Visualization Library: Visualization Library Reference Documentation

Visualization Library

 A lightweight C++ OpenGL middleware for 2D/3D graphics 		[Home] [Tutorials] [All Classes] [Grouped Classes]
  • Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files

Visualization Library Reference Documentation

v2009.08

www.visualizationlibrary.com

Basic Information

  • Introduction
  • Gallery
  • Learning VL
  • Features Overview
  • Contacts

Downloads

  • Download page
  • Changelog

Getting Started

  • Compiling and Installing VL
  • Architecture Diagrams
  • OpenGL - Visualization Library Feature Mapping
  • Tutorials

API Documentation

  • Grouped Classes and Functions
  • Annotated Class List
  • Alphabetical Class List
  • Class Hierarchy

Community

  • Users' Forum
  • Newsletter
  • VizLibrary on Twitter
  • Contributing

Licenses and Credits

  • Licensing
  • Professional Edition License (VPL)
  • GNU General Public License version 3
  • Credits

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.
Permission is granted to use this page to write and publish articles regarding Visualization Library.


Visualization Library: Introduction

  • Related Pages
  • Namespaces
  • Classes
  • Files
Visualization Library Reference Documentation

Introduction

Welcome to Visualization Library!

Visualization Library has been developed by Michele Bosi. He can be contacted at:

  • info@visualizationlibrary.com
  • http://www.linkedin.com/in/michelebosi

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

Visualization Library can be used to develop applications for 2D and 3D scientific visualization (material sciences, geosciences, oil and gas exploration etc.), civil and military training and simulation, virtual reality, augmented reality, visual simulation, plotting, data mining and visualization, presentations, multimedia applications, special effects, 2D and 3D games and so on.

Visualization Library is not a pre-packaged rendering engine or a game engine, as this would limit its scope. Visualization Library has been designed to be a fine-grained platform upon which 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 very thin high-performance layer on top of it. The result is that many OpenGL functions and features have a 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. If you need a simple, flexible, portable and fast 3d graphics platform that can be quickly integrated in your applications then you should consider using Visualization Library.

If you would like to be notified of the latest developments, events and news regarding Visualization Library subscribe to Visualization Library Newsletter.

Do not forget to check out also our Twitter page at http://twitter.com/VizLibrary.

Visualization Library Design Key Features and Goals
  • Code developed in standard C++/STL, inspired by Boost and Design Patterns.
  • Portable across Windows, Linux and Mac OS X operating systems (32 and 64 bits).
  • Friendly API using OpenGL wording and conventions.
  • Minimalistic, efficient, professional, reliable.
  • 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.

  • 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, Pixel and Vertex Buffer Objects etc. while at the same time retains full compatibility with OpenGL 1.1 class hardware.

  • Designed for OpenGL 2.1, inspired by OpenGL 3.x and OpenGL ES principles:

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 and OpenGL 3.x principles. Note that at the moment Visualization Library fully supports OpenGL 2.1 plus most of the extensions included in OpenGL 3.x. Support to OpenGL 3.x and OpenGL ES will be available in the future.

  • 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. If you are interested in the topic you might want to use Visualization Library in conjunction with the following: Intel® Threading Building Blocks, VR Juggler, Chromium.

Short Feature List
  • 3D file formats supported: 3DS, OBJ, PLY (binary and ascii), STL (binary and ascii), AC3D, MD2.
  • Image file formats supported: JPG, PNG, TGA, TIFF, BMP, DDS, DICOM.
  • GUI bindings: Win32, MFC, Qt4, wxWidgets, SDL, GLUT, Cocoa.
  • Volume visualization: direct volume rendering via screen aligned slices, isosurface extraction via marching cubes.
  • 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: 1D, 2D, 3D textures, cubemaps, texture arrays, texture rectangles, multi-texturing, render to texture, texture coordinate generation, texture combiners, mipmapping and mipmaps generation, anisotropic filtering, compressed textures, depth textures, integer textures, non normalized textures.
  • OpenGL Shading Language support.
  • Geometry Shaders support.
  • GLSL multiple render targets.
  • OpenGL accelerated 2D vector graphics.
  • Multisampling.
  • Framebuffer Objects support.
  • Vertex Buffer Objects support.
  • Pixel Buffer Objects support.
  • Display Lists support.
  • Hierachical frustum culling against boxes and spheres.
  • Multiple cameras, multiple scene managers, multiple renderings.
  • High quality unicode text rendering and text manipulation functions and classes.
  • GLSL based C++ vector/matrix library.
  • Hierachical bounding volume scene manager.
  • Kd-Tree hierachical scene manager.
  • Portal/sector scene manager.
  • Kd-Tree based terrain scene manager (with GPU acceleration if available).
  • Hierarchical matrix transformations.
  • Morphing animations (with GPU acceleration if available).
  • Geometry instancing.
  • Geometry Level of Detail.
  • Shader Level of Deatil.
  • Multipassing.
  • Render state sorting and minimization.
  • Automatic transparency management.
  • Billboards.
  • Clipping planes.
  • All OpenGL lighting models/materials supported.
  • Extensible resource system to support new resource types.
  • Geometry optimization functions, triangle reduction/decimation, double vertex removal etc.
  • Rich image manipulation routines.
  • Molecular visualization.
  • Extrusion generation.
  • Linear and Catmull-Rom path interpolation.
  • Bicubic Bézier surfaces.
  • Edge and silhouette enhancement.

And much more... see Features Overview for a complete overview of Visualization Library's features.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Learning Visualization Library

  • Files
Visualization Library Reference Documentation

Learning Visualization Library

We assume that you already know C++, you know how to compile a program and you have some understanding of linear algebra and geometry.

If after reading the Introduction page you want to know more about Visualization Library's features and design then take a look at the Features Overview and Grouped Classes and Functions pages.

A quick look also at the Annotated Class List will give you a more detailed idea of the available features.

If you would like to have a visual understanding of Visualization Library's architecture then take a look at the Visualization Library Architecture page.

If you are an OpenGL programmer and want to know how an OpenGL feature maps to Visualization Library (or the other way around) you will find the OpenGL vs VL Feature Mapping page very useful.

Several tutorials and examples are available from the Quick Start Guides page to get you started with the most important VL programming concepts.

In the src/examples/ directory you will also find a set of example applications demonstrating how to implement various techniques using Visualization Library.

Do not forget that you can search through the online documentation using the Search for box on the top-right corner of every page.

If you would like to be notified of the latest developments, events and news regarding Visualization Library subscribe to Visualization Library Newsletter.

OpenGL Background
Since a VL programmer is essentially a C++ OpenGL programmer, some kind of OpenGL background is highly desirable in order to effectively use Visualization Library.

If you are just starting your journey in the 3D graphics realm then the OpenGL SuperBible will provide you with very good theoretical and practical foundations.

More advanced users will absolutely need the OpenGL Shading Language and at the OpenGL Programmers Guide 6th edition.

You might also want to bookmark the OpenGL 2.1 Reference Pages as they are extremely useful for the everyday work.

GUI Bindings
Chances are that you are using a GUI framework that is officially supported by Visualization Library, like Win32, MFC, QT4, SDL, GLUT and Cocoa. If you would like to see how to use Visualization Library within a particulare GUI framework then take a look at the src/examples directory, which contains a set of minimalistic applications that demonstrate how to use VL with several GUI frameworks.

Good luck and have fun!

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Visualization Library Features Overview

Visualization Library Reference Documentation

Visualization Library Features Overview

Intro
Below is a descriptive introduction to Visualization Library key features and functionalities. Take a couple of minutes to read this page as you will find a lot of useful information about how VL works, how to take full advantage of VL's power and why you should use VL rather than plain OpenGL or other libraries.

A Lightweight Modern OpenGL Middleware

The first and most important feature of Visualization Library is surely its simple and straightforward design. Every aspect of Visualization Library has been developed keeping in mind this few but important principles:

  • Lightweight: VL is a low-level, fast, fine-grained C++ middleware on top of OpenGL.
  • Integrability: VL is simple to integrate into your framework, you do not need to adapt your own framework to VL. Moreover, VL has been designed to seamlessly work side by side with other rendering frameworks, thus allowing a gradual and risk-free transition to VL.
  • Accurate OpenGL mapping: VL exposes OpenGL functionalities in a manner that reproduces as closely as possible the original OpenGL semantics and adopts as closely as possible the OpenGL wording and conventions.
  • Simplification: Visualization Library development has been heavily inspired by the idea of simplification promoted by OpenGL 3.x and OpenGL ES 2.0. For this reasons many legacy OpenGL features like edge flags, accumulation buffers, feedback mode, the inefficient immediate mode commands etc. are not used by VL. While retaining full compatibility with OpenGL 1.1 class hardware, this ensures that Visualization Library size is kept to a minimum and that only the most efficient rendering paths are used.
  • Full support to modern GPUs: Visualization Library architecture has been designed from the ground up to take full advantage of the most modern OpenGL features like OpenGL Shading Language, Vertex and Pixel Buffer Objects, Framebuffer Objects, Occlusion Culling, Multiple Render Targets, Geometry Shaders, Geometry Instancing and so on, thus providing all the necessary tools to create extraordinary 3D graphics applications.
  • Compatibility: probably the single most important factor that made OpenGL the de-facto standard in the 3D graphics industry has been its ability to evolve and to provide always new features with a consistent API, while at the same time maintaining backwards compatibility. Learning from this lesson, mantaining compatibility even with OpenGL 1.1 class hardware is considered a top priority for Visualization Library.
  • Glass box: many rendering engines implement their functionalities as a "black box". This approach usually tends to simplify the life of the casual user as many details are hidden inside the "black box". Instead with VL the user has transparent access to all the switches and buttons provided by OpenGL from a friendly C++ object oriented framework. This kind of approach might be a bit intimidating at the beginning but the extra effort will be well invested, as you will soon be able to create your own rendering pipeline, your own shading model, your own post processing effects or something that no one has even conceived yet!
  • Uber-scene-graphs? OpenInventor/Peformer clones? no thanks! While many rendering engines still advertise proudly their "scene-graph oriented architecture", more and more developers are starting to realize that a uber-scene-graph architecture is far from being an optimal data structure for modern 3D engines. Visualization Library, with its radical design, is a remarkable example of this trend and promotes the notion of data structure separation and specialization. Put in simple words, while a uber-scene-graph 3D engine uses a single, overloaded data structure (usually a DAG) to represent transforms, spatial/visibility relationships, material properties etc, Visualization Library separates these concepts, utilizing for each of them an optimal domain-specific data structure (possibly referencing each other). This intuitive approach not only provides superior performances but allows you to customized and extend each aspect independently from all the others.
  • Debug friendly behaviour: developing modern 3D graphics applications requires every day more and more human resources in terms of programmers and skills. It is a fact that a considerable part of such resources is spent for bug fixing and feature stabilization. This is especially true for 3D graphics applications where cutting-edge technology and highly customized tools are often developed in-house. In order to facilitate the developer's job, Visualization Library has been designed to perform a number of checks that help the developer to identify possible bugs as early as possible and to issue sensible and detailed error messages.
  • Reliable: in order to privide the maximum degree of code robustness and reliability Visualization Library comes with a set of regression tests which perform hundreds of tests. Such tests are run consistently throughout the development and especially before every release. Furthermore, the regression test framework has been developed to run under all the platforms and GUI backends supported by Visualization Library.

GUI Bindings

Even if Visualization Library can be used wherever there is an OpenGL context, several utility classes are available to facilitate even more the integration of VL into your applications. VL officially supports all the most popular C/C++ GUI frameworks such as Win32, MFC, Qt4, wxWidgets, GLUT, SDL and Cocoa (experimental). A "GUI binding" mainly consists of a window class that, using the framework-specific API, is capable of creating and setting up a vl::OpenGLContext, manages unicode keyboard input, mouse events, file drag and drop, OpenGL resource sharing, framebuffer swap, multiple OpenGL windows and many other things. Thanks to the many ready-to-use GUI bindings available, the developer can start using Visualization Library in just a few minutes and has only to concentrate on creating great 3D graphics applications!

Classes
vlWin32::Win32Window, vlMFC::MFCWindow, vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlGLUT::GLUTWindow, vlSDL::SDLWindow

OpenGL Shading Language

There is no doubt that the OpenGL Shading Language is the present and the future of OpenGL. For this reason Visualization Library architecture has been carefully designed from the ground up to exploit the full power of the OpenGL Shading Language and to make it accessible to everyone. VL makes the OpenGL Shading Language so simple to use that setting up a complete GLSL program requires just a couple of lines of code! Advanced features such as geometry instancing, texture arrays, geometry shaders, multiple render targets etc. are fully supported as well.

Classes
vl::GLSLProgram, vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader, vl::Uniform

Related Pages
  • OpenGL Shading Language

Volume Rendering

Visualization Library also provides a set of simple and powerful classes to perform volume rendering, isosurface extraction and 3D plots from volume data. The vlVolume::SlicedVolume class implements all the functionalities needed to perform a direct volume rendering with and without OpenGL Shading Language. When the OpenGL Shading Language is used Blinn-Phong lighting and transfer function computations are performed in realtime. The vlVolume::MarchingCubes is a powerful class that uses an efficient implementation of the marching cubes algorithm to extract one or more isosurfaces from one or more volume data. The vlVolume::VolumePlot is an utility class that takes a volume data and automatically extracts the isosurface at the specified threshold and generates a plot with labels.

Classes
vlVolume::SlicedVolume, vlVolume::MarchingCubes, vlVolume::VolumePlot

Related Pages
  • Volume Rendering and Isosurfaces Extraction with Marching Cubes Tutorial
  • Volume Rendering with Transfer Functions and Lighting Tutorial

Hardware Accelerated 2D Vector Graphics

The mission of Visualization Library is not only to provide cutting edge technology for 3D graphics application but also to open the world of hardware accelerated 2D graphics for applications like plotting, charting, data mining and many others. The lack of support for hardware accelerated 2D graphics is almost embarrassing and even when such support is claimed, very few times the performances come close to the full potential of modern GPUs. Since Alpha 3.0 Visualization Library enables true hardware accelerated 2D vector graphics via the following simple and intuitive classes: vlVG::VectorGraphics and vlVG::SceneManagerVectorGraphics. Using such classes the developer has full access to standard functionalities like boxes, lines, ellipses, tansforms, clipping etc. but also to advanced features like texturing, point sprites, stencil operations, antialiasing, high quality text rendering and all the blending modes supported by OpenGL! All this using an intuitive interface that optimally generates vl::Actor, vl::Geometry, vl::Shader etc. objects and commands that are rendered at full speed!

Classes
vlVG::VectorGraphics, vlVG::SceneManagerVectorGraphics

Related Pages
  • OpenGL Accelerated 2D Vector Graphics

High Performances

In order to maximize the rendering performances Visualization Library employs several techniques:

  • Vertex Buffer Objects: allows Visualization Library to store the geometrical information directly on the GPU, thus neutralizing the RAM-to-GPU communication bottleneck and maximizing the GPU triangle throughput.
  • Pixel Buffer Objects: allows Visualization Library to store the image data directly on the GPU, thus neutralizing the RAM-to-GPU communication bottleneck and maximizing the performances of image rendering and copy operations.
  • Display Lists: allows Visualization Library to compile a set of rendering commands which can be recalled later with a single function call. Since the compilation process optimizes the rendering commands and data, using display lists can bring a remarkable performance boost for some applications, in particular when used with static geometries.
  • Render State Sorting: in order to minimize the amount of rendering commands sent to the GPU Visualization Library sorts the visible objects based on their rendering states.
  • Lazy (or Delta) Render State Setup: in order to minimize the amount of rendering commands sent to the GPU Visualization Library also implements an efficient mechanism that allows Visualiation Library to setup only the rendering states that have changed from the last rendered object.
  • Occlusion and Hierachical Frustum Culling: in order to minimize the amount of objects sent through the rendering pipeline Visualization Library uses several culling techniques such as hierachical frustum culling based on bounding volume hierachies and occlusion culling. For example the vl::SceneManagerActorKdTree class uses a KdTree to hierachically determine the objects within the view frustum. KdTrees are an efficient and flexible data structure that can effectively replace even quadtrees and octrees. The vl::SceneManagerPortals on the other hand implements a portal based hidden suface removal which is very efficient to render highly occluded environments. In addition VL natively supports also the GL_ARB_occlusion_query extension, which allows your applications to exploit the benefits of true OpenGL-accelerated occlusion culling! Other culling techniques like PVS (potentially visible set) etc. can be used implementing an appropriate vl::SceneManager.
  • LOD (Level Of Detail): in order to accelerate the rendering process, Visualization Library supports both geometrical and shader based LOD. With geometrical LOD you can render objects that are far away using a lower level of detail, i.e. using less vertices and polygons. With shader based LOD you can render objects that are far away using a simpler shader or using less rendering passes, while at the same time you can render objects that are close to the camera using more detailed and complex shaders and geometries.

Classes and Functions
vl::Actor, vl::Effect, vl::LODEvaluator, vl::DistanceLODEvaluator, vl::Actor::setLODEvaluator(), vl::Effect::setLODEvaluator(), vl::Renderable::setDisplayListEnabled(), vl::Geometry::setVertexBufferObjectsEnabled()

Related Pages
  • OpenGL-Accelerated Occlusion Culling Tutorial
  • Portal-Based Culling and Scene Management Tutorial
  • Rendering Order

Flexible Scene Management

Visualization Library uses a simple and extensible scene management system and provides several ready-to-use scene managers:

  • vl::SceneManagerActorTree - a generic bounding volume hierarchy based scene manager.
  • vl::SceneManagerActorKdTree - a kd-tree based scene manager which is also a generic and efficient replacement for quadtrees and octrees.
  • vl::SceneManagerPortals - a scene manager that implements porta/sector-based hidden surface removal, especially suitable to render highly occluded environments.

Scene managers using other techniques like PVS (potentially visible set) etc. can be also used implementing an appropriate vl::SceneManager subclass.

Note that Visualization Library allows you to seamlessly use multiple scene managers at the same time!

Classes
vl::SceneManager, vl::SceneManagerActorTree, vl::SceneManagerActorKdTree, vl::SceneManagerPortals, vl::Rendering

Related Pages
  • Portal-Based Culling and Scene Management Tutorial

Automatic Transparency Management

Visualization Library automatically sorts transparent objects in order to perform a correct rendering. The user is not required to setup any special "transparent bin" or to define any explicit rendering order as Visualization Library automatically detects and manages transparent objects. However, the developer retains full control over the object rendering order via the vl::Actor::setRenderRank(), vl::Actor::setRenderBlock() and vl::Effect::setRenderRank() methods. The developer can also install a custom vl::RenderQueueSorter using the vl::Rendering::setRenderQueueSorter() method.

In case you need to render a convex transparent object then you have to ensure that its polygons are properly depth-sorted. You can do this by simply installing a vl::DepthSortCallback to your vl::Actor.

Classes
vl::DepthSortCallback, vl::Actor, vl::Effect, vl::Rendering, vl::RenderQueueSorter

Related Pages
  • Rendering Order

Shader and Geometry: LOD, Multipassing and Animation

Visualization Library can naturally manage complex scenarios where Effects and/or Actors define several LODs with possibly multiple rendering passes each and with animations defined for each pass and LOD. Visualization Library not only manages naturally such scenarios but also ensures that the animations are computed only once per frame, for only the visible LODs, for each pass, for both Shaders and Actors.

Classes
vl::Actor, vl::Effect, vl::Shader

OpenGL Shading Language Based C++ Math Library

Visualization Library features a complete vector and matrix math library designed to replicate as closely as possible in C++ the OpenGL Shading Language types and functons. VL's math library provides the developer with 2, 3, and 4 components vector (float, double, int, unsigned int etc.), 2x2, 3x3, 4x4 float and double matrices, vector/vector, vector/matrix and matrix/matrix operations, a quaternion class to conveniently represent and manipulate rotations and orientations and much more. The GLSLmath.hpp module also provides C++ implementations of the most important OpenGL Shading Language scalar and vector functions.

Classes
vl::dvec4, vl::dvec3, vl::dvec2, vl::fvec4, vl::fvec3, vl::fvec2, vl::ivec4, vl::ivec3, vl::ivec2, vl::uvec4, vl::uvec3, vl::uvec2, vl::dmat4, vl::dmat3, vl::dmat2, vl::fmat4, vl::fmat3, vl::fmat2, vl::quat, vl::AABB, vl::Sphere, vl::RectI, vl::RectF.

Related Pages
  • 3D Maths with Visualization Library

Framebuffer Objects

Modern OpenGL applications make heavy use of framebuffer objects (EXT_framebuffer_object extension) to implement efficient render to texture, offscreen rendering and post processing effects. Visualization Library has been designed to take full advantage of framebuffer objects where available and makes rendering to a framebuffer objects as easy as using the standard OpenGL framebuffer. Besides providing the standard framebuffer object functionalities, Visualization Library goes the extra mile, delivering first-class support for framebuffer objects also in conjuction with many other extensions like EXT_texture_array, EXT_framebuffer_blit, EXT_framebuffer_multisample, EXT_packed_depth_stencil, ARB_geometry_shader4, ARB_texture_rectangle, ARB_texture_cube_map, 3D textures and so on.

Classes
vl::FBORenderTarget, vl::FBOAttachmentAbstract, vl::FBORenderbufferAttachment, vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBODepthStencilBufferAttachment, vl::FBOStencilBufferAttachment, vl::FBOTexture1DAttachment, vl::FBOTexture2DAttachment, vl::FBOTexture3DAttachment, vl::FBOTextureAttachment, vl::FBOTextureLayerAttachment, vl::BlitFramebuffer

Automatic Progressive OpenGL Extension Management

The extension mechanism provided by OpenGL has proved to be one of the key factors for the success and longevity of this elegant API. However, exploiting effectively all the possible hardware configurations and all the available extensions can easily become an overwhelming task. For this reason Visualization Library tackles this task for you, querying the available extensions in an automatic manner (via GLEW) and selecting and using the most appropriate ones to deliver maximum performance and stability. We refer to this intelligent selection mechanism as "Progressive OpenGL Extension Management". The principle is very simple, wherever an OpenGL feature is requested not only Visualization Library looks for an extension to support it but looks for the best implementation of that functionality, checking first among the functions which are directly supported by the current OpenGL implementation, then looking among the ARB extensions, then looking among the EXT extensions, then among the vendor specific extensions if necessary.

Advanced Texturing

Taking advantage of the latest and most advanced texturing techniques is a breeze with Visualization Library. The vl::Texture class provides out of the box and transparent support for all the texture formats supported by OpenGL 3.x! This includes multitexturing support, 1D, 2D and 3D textures, cubemap textures, texture rectangles, 1D and 2D texture arrays, automatic mipmaps generation (hardware-accelerated where available), anisotropic filtering, compressed textures, depth textures, integer textures, non normalized floating point textures, and much more! You can also easily manipulate texture parameters, texture matrices, automatic texture coordinate generation and texture environment settings using a few intuitive classes!

Classes
vl::Image, vl::Texture, vl::TexParameter, vl::TexEnv, vl::TexGen, vl::TextureMatrix, vl::TextureUnit, vl::CopyTexSubImage1D, vl::CopyTexSubImage2D, vl::CopyTexSubImage3D, vl::Shader

Related Pages
  • Texturing

Unicode support, Text Manipulation and Rendering

Text rendering and manipulation (not to mention Unicode support) has always been the Achilles' heel of many 3D graphics applications. Visualization Library inverts this situation and brings to VL developers first class Unicode support, high-quality text rendering, and feature-rich text manipulation classes. Visualization Library not only provides high-quality Unicode text rendering (based on FreeType) but also a set of powerful text manipulation classes that can be considered a library on their own. In particular the vl::String class implements a feature-rich Unicode text manipulation engine that can be used not only to load, parse, split, trim, search and replace text but that can interoperate with std::string and std::wstring, can encode to/from Latin1, UTF8 and UTF16BE/LE, can perform Unicode-aware case transformations and much more!

Classes
vl::Text, vl::Font, vl::String, vl::TextStream, vl::Say

Related Pages
  • Text Rendering and Manipulation

Virtual File System

In order to load and write resources VL uses an extensible system called "Virtual File System". Anything that can be written to or read from can be implemented as vl::VirtualFile. Anything that is capable of containing or enumerating VirtualFiles can be implemented as a vl::VirtualDirectory. Using this mechanism VL can read and write files that are stored in the RAM, on a disk, that are compressed in an archive or that are transparently downloaded from an HTTP connection. VL provides out of the box support for memory files and directories, disk files and directories, zipped files and directories, and a codec to read and write gz compressed files. This mechanism can be easily extended to implement VirtualFiles and VirtualDirectories that operate over Internet or that encode, compress or encrypt stream of data on the fly, in a manner that is completely transparent to Visualization Library's resource IO functions!

Classes
vl::GZipCodec, vl::VirtualFile, vl::VirtualDirectory, vl::DiskFile, vl::DiskDirectory, vl::MemoryFile, vl::MemoryDirectory, vl::ZippedFile, vl::ZippedDirectory, vl::FileSystem.

Related Pages
  • Loading and Saving Resources

Image IO and Manipulation

Visualization Library provides support to all the most common image file formats like PNG, JPG, DDS, DICOM, TIFF, TGA and BMP. Not only vl::Image is capable of storing any kind of texture (2D, 3D, cubemaps, arrays, compressed images etc.) supported by OpenGL, but can also load and write them on a variety of virtual devices (even custom defined) using the Virtual File System mechanism. vl::Image can also store its data on a local memory buffer or directly on the GPU memory, taking full advantage of the ARB_pixel_buffer_object extension. Moreover, vl::Image allows you to perform operations like sampling the pixel of an image regardless of it's data format and type, and convert among several image formats and types, like converting a GL_RGBA/GL_FLOAT image into a GL_LUMINANCE/GL_UNSIGNED_BYTE one (automatically performing a color to grayscale conversion)!

Classes and Functions
vl::Image, vl::Image::convertType(), vl::Image::convertFormat(), vl::Image::sample(), vl::Image::sampleLinear(), vl::Image::readPixels()

Extensible Resource I/O System

Visualization Library implements an intuitive and extensible mechanism to load and write a broad range of resource types such as images, 3d file formats like 3DS, OBJ, PLY, STL, AC3D etc. This mechanism is centered around three simple concepts: 1) a resource database (vl::ResourceDatabase) that stores the information loaded or to be written, 2) a set of resource load-writers (vl::ResourceLoadWriter) that implement the specific algorithm which reads and/or writes a specific resource type from/to a resource database, 3) a manager class (vl::LoadWriterManager) that coordinates the resource load-writers. This way not only it is possible to load and write resources in a simplified and centralized way, regardless of the resource type, but the resource types supported can be extended by the user implementing a new vl::ResourceLoadWriter and registering it to the vl::LoadWriterManager. Futhermore, the user can also provide a customized vl::ResourceLoadWriter to override the ones shipped with Visualization Library if it is needed. When, for example, an application requests an image using the vl::loadImage() function, the appropriate vl::ResourceLoadWriter is picked by the vl::LoadWriterManager, and the resource is loaded from the specified path or vl::VirtualFile.

Classes
vl::ResourceDatabase, vl::ResourceLoadWriter, vl::LoadWriterManager

vl::LoadWriterDICOM, vl::LoadWriterPNG, vl::LoadWriterJPG, vl::LoadWriterTIFF, vl::LoadWriterDDS, vl::LoadWriterTGA, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriter3DS, vl::LoadWriterOBJ, vl::LoadWriterAC3D, vl::LoadWriterPLY, vl::LoadWriterSTL, vl::LoadWriterMD2

Related Pages
  • Loading and Saving Resources

Terrain Scene Manager

Some applications do not need complex LOD or CLOD management algorithms to display height fields or terrains, either because the data displayed has a limited size or because particular constraints are applied to the camera (like in RTS games for example) for which only a limited portion of the terrain is visible at a given time. This applications can greatly benefit from the vl::Terrain scene manager which implements a fool-proof, high-precision (8, 16 and 32 bits heightmaps) and efficient terrain/heightfield generation and management system. All the user has to provide is a texture for the terrain, a heightfield image and a detail texture following very simple and precise guidelines. The vl::Terrain class takes care of all the rest, like dividing the provided images into chunks, generating the geometry, generating the kd-tree, computing the appropriate texture coordinates in order to prevent seams and so on. If the OpenGL Shading Language is available, the vl::Terrain class can also store the heightmap directly on the GPU and can generate the geometry on the fly using a technique called "vertex texture fetch" (http://developer.nvidia.com/object/using_vertex_textures.html). This technique allows the application to save GPU memory and to manage even greater terrain databases at a higher speed.

Classes
vl::Terrain

Related Pages
  • Simple Terrain

Memory Management

Visualization Library memory management has been designed following three main principles:

  • Smart-pointers: Visualization Library implements a simple and friendly reference-count based memory management system (via the vl::ref<> class) which greatly simplifies the life of the developer and adds robustness to the application.
  • Resource sharing: to optimize the resource usage and the rendering performances Visualization Library has been developed to provide the highest possible degree of resource sharing throughout the library. For example two vl::Effect can share tha same vl::Shader, two vl::Shader can share the same render states, two vl::Actor can share the same vl::Transform, vl::Geometry or vl::Effect, two vl::Geometry can share the same vertex attributes and so on.
  • Quick allocation: complex applications often need to allocate and deallocate quickly hundreds of thousands of objects. For this reason each class of Visualization Library has been designed to be allocated as quickly as possible and to issue as few dynamic memory allocations as possible.

Related Pages
  • Memory Management

Geometrical Primitives

Visualization Library provides the developer with several ready-to-use and configurable geometrical primitives like bicubic bezier surfaces, extrusions, cubes, spheres, toruses, grids, pyramids, circles, point clouds etc.

classes
  • vl::BezierSurface
  • vl::Extrusion

Functions
  • vlut::makeIcosphere()
  • vlut::makeCylinder()
  • vlut::makeUVSphere()
  • vlut::makeTorus()
  • vlut::makeCone()
  • vlut::makePyramid()
  • vlut::makeBox()
  • vlut::makeGrid()
  • vlut::makeIcosahedron()
  • vlut::makePoints()
  • vlut::makeCircle()
  • vlut::makeCapsule()

Related Pages
  • Geometrical Primitives
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Contacts

Visualization Library Reference Documentation

Contacts

Visualization Library has been developed by Michele Bosi.

Michele can be contacted at:

  • info@visualizationlibrary.com
  • http://www.linkedin.com/in/michelebosi

If you are aware that an individual or organization is infringing Visualization Library's licensing terms you can report the issue at fraud@visualizationlibrary.com.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Changelog

Visualization Library Reference Documentation

Changelog

Visualization Library 2009.08.800

  • String class now based on wchar_t.
  • String class documentation.
  • Fixed Max OS X compilation.
  • Using stricter warning levels.
  • Fixed several warnings.
  • Fixed typos and non returning functions.
  • Fixed bug in OpenGL 2.0 support.

Visualization Library 2009.07.640

  • Extended documentation and tutorials.
  • API improvements and cleanup.
  • Fixed MFC compilation issues.
  • Fixed Mac OS X compilation issues.

Visualization Library 2009.07 RC3

  • Extended documentation and tutorials.
  • API improvements and cleanup.

Visualization Library 2009.07 RC2

  • FileSystem::locateFile() enhanced.
  • 3DS, OBJ, AC3D texture locating enhanced.
  • Fixed sources installation.

Visualization Library 2009.07 RC1

  • OpenGL & VL enables documentation.
  • setEnabled/isEnabled policy.
  • vl::PolygonDephtSorting bug fixes and tutorial.
  • Picking example.
  • Image and ReadPixels enhancements.
  • Transparency and Polygon Depth Sorting Tutorial.
  • Antialiasing and Multisampling Tutorial.
  • Billboards Tutorial.

Visualization Library 2009.07 Beta 2

  • Bug fixes.
  • Documentation updates.
  • API stabilization.

Visualization Library 2009.07 Beta 1

  • Added new classes to perform edge enhancement: vl::EdgeRenderer, vl::EdgeExtractor
  • Added new Edge Enhancement and Wireframe Rendering demo and tutorial.
  • Added new vl::SceneManagerPortals, a scene manager that implements sector/portal-based occlusion culling.
  • Added new Portal-Based Culling and Scene Management demo and tutorial.
  • Added support OpenGL-accelerated occlusion culling via the GL_ARB_occlusion_query extension.
  • Added new Hardware Occlusion Culling demo and tutorial.
  • Added new vl::BezierSurface class to manipulate and render complex bicubic Bézier patches and surfaces.
  • Added new Bicubic Bézier Patches and Surfaces demo and tutorial.
  • Added new vlMolecule module for molecular visualization. See also vlMolecule::Molecule and vlMolecule.
  • Added new Molecule Visualization demo and tutorial.
  • Added new vl::Tessellator class to tessellate complex, concave and self-intersecting polygons.
  • Added new Polygon Tessellation demo and tutorial.
  • Added new vl::Extrusion class to generate 3d geometry by extruding a 2d silhouette along 3d paths.
  • Added new Geometry Extrusions demo and tutorial.
  • Added new vl::Interpolator, vl::LinearInterpolator, vl::CatmullRomInterpolator and other classes to interpolate over a set of values.
  • Added new Interpolators demo and tutorial.
  • Simplified Actor and Effect lod management; quicker Actor and Effect allocation.
  • Fixed x86 compilation and portable debug interrupt implementation.
  • RenderingSequence dropped -> Implemented a new powerful rendering-tree mechanism.
  • MessageBox used to notify failed checks on Win32.
  • New VisualizationLibrary class.
  • Nicely manage degenerate quads normal computation.
  • Enhanced test framework.

Visualization Library Alpha 3.2.440

  • Direct volume rendering via vlVolume::SlicedVolume, supporting gradient, lighting and transfer function pre-computation, realtime GLSL-based Blinn-Phong lighting and transfer function computation.
  • New App_VolumeRendering.hpp demo demonstrating various volume rendering techniques based on the vlVolume::SlicedVolume class, see the tutorial section for more information.
  • Isosurface extraction with the new vlVolume::MarchingCubes class!
  • New App_MarchingCubes.hpp demo demonstrating various techniques using marching cubes, including multiple volume rendering, transparency management, volume color via texturing and vertex color, 3D plots and even two animated metaballs demos! See the tutorial section for more information.
  • DICOM file format support (read/write).
  • New vlVolume::VolumePlot class to generate annotated 3D plots from volume data.
  • Dramatic performance improvements up to 10x for STL, PLY and OBJ import.
  • TGA, TIFF, JPG and PNG files can now save 1D, 2D, 3D and cubemap images.
  • New Image::makeNonUniformColorSpectrum() function, especially useful to colorize volume data.
  • Quicker vl::DepthSortCallback: sorts only when the camera or actor matrix changes.
  • Enhanced Virutal File System functionalities: locate directories, test disk directory existence, enumerate files and directories, other misc enhancements.
  • New vl::Image related functions: vl::loadImagesFromDir(), vl::assemble3DImage().
  • Simple KeyValues class to manage a set of key/value pairs.
  • Now shaders automatically detext if the source passed is a path to a file or is an actual shader text

Visualization Library Alpha 3.1.300

  • New official wxWidgets bindings! See vlWX::vlWXGLCanvas for more information.
  • New vl::STLLoader class: loads ascii and binary STL files.
  • New vl::PlyLoader class: more powerful loader for ascii and binary (little and big endian) ply files.
  • Callback mechanism to execute operations on resource load and write, see vl::LoadCallback and vl::WriteCallback.
  • New vl::GeometryLoadCallback class to perform transformations and optimizations on the loaded vl::Geometry.
  • New vl::GZipCodec class to load/write gz files.
  • New template math classes vl::Matrix4, vl::Matrix3, vl::Matrix2, vl::Vector4, vl::Vector3, vl::Vector2.
  • New matrix classes vl::imat4/3/2, vl::umat4/3/2.
  • New vector classes vl::svec4/3/2, vl::usvec4/3/2, vl::bvec4/3/2, vl::ubvec4/3/2.
  • New array classes vl::ArrayFVec4/3/2, vl::ArrayDVec4/3/2, vl::ArrayIVec4/3/2, vl::ArrayUVec4/3/2 etc.
  • Simplified vertex array system based on vl::Array template class.
  • vl::DoubleVertexRemover: much quicker implementation.
  • New vl::TriangleStripGenerator class.
  • New vl::Geometry optimization functions: vl::Geometry::mergeTriangleStrips(), vl::Geometry::convertPrimitivesToDrawArrays(), vl::Geometry::sortVertices().
  • New App_ModelProfiler applet to measure the performance of different geometrical optimization techniques.
  • Improved vl::Terrain GPU algorithm for ATI cards.
  • VBO creation outside of the rendering loop.
  • Improved DepthSortCallback: sorts all types of DrawElements*.
  • Fixed potential font deallocation problem.
  • Image::copySubImage() function to copy a rectangular sub-area of an image, supports all the most common image formats and types.

Visualization Library Alpha 3.0.291

  • Automatic compilation of PNG, JPG, ZLib and FreeType libraries.
  • New template-based ResourceDatabase implementation: simpler and more flexible.
  • Fixed bugs and compilation issues for Ubuntu and Fedora 64 bit systems.
  • Fixed permission settings in tgz and tar.bz2 files.
  • ZippedFile now supports the seek() operation.

Visualization Library Alpha 3.0.290

  • Mac OS X platform support plus experimental Cocoa GUI bindings! A huge thanks goes to Brent Fulgham for his help and feedback!
  • MFC GUI bindings! Again, thanks to Brent Fulgham for his help and feedback! Includes support to fullscreen windows, multisampling, keyboard and mouse management, file drag&drop, OpenGL resource sharing, child and top windows support etc.
  • VectorGraphics and VectorGraphicsScene classes to perform advanced OpenGL hardware-accelerated 2D rendering.
  • Terrain scene manager: implements a simple, kdtree/chunk-based, GPU accelerated (if available), highly memory efficient terrain rendering system (no LOD yet). The system lets you use very large height-maps and texture maps that exceed the GPU's maximum texture size. If the host supports OpenGL Shading Language the scene manager keeps on the GPU memory only the heightmap and generates all the geometry on the fly, thus allowing very large/detailed terrains.
  • Extensible resource IO system (see below)
  • ShaderNode class to conveniently managed complex hierarchies of Shaders.
  • Progressive OpenGL extension management: if the same functionality is supported via multiple extensions now VL selects and uses the best available: first checks direct support by the OpenGL implementation, then checks ARB extensions, then checks EXT extensions.
  • Broader video card compatibility including support to integrated ATI and Intel chipsets.
  • TrackballManipulator new controls and more precise: now you can zoom in/out with the right mouse button, pan the camera up/down left/right with the middle button and rotate with the left button.
  • Near/far clipping plane optimizations. The camera can now optionally optimize the near/far clipping planes based on the visible objects enhancing the everall rendering quality, minimizing z-fighting.

RESOURCE IO
  • JPG file format support for both load and save.
  • PNG file format support for both load and save.
  • Plug-in based ResourceLoaderWriter system. Now you can load and write any resource including 3d files and images using the methods LoaderWriterManager::loadResource()/writeResource(). The appropriate ResourceLoaderWriter will be picked up and used for the specified file type. You can register your own ResourceLoaderWriter to support more file formats or to overried existing ResourceLoaderWriter too!
  • Image: new methods convertType() and convertFormat() to convert images from/to all the OpenGL 1.1 type/format combinations! For example you can convert an IT_FLOAT/IF_RGBA to a IT_UNSIGNED_SHORT/IF_LUMINANCE image! In this case the image is also automatically converted from rgb to gray scale! The alpha channel is also retained when possible.
  • Image: new methods sampleLinear() and sample() to perform nearest-point or bilinear filtering sampling of an image. This functions support all the OpenGL 1.1 standard image type/format combinations too. This functions can be used to retrieve the color of a pixel, the height of a heightmap or to perform collision detection on a heightmap.
  • Image: new method subImage() returns a new image containing the specified rectangular pixel area taken from the source image. Also this function supports all the OpenGL 1.1 image type/format combinations!
  • Image::makeColorSpectrum() function: creates an 1D image filled with the specified color spectrum.
  • Image: new methods substituteColorRGB_RGB(), substituteColorRGB_RGBA(), and substituteColorGreenKey() to substitute colors and colorize an Image.
  • All file loaders and writers now use the VirtualFile interface
  • Added write support to DiskFile class.
  • Image loader/writers divided into their own modules: vlPNG, vlJPG, vlTIFF, vlTGA, vlBMP, vlDDS, vlDAT.
  • 3D file loader/writers divided into their own modules: io3DS, ioOBJ, ioAC3D, ioPLY, ioMD2.
  • Autodesk 3DS loader class cleaned and exposed in the vl3DS module to be directly used or enhanced by the user.
  • Simplified/unified render states management: RenderStates, ClipPlanes, Light, TextureUnit.
  • New more flexible texture render states: TexGen, TexEnv, TextureMatrix.
  • Lazy allocation of RenderStateSet, EnableSet, UniformSet: uses less memory and object creation/deletion is much quicker.

GEOMETRY
  • GPUBufferInterfaceAbstract new methods: computeBoundingBox(), computeBoundingSphere(), transform() and normalize(). Now you can perform all this operations in a GPU-buffer-type-and-layout agnostic way!
  • Geometry primitives quality updates: uses quads instead of triangles when possible, topological fixes for better normal computation.
  • Geometry primitives: draw elements commands minimized and optimized.
  • Geometry::computeNormals() now supports all vertex formats and layouts!
  • Geometry::computeNormals() now supports all the main primitive types: triangles, triangle fan, polygon, quads, tri strips, quad strips!
  • Geometry::shrinkDrawElements() bug fixes.

DEMOS/TESTS
  • New demo App_VectorGraphics showing how to use VectorGraphics and VectorGraphicsScene.
  • New demo App_Terrain using the Terrain scene manager.
  • New test/demo App_Lights: shows how to implement moving colored lights like spot-lights, directional lights, point lights, lights following the camera.
  • App_VolumeRendering enhanced: allows drag&drop of volume data and the energy threshold can be interactively adjusted with the mouse wheel.
  • New demo App_GLSLImageProcessing: shows how use GLSL to implement some image processing effects.
  • New demo App_Deformer: shows how to implement a 2D application that loads an image and let the user interactively deform it!
  • New demo App_Fractals: a GPU accelerated interactive fractal navigator!
  • App_ModelViewer demo enhanced: massive code cleanup; camera centers the view to the model; automatic near/far clipping planes adjustment, nicer trackball panning and zooming.
  • New App_VertexFormat: shows several ways to layout vertex data and. how to use it in VL. VL support data layout in both Structure-Of-Array. and Array-Of-Structures form, spanning a single or multiple buffers!
  • New test App_ImageFunctions: tests image type/format conversion, nearest and bilinear sampling, loading and saving in JPG, PNG, TGA, TIFF formats.
  • MorphingActor test simplified and enhanced to show multiple animations.
  • App_Texturing test: now is a unified test checking 2D textures, 3D textures, 1D texture arrays, 2D texture arrays, texture rectangle, cubemap environment mapping, sphere mapping.

MISC
  • CMake building: many optional modules to minimize compilation time and library size.
  • Support to the GL_ATI_texture_float extension for backwards compatibility.
  • OpenGLContext's non-continuous update is much more CPU friendly.
  • Uniform setup bug fixes and performance enhancements.
  • GLSLProgram now can also have its own "static" Uniforms.
  • VL containers use the "at()" semantics to stay closer to the STL look'n'feel.
  • Bounding sphere and bounding box management: simplified, enhanced, bug fixes.
  • Scene managers bounding sphere, bounding box, and culling: now the rendering is able to optionally cull whole scene managers.
  • Current-lod property made a render-time transient variable.
  • Better definition and splitting of non-const and const rendering operations.
  • get/goc semantics for Shaders and Uniforms: a method starting with "get" will never create the object requested, methods starting with "goc" (= get-or-create) will create the resource if it doesn't exist.
  • Qt4, SDL, Win32 keyboard management fixes when pressing keys like CTRL.
  • Text: fix when rendering empty lines.
  • Text: 2d text now can seamlessly interact with 3D objects and be rendered. in front or behind the other 3D objects.
  • Actor z-sorting now works also when the bounding box is null.
  • Added support to glStencilOpSeparate().
  • Added support to glStencilFuncSeparate().
  • Added support to glStencilMaskSeparate().
  • Added the new Clear class (Renderable) to clear buffers during the rendering.
  • Removed deprecated camara/viewport binding to OpenGLContext.
  • New Scissor class: scissor clipping support for Actors, Effects and vector graphics. The Scissor class lets you define a rectangular aread clipped against the Viewport within which the rendering will be performed.
  • New RectI and RectF classes to manipulate rectangular regions.
  • Framebuffer Objects fixes and improvements.
  • New Collection class: managing groups of objects is more robust and closer to the C++ STL spirit.
  • New object oriented battery test framework
  • GLUT, WIN32, SDL, QT4 examples updated
  • Fixed mouse visibility bug under Win32
  • KdTree is now a subclass of BoundingBoxTree
  • KdTree compilation time 4.3x faster
  • Fixed culling for objects with Null bounds
  • Terrain scene manager is now based on the KdTree scene manager
  • TextStream reads UTF8 encoded strings
  • String::trim() functions improved
  • String::replace() functions improved
  • OpenGL extensions management greatly improved: wider compatibility, optimal use of the available extensions
  • Win32 GUI bindings: better support for fullscreen mode, support for top and child windows, many fixes and improvements.

Visualization Library Alpha 2.1 (12th Jan 2009)

  • VBO usage and creation bug fixes.
  • GLSLProgram and GLSLShader documentation and pointers to the reference manual.
  • version string and build number put into version.hpp.
  • merged TextStream and TokenStream classes.
  • simplified GLCHECK() macro usage.
  • GLSL temporarily removed binding maps.
  • render states constness fixes.
  • removed deprecated Actor::prepareForRendering() callback.
  • updated MorphingActor and MD2 loader.
  • ActorRenderingCallback for morphing actor and polygon depth sorting.
  • removed deprecated specific Actors for morphing and point splatting.
  • generalized depth sorting callback supporting points, lines, triangles and quads.
  • improvements to the constness of the objects during the rendering.
  • added FontManager class.
  • removed deprecated RenderStream systems.
  • texture SetupParams more flexible and documented.
  • removed deprecated math classes and tests.

Visualization Library Alpha 2 (6th Jan 2009)

  • faster and lighter rendering architecture (deprecated scene-graph system).
  • Unicode String class.
  • Virtual file system.
  • geometry shaders.
  • GLSL 1.30 support.
  • most of OpenGL 3.0 extensions support.
  • Win32 and QT4 bindings.
  • new OBJ importer and much better 3DS importer.
  • CMake building system.
  • Documentation updates.

Visualization Library Alpha 1 (7th May 2008)

  • KdTree.
  • OpenGL 1.1 - 2.1 support.
  • OpenGL Shading Language.
  • VBO, PBO, MRT.
  • Image class, support to BMP, DDS, TIFF, TGA.
  • Multipassing and LOD.
  • FreeType based text rendering engine.
  • Transform trees and billboards.
  • 3DS, PLY, AC3D, MD2 importers.
  • GLUT and SDL bindings.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Compiling and Installing Visualization Library

Visualization Library Reference Documentation

Compiling and Installing Visualization Library

Installing the License Signature
Before compiling and installing Visualization Library you are required to specify a license signature that identifies the license that has been granted to you, and thus, the conditions under which you are allowed to use Visualization Library.

By default Visualization Library is distributed with a license certificate and license signature that allows you to use Visualization Library under the GNU GPL version 3.0 license. If you would like to develop proprietary and commercial applications you need a Professional Edition License.

You can find the default license certificate (license_certificate_gpl3.vlc) and license signature (license_signature.vls) in the root directory of Visualization Library distribution.

If you own a Professional Edition License locate the LicenseSignatures field at the end of your license certificate and substitute with it the default license signature "VLLS:A85397342177565495" contained in the license_signature.vls file. This way you will be able to develop and distribute your programs according to the Visualization Library Professional Edition License terms. Please read carefully the comments included in the license_signature.vls file.

You are now ready to compile and use Visualization Library!

Compilation and Installation
Visualization Library uses the CMake building system to target several platforms and compilers. At the moment Visualization Library supports the following development platforms:

  • Windows: Visual Studio 2005-2008 32-64 bits
  • Windows: MinGW
  • Linux: GNU make/gcc 32-64 bits
  • Mac OS X: Xcode

Note that CMake supports many other platforms and operating systems as well, in which you can probably also run Visualization Library.

Please visit http://www.cmake.org to download the latest 2.6.x CMake distribution for your operating system.

In order to compile Visualization Library with CMake you have to understand a few simple concepts that remain valid for all the platforms. When building Visualization Library you will need 3 directories:

  • a source directory: the directory where Visualization Library sources are located (containing the main CMakeLists.txt)
  • a build directory: the directory used to keep the temporary object and project files generated for and during the building process.
  • an install directory: the directory in which Visualization Libary's executables, libraries and header files will be installed.

Run CMake, select the source directory and the build directory, then press the Configure button:

Select your building environment and press the Finish button:

The basic build environment is ready:

Variables overview:

  • CMAKE_BUID_TYPE: set it to Release if you want to compile VL for maximum performance or to Debug if you want to compile VL with debugging symbols. Note that this variable is not available under Visual Studio since you can manage the Release and Debug configurations directly from the Visual Studio gui.

  • CMAKE_INSTALL_PREFIX: this is the location where Visualization Library will be installed. In order to install visualization library you can either call make install under Unix-like environments or build the INSTALL project under Visual Studio.

  • GUI_*_SUPPORT and GUI_*_EXAMPLES: check the appropriate variable if you would like to build the binding classes for a particular GUI framework. Note that after selecting this variable and pressing the Configure button CMake might require more information to locate the required libraries and include files (like the location of the SDL library, of the GLUT header files etc.).

  • IO_MODULE_*: check the resource file formats that you want to be natively supported by VL. Selecting less modules will make Visualization Library smaller. Note that if you select modules like IO_MODULE_JPG or IO_MODULE_PNG CMake will require more information to locate the libpng and libjpeg libraries and include files.

Press the Configure button, you should see something similar to:

If you would like to reset your configuration go to the menu File -> Delete Cache.

To finalize and generate the building environment press Generate. Now you can close CMake and go to the specified build directory. If you are using a Unix-like environment you can simply type make then make install. If you are using Visual Studio you just need to double click on the VisualizationLibrarySDK.sln file and build the BUILD_ALL project and then the INSTALL project.

You are now ready to use Visualization Library!

Third Party Libraries
This is a convenience list of third party libraries used by Visualization Library:

  • FreeType - http://www.freetype.org [required, included with VL]
  • zlib - http://www.zlib.net [required, included with VL]
  • IJG's libjpeg - http://www.ijg.org [required, included with VL]
  • libpng - http://www.libpng.org [required, included with VL]
  • libtiff - http://www.libtiff.org [required, included with VL]
  • Qt - http://www.qtsoftware.com
  • wxWidgets - http://www.wxwidgets.org
  • SDL - http://www.libsdl.org
  • GLUT - http://www.opengl.org/resources/libraries/glut
  • FreeGLUT - http://freeglut.sourceforge.net
  • GnuWin32: http://gnuwin32.sourceforge.net/packages.html (provides Win32-versions of tools and libraries with GNU or similar open source licences)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Visualization Library Architecture

Visualization Library Reference Documentation

Visualization Library Architecture

Introduction

Visualization Library's architecture provides the programmer with a flexible and efficient framework to develop any kind of 3D graphics and visualization applications. In fact, even if Visualization Library was born with mainly scientific applications in mind, its modular architecture is perfectly suitable to develop high-performance applications such as next-generation games. It is not a surprise after all if we consider the fact that VL was designed to natively support technologies such as OpenGL Shading Language, geometry shaders, occlusion culling, framebuffer objects, vertex buffer objects, multiple render targets, multiple rendering, post processing etc. Not to mention more traditional features like hierachical frustum culling, geometry LOD, effect LOD, multipassing, hierachical transforms...

The paragraphs below briefly describe the interaction among the most important Visualization Library classes. This will give you a general idea of how VL works and how the main classes collaborate with each another.

Visualization Library Singleton

The vl::VisualizationLibrary class is used to globally initialize, access and shutdown all the most important Visualization Library's components. As shown in the picture below, each instance of Visualization Library provides the following components:

  • A vl::KeyValues object: used to conveniently pass key/value pairs across the application.
  • A vl::FileSystem object: used to locate and retrieve files and directories on all the registered vl::VirtualDirectory[s].
  • A vl::LoadWriterManager object: is used to register, manage and use all the vl::ResourceReadWriter[s] which allow Visualization Library to load and save various file formats.
  • A vl::FontManager object: used to query vl::Font objects to be used with one or multiple shared OpenGL contexts. This is provided for conveniency. Your application can instantiate and use its own vl::FontManager. This is mandatory if you are using multiple non-shared OpenGL contexts. In this case you should use a different vl::FontManager for each context.
  • A pointer to vl::RenderingAbstract: the entry point of the rendering pipeline. This can point to a single vl::Rendering object or to a hierarchy of renderings (vl::RenderingTree) or to a custom rendering objects performing post processing etc. This is provided for conveniency. Your application can instantiate and use its own set of rendering objects and arrange them in the most appropriate way. By default the returned vl::RenderingAbstract is actually a vl::Rendering.

Actors

The vl::Actor class associates three kinds of information:

  1. "what to render"
  2. "where to render"
  3. "how to render"

The vl::Renderable class defines "what to render".
The vl::Transform class defines "where to render".
The vl::Effect class defines "how to render".

As shown in the picture, a vl::Actor can render different things for each level of detail.

The vl::Effect class can render for each level of detail a different set of rendering passes, each of which is defined by a vl::Shader which contains the actual render states to be used.

ShaderNode Trees

The vl::ShaderNode class is a high-level service provided by Visualization Library to conveniently manage and arrange large hierachies of shaders. Each vl::ShaderNode manages and is bound to a single vl::Shader. This kind of service is similar to what a typical scene-graph-oriented engine provides but here you are not required to use it. You can use it for a subset of your shaders and not for others. Visualization Library gives you total control over when the shader hierarchy is updated, as opposed to most of the scene-graph-oriented engines that are forced to continuously traverse and update the whole hierarchy!

Transform Trees

A vl::Transform defines a model transformation matrix. Transforms can be arranged in one or more hierachies to represent hierarchical transformations. Each vl::Actor can reference one vl::Transform (or none) and each vl::Transform can be referenced by multiple Actors. The vl::Rendering class defines a transform hierarchy that is updated before every rendering. This way if you have a set of animated objects you can put their transform in this hierarchy, while non animated objects can remain in an external hierarchy that is updated only when necessary.

Compared to a typical scene-graph-oriented architecture Visualization Library has the following advantages:

  1. An object does not need to be part of the rendering transform tree to be part of the rendering.
  2. During the rendering you do not need to traverse the whole transform hierarchy but only the ones that are animated, saving a considerable amount of time when dealing with a large number of objects.
  3. You have the freedom to choose if a transform should be continuously and automatically updated before each rendering or not.

Rendering

The vl::Rendering class collects all the information necessary to perform a single rendering:

  1. vl::Camera: defines the point of view of the rendering, the viewport and the projection.
  2. vl::RenderTarget: defines the OpenGL surface used for the rendering. It can be the normal OpenGL framebuffer, a framebuffer object (possibly a texture), a pbuffer for offscreen rendering etc. Each rendering target belongs to an OpenGL context.
  3. A set of vl::SceneManager objects: a scene manager contains a set of Actors and implements a specific spatial organization algorithm used to accelerate visibility/culling, picking, intersection/collision computations etc.
  4. A set of vl::RenderingCallback objects: called at the beginning and at the end of a rendering to perform user-specific actions.
  5. vl::Renderer: performs the actual rendering.

As you can see Visualization Library can seamlessly use multiple scene managers, each of which can implement its own visibility and spatial organization algorithm. You can for example implement a PVS or portal-based scene manager and just drop it in the vl::Rendering! Visualization Library provides out-of-the-box the following scene managers: two BVH (bounding volume hierarchy) scene managers (a KdTree based scene manager that can efficiently replace quadtrees and octrees and a generic hierachical tree based scene manager) and a portal based scene manager especially useful for highly occluded environments.

Visualization Library allows you to combine multiple renderings by organizing them in a powerful and simple to use tree layout, for more information see vl::RenderingTree.

Rendering Queue

Below is a simplified view of Visualization Library internal rendering pipeline, from hidden surface removal to rendering.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: OpenGL vs VL function mapping

Visualization Library Reference Documentation

OpenGL vs VL function mapping

The table below shows how the most important OpenGL features and functions map to Visualization Library classes and functions.

OpenGL functions Visualization Library classes and functions
Texturing
  • glActiveTexture()
  • glClientActiveTexture()
  • glBindTexture()
  • glTexImage1D()
  • glTexImage2D()
  • glTexImage3D()
  • glCompressedTexImage1D()
  • glCompressedTexImage2D()
  • glCompressedTexImage3D()
  • glGenTextures()
  • glDeleteTextures()
  • vl::Texture
  • vl::Texture::setupTexture1D()
  • vl::Texture::setupTexture2D()
  • vl::Texture::setupTexture3D()
  • vl::Texture::setupTextureCubemap()
  • vl::Texture::setupTextureRectangle()
  • vl::Texture::setupTexture1DArray()
  • vl::Texture::setupTexture2DArray()
  • vl::TextureUnit
  • vl::Shader::gocTextureUnit()

  • gluBuild1DMipmaps()
  • gluBuild2DMipmaps()
  • gluBuild3DMipmaps()
Mipmaps are automatically generated when requested by the texture constructor or by one of the vl::Texture::setupTexture*() methods. The texture generation uses the hardware acceleration where available otherwise glu is used.

  • glTexSubImage1D()
  • glTexSubImage2D()
  • glTexSubImage3D()
  • glCompressedTexSubImage1D()
  • glCompressedTexSubImage2D()
  • glCompressedTexSubImage3D()
Not mapped, you can use them like this:
vl::Texture* texture = ... init texture ...
glBindTexture(GL_TEXTURE_2D, texture->handle());
glTexSubImage2D(GL_TEXTURE_2D, ...);

  • glTexParameter()
  • vl::TexParameter
  • vl::Texture::getTexParameter()

  • glTexGen()
  • vl::TexGen
  • vl::Shader::gocTexGen(), vl::Shader::getTexGen()

  • glTexEnv()
  • vl::TexEnv
  • vl::Shader::gocTexEnv(), vl::Shader::getTexEnv()

  • glClientActiveTexture()
  • glTexCoord()
  • glMultiTexCoord()
  • glTexCoordPointer()
  • vl::Geometry::setTexCoordArray()

  • glCopyTexImage1D()
  • glCopyTexImage2D()
  • glCopyTexSubImage1D()
  • glCopyTexSubImage2D()
  • glCopyTexSubImage3D()
  • vl::CopyTexSubImage1D
  • vl::CopyTexSubImage2D
  • vl::CopyTexSubImage3D

Matrices
  • glMatrixMode()
  • glLoadMatrix()
  • glLoadIdentity()
  • glMultMatrix()
  • glPushMatrix()
  • glPopMatrix()
  • glTranslate()
  • glScale()
  • glRotate()
  • vl::dmat4
  • vl::fmat4
  • vl::TextureMatrix
  • vl::Transform
  • vl::Billboard
  • vl::Camera
  • vl::Camera::setViewMatrix()
  • vl::Camera::setProjectionMatrix()

Camera viewing and projection matrices
  • gluPerspective()
  • glFrustum()
  • glOrtho()
  • gluOrtho2D()
  • gluLookAt()
  • gluProject()
  • gluUnProject()
  • vl::dmat4::perspective()
  • vl::dmat4::frustum()
  • vl::dmat4::ortho()
  • vl::dmat4::lookAt()
  • vl::Camera::setProjectionAsPerspective()
  • vl::Camera::setProjectionAsFrustum()
  • vl::Camera::setProjectionAsOrtho()
  • vl::Camera::setProjectionAsOrtho2D()
  • vl::Camera::setViewMatrixAsLookAt()
  • vl::Camera::project()
  • vl::Camera::unproject()

Vertex attributes
  • glVertex()
  • glVertexPointer()
  • vl::Geometry::setVertexArray()

  • glVertexAttrib()
  • glVertexAttribPointer()
  • vl::Geometry::setVertexAttributeArray()

  • glNormal()
  • glNormalPointer()
  • vl::Geometry::setNormalArray()

  • glColor()
  • glColorPointer()
  • vl::Geometry::setColorArray()

  • glSecondaryColor()
  • glSecondaryColorPointer()
  • vl::Geometry::setSecondaryColorArray()

  • glFogCoord()
  • glFogCoordPointer()
  • vl::Geometry::setFogCoordArray()

Draw commands
  • glDrawArrays()
  • glMultiDrawArrays()
  • glDrawArraysInstanced()
  • vl::DrawArrays
  • vl::Geometry::primitives()

  • glDrawElements()
  • glMultiDrawElements()
  • glDrawArraysInstanced()
  • vl::DrawElements
  • vl::Geometry::primitives()

Enables
  • glEnable()
  • glDisable()
  • glIsEnabled()
  • vl::Shader::enable()
  • vl::Shader::disable()
  • vl::Shader::isEnabled()

glReadPixels
  • glReadPixels()
  • vl::Image::readPixels()
  • vl::ReadPixels

OpenGL Shading Language
  • glCreateShader(), glDeleteShader()
  • glCreateProgram(), glDeleteProgram()
  • glLinkProgram()
  • glAttachShader()
  • glDetachShader()
  • glCompileShader()
  • glUseProgram()
  • glValidateProgram()
  • glBindAttribLocation()
  • glUniform()
  • vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader
  • vl::GLSLProgram
  • vl::GLSLProgram::linkProgram() (done automatically)
  • vl::GLSLProgram::attachShader()
  • vl::GLSLProgram::detachShader()
  • (done automatically)
  • vl::GLSLProgram::useProgram()
  • vl::GLSLProgram::validateProgram()
  • vl::GLSLProgram::bindAttribLocation()
  • vl::Uniform, vl::GLSLProgram::setUniform(), vl::Actor::setUniform(), vl::Shader::setUniform()

Vertex and pixel buffer objects (VBO, PBO)
  • glGenBuffers()
  • glDeleteBuffers()
  • glBufferData()
  • glBufferSubData()
  • glMapBuffer()
  • glUnmapBuffer()
  • vl::GLBufferObject
  • vl::GLBufferObject::createGLBufferObject()
  • vl::GLBufferObject::deleteGLBufferObject()
  • vl::GLBufferObject::setBufferData()
  • vl::GLBufferObject::setBufferSubData()
  • vl::GLBufferObject::mapGPUBuffer()
  • vl::GLBufferObject::unmapGPUBuffer()
  • vl::Geometry::setVBOEnabled()
  • vl::Image::readPixels()
  • vl::DrawPixels

Framebuffer object extension
See http://oss.sgi.com/projects/ogl-sample/registry/EXT/framebuffer_object.txt
  • glFramebufferTexture1D()
  • glFramebufferTexture2D()
  • glFramebufferTexture()
  • glFramebufferTexture3D()
  • glFramebufferTextureLayer()
  • glCheckFramebufferStatus()
  • glGenRenderbuffers()
  • glDeleteRenderbuffers()
  • glRenderbufferStorage()
  • glFramebufferRenderbuffer()
  • glGenFramebuffers()
  • glDeleteFramebuffers()
  • glBindFramebuffer()
  • vl::FBOTexture1DAttachment
  • vl::FBOTexture2DAttachment
  • vl::FBOTextureAttachment
  • vl::FBOTexture3DAttachment
  • vl::FBOTextureLayerAttachment
  • vl::FBORenderTarget::checkFramebufferStatus()
  • vl::FBORenderbufferAttachment::create()
  • vl::FBORenderbufferAttachment::destroy()
  • automatically called inside vl::FBOAttachmentAbstract::bindAttachment()
  • automatically called inside vl::FBOAttachmentAbstract::bindAttachment()
  • vl::FBORenderTarget::create()
  • vl::FBORenderTarget::destroy()
  • vl::FBORenderTarget::bindFrameBuffer() (initializes also the attachment points)

Display lists
  • glGenLists()
  • glDeleteLists()
  • glNewList()
  • glCallLists()
  • glCallList()
  • vl::Renderable::setDisplayListEnabled()
  • vl::Renderable::setDisplayListDirty()
  • vl::Renderable::displayList()
  • vl::Renderable::deleteDisplayList()

Render states
  • glAlphaFunc
  • glBlendColor
  • glBlendEquation
  • glBlendFunc
  • glClipPlane
  • glColorMask
  • glCullFace
  • glDepthFunc
  • glDepthMask
  • glDepthRange
  • glFog
  • glFrontFace
  • glHint
  • glLight
  • glLightModel
  • glLineStipple
  • glLineWidth
  • glLogicOp
  • glMaterial
  • glPixelTransfer
  • glPointParameter
  • glPointSize
  • glPolygonMode
  • glPolygonOffset
  • glPolygonStipple
  • glSampleCoverage
  • glShadeModel
  • glStencilFunc
  • glStencilMask
  • glStencilOp
  • glTexEnv
  • glTexGen
  • vl::AlphaFunc
  • vl::BlendColor
  • vl::BlendEquation
  • vl::BlendFunc
  • vl::ClipPlane
  • vl::ColorMask
  • vl::CullFace
  • vl::DepthFunc
  • vl::DepthMask
  • vl::DepthRange
  • vl::Fog
  • vl::FrontFace
  • vl::Hint
  • vl::Light
  • vl::LightModel
  • vl::LineStipple
  • vl::LineWidth
  • vl::LogicOp
  • vl::Material
  • vl::PixelTransfer
  • vl::PointParameter
  • vl::PointSize
  • vl::PolygonMode
  • vl::PolygonOffset
  • vl::PolygonStipple
  • vl::SampleCoverage
  • vl::ShadeModel
  • vl::StencilFunc
  • vl::StencilMask
  • vl::StencilOp
  • vl::TexEnv
  • vl::TexGen

OpenGL Enables
  • GL_ALPHA_TEST
  • GL_BLEND
  • GL_COLOR_LOGIC_OP
  • GL_LIGHTING
  • GL_COLOR_SUM
  • GL_CULL_FACE
  • GL_DEPTH_TEST
  • GL_FOG
  • GL_LINE_SMOOTH
  • GL_LINE_STIPPLE
  • GL_POLYGON_STIPPLE
  • GL_NORMALIZE
  • GL_POINT_SMOOTH
  • GL_POINT_SPRITE
  • GL_POLYGON_SMOOTH
  • GL_POLYGON_OFFSET_FILL
  • GL_POLYGON_OFFSET_LINE
  • GL_POLYGON_OFFSET_POINT
  • GL_RESCALE_NORMAL
  • GL_STENCIL_TEST
  • GL_VERTEX_PROGRAM_POINT_SIZE
  • GL_VERTEX_PROGRAM_TWO_SIDE
  • GL_MULTISAMPLE
  • GL_SAMPLE_ALPHA_TO_COVERAGE
  • GL_SAMPLE_ALPHA_TO_ONE
  • GL_SAMPLE_COVERAGE
  • GL_LIGHTi
  • GL_CLIP_PLANEi
  • GL_SCISSOR_TEST
  • GL_COLOR_MATERIAL
  • GL_TEXTURE_1D
  • GL_TEXTURE_2D
  • GL_TEXTURE_3D
  • GL_TEXTURE_CUBE_MAP
  • GL_TEXTURE_GEN_Q/R/S/T
  • GL_DITHER
  • GL_INDEX_LOGIC_OP
  • vl::EN_ALPHA_TEST
  • vl::EN_BLEND
  • vl::EN_COLOR_LOGIC_OP
  • vl::EN_LIGHTING
  • vl::EN_COLOR_SUM
  • vl::EN_CULL_FACE
  • vl::EN_DEPTH_TEST
  • vl::EN_FOG
  • vl::EN_LINE_SMOOTH
  • vl::EN_LINE_STIPPLE
  • vl::EN_POLYGON_STIPPLE
  • vl::EN_NORMALIZE
  • vl::EN_POINT_SMOOTH
  • vl::EN_POINT_SPRITE
  • vl::EN_POLYGON_SMOOTH
  • vl::EN_POLYGON_OFFSET_FILL
  • vl::EN_POLYGON_OFFSET_LINE
  • vl::EN_POLYGON_OFFSET_POINT
  • vl::EN_RESCALE_NORMAL
  • vl::EN_STENCIL_TEST
  • vl::EN_VERTEX_PROGRAM_POINT_SIZE
  • vl::EN_VERTEX_PROGRAM_TWO_SIDE
  • vl::EN_MULTISAMPLE
  • vl::EN_SAMPLE_ALPHA_TO_COVERAGE
  • vl::EN_SAMPLE_ALPHA_TO_ONE
  • vl::EN_SAMPLE_COVERAGE
  • automatically managed by vl::Light
  • automatically managed by vl::ClipPlane
  • automatically manaded by vl::Scissor
  • see vl::Material::setColorMaterial(), vl::Material::setColorMaterialEnabled()
  • automatically managed, see vl::Texture, vl::TextureUnit, vl::TexParameter
  • automatically managed, see vl::Texture, vl::TextureUnit, vl::TexParameter
  • automatically managed, see vl::Texture, vl::TextureUnit, vl::TexParameter
  • automatically managed, see vl::Texture, vl::TextureUnit, vl::TexParameter
  • automatically managed by vl::TexGen
  • deprecated functionality
  • deprecated functionality
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Visualization Library Tutorials

Visualization Library Reference Documentation

Visualization Library Tutorials

Introduction
This section contains a set of practical tutorials and examples that will guide you through the most important concepts and techniques regarding Visualization Library and computer graphics. The topics range from basic application setup, to memory management, texturing, OpenGL Shading Language, terrain rendering and much more. Enjoy!

Implementing a Simple Spinning Cube Tutorial (code and comments)

Smart Pointers and Memory Management Tutorial

OpenGL Texture Mapping Tutorial

Rendering Order Tutorial

OpenGL Shading Language Tutorial (code and comments)

Picking and Selection Tutorial (code and comments)

Volume Rendering and Isosurfaces Extraction with Marching Cubes Tutorial (code and comments)

Volume Rendering with Transfer Functions and Lighting Tutorial (code and comments)

Directional, Point and Spot Lights Tutorial (code and comments)

Terrains and Heightmaps Tutorial (code and comments)

OpenGL-Accelerated 2D Vector Graphics Tutorial (code and comments)

Clipping Planes Tutorial (code and comments)

Polygon Tessellation Tutorial (code and comments)

Geometry Extrusion Tutorial (code and comments)

Interpolators Tutorial (code and comments)

Molecule Visualization Tutorial (code and comments)

Edge Enhancement and Wireframe Rendering Tutorial (code and comments)

Portal-Based Culling and Scene Management Tutorial (code and comments)

OpenGL-Accelerated Occlusion Culling Tutorial (code and comments)

Bicubic Bézier Patches and Surfaces Tutorial (code and comments)

Transparency and Polygon Depth Sorting Tutorial (code and comments)

Antialiasing and Multisampling Tutorial

Billboards Tutorial

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Spinning Cube Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Spinning Cube Tutorial

Implementing the First Rotating Cube
Complete source: src/examples/Applets/App_RotatingCube.hpp

Visualization Library comes with several utility components to quickly develop applictions under several GUI frameworks. The vlut::Applet class is an utility class that implements an event-driven application with a default rendering pipeline. Below is a practical examples of how to implement a vlut::Applet that renders a spinning cube and how to use it (unchanged!) with Win32, MFC, Qt4, SDL and GLUT! For more information see vlut::Applet.

#include "vlut/Applet.hpp"
#include "vlut/GeometryPrimitives.hpp"
#include "vl/SceneManagerActorTree.hpp"
#include "vl/Actor.hpp"
#include "vl/Effect.hpp"
#include "vl/Time.hpp"

class App_RotatingCube: public vlut::Applet
{
public:
  virtual void shutdown() {}

  // called once after the OpenGL window has been opened
  void initEvent()
  {
    // allocate the Transform
    mCubeTransform = new vl::Transform;
    // bind the Transform with the transform tree of the rendring pipeline
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mCubeTransform.get() );

    // create the cube's Geometry and compute its normals to support lighting
    vl::ref<vl::Geometry> cube = vlut::makeBox( vl::vec3(0,0,0), 10, 10, 10 );
    cube->computeNormals();

    // setup the effect to be used to render the cube
    vl::ref<vl::Effect> effect = new vl::Effect;
    // enable depth test and lighting
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    // add a Light to the scene, since no Transform is associated to the Light it will follow the camera
    effect->shader()->setRenderState( new vl::Light(0) );
    // enable the standard OpenGL lighting
    effect->shader()->enable(vl::EN_LIGHTING);
    // set the front and back material color of the cube
    // "gocMaterial" stands for "get-or-create Material"
    effect->shader()->gocMaterial()->setDiffuse( vlut::crimson );

    // install our scene manager, we use the SceneManagerActorTree which is the most generic
    vl::ref<vl::SceneManagerActorTree> scene_manager = new vl::SceneManagerActorTree;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->sceneManagers()->push_back(scene_manager.get());
    // add the cube to the scene using the previously defined effect and transform
    scene_manager->tree()->addActor( cube.get(), effect.get(), mCubeTransform.get()  );
  }

  // called every frame
  virtual void run()
  {
    // rotates the cube around the Y axis 45 degrees per second
    vl::Real degrees = vl::Time::currentTime() * 45.0f;
    vl::mat4 matrix = vl::mat4::rotation( degrees, 0,1,0 );
    mCubeTransform->setLocalMatrix( matrix );
  }

protected:
  vl::ref<vl::Transform> mCubeTransform;
};

// Have fun!

Using the Qt4 Utility Bindings
Complete source: src/examples/Qt4_example.cpp

#include "vl/VisualizationLibrary.hpp"
#include "vlQt4/Qt4Widget.hpp"
#include "Applets/App_RotatingCube.hpp"

using namespace vl;
using namespace vlQt4;

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);

  /* init Visualization Library */
  vl::VisualizationLibrary::init();

  /* setup the OpenGL context format */
  vl::OpenGLContextFormat format;
  format.setDoubleBuffer(true);
  format.setRGBABits( 8,8,8,8 );
  format.setDepthBufferBits(24);
  format.setStencilBufferBits(8);
  format.setFullscreen(false);
  //format.setMultisampleSamples(16);
  //format.setMultisample(true);

  /* create the applet to be run */
  vl::ref<vlut::Applet> applet = new App_RotatingCube;
  applet->initialize();
  /* create a native Qt4 window */
  vl::ref<vlQt4::Qt4Widget> qt4_window = new vlQt4::Qt4Widget;
  /* bind the applet so it receives all the GUI events related to the OpenGLContext */
  qt4_window->addEventListener(applet.get());
  /* target the window so we can render on it */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderTarget( qt4_window->renderTarget() );
  /* black background */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor( vlut::black );
  /* define the camera position and orientation */
  vl::vec3 eye    = vl::vec3(0,10,35); // camera position
  vl::vec3 center = vl::vec3(0,0,0);   // point the camera is looking at
  vl::vec3 up     = vl::vec3(0,1,0);   // up direction
  vl::mat4 view_mat = vl::mat4::lookAt(eye, center, up).inverse();
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( view_mat );
  /* Initialize the OpenGL context and window properties */
  int x = 0;
  int y = 0;
  int width = 512;
  int height= 512;
  qt4_window->initQt4Widget( "Visualization Library on Qt4 - Rotating Cube", format, NULL, x, y, width, height );
  /* show the window */
  qt4_window->show();

  /* run the Win32 message loop */
  int val = app.exec();

  /* deallocate the window with all the OpenGL resources before shutting down Visualization Library */
  qt4_window = NULL;

  /* shutdown Visualization Library */
  vl::VisualizationLibrary::shutdown();

  return val;
}
// Have fun!

Using the wxWidgets Utility Bindings
Complete source: src/examples/WX_example.cpp

#include "vlWX/vlWXGLCanvas.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "Applets/App_RotatingCube.hpp"

using namespace vlWX;
using namespace vl;

//-----------------------------------------------------------------------------
// main window
//-----------------------------------------------------------------------------
class MyFrame: public wxFrame
{
public:
  MyFrame(wxWindow *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style = wxDEFAULT_FRAME_STYLE):
    wxFrame(parent, wxID_ANY, title, pos, size, style) {}
  ~MyFrame(){}
};
//-----------------------------------------------------------------------------
// implement the application
//-----------------------------------------------------------------------------
class MyApp: public wxApp
{
public:
  bool OnInit();
  int OnExit();
};
//-----------------------------------------------------------------------------
IMPLEMENT_APP(MyApp)
//-----------------------------------------------------------------------------
bool MyApp::OnInit()
{
  vl::showWin32Console();
  vl::VisualizationLibrary::init();

  MyFrame *frame = new MyFrame(NULL, L"vlWXGLCanvas", wxDefaultPosition, wxSize(400, 300));

  /* create the applet to be run */
  vl::ref<vlut::Applet> applet = new App_RotatingCube;
  applet->initialize();
  /* Initialize the OpenGL context and window properties */
  // WX_GL_RGBA:            Use true colour
  // WX_GL_BUFFER_SIZE:     Bits for buffer if not WX_GL_RGBA
  // WX_GL_LEVEL:           0 for main buffer, >0 for overlay, <0 for underlay
  // WX_GL_DOUBLEBUFFER:    Use doublebuffer
  // WX_GL_STEREO:          Use stereoscopic display
  // WX_GL_AUX_BUFFERS:     Number of auxiliary buffers (not all implementation support this option)
  // WX_GL_MIN_RED:         Use red buffer with most bits (> MIN_RED bits)
  // WX_GL_MIN_GREEN:       Use green buffer with most bits (> MIN_GREEN bits)
  // WX_GL_MIN_BLUE:        Use blue buffer with most bits (> MIN_BLUE bits)
  // WX_GL_MIN_ALPHA:       Use alpha buffer with most bits (> MIN_ALPHA bits)
  // WX_GL_DEPTH_SIZE:      Bits for Z-buffer (0,16,32)
  // WX_GL_STENCIL_SIZE:    Bits for stencil buffer
  // WX_GL_MIN_ACCUM_RED:   Use red accum buffer with most bits (> MIN_ACCUM_RED bits)
  // WX_GL_MIN_ACCUM_GREEN: Use green buffer with most bits (> MIN_ACCUM_GREEN bits)
  // WX_GL_MIN_ACCUM_BLUE:  Use blue buffer with most bits (> MIN_ACCUM_BLUE bits)
  // WX_GL_MIN_ACCUM_ALPHA: Use blue buffer with most bits (> MIN_ACCUM_ALPHA bits)
  int context_format[] =
  {
    WX_GL_RGBA,
    WX_GL_DOUBLEBUFFER,
    WX_GL_MIN_RED, 8,
    WX_GL_MIN_GREEN, 8,
    WX_GL_MIN_BLUE, 8,
    WX_GL_MIN_ALPHA, 8,
    WX_GL_DEPTH_SIZE, 24,
    WX_GL_STENCIL_SIZE, 8,
    /*WX_GL_LEVEL, 0,
    WX_GL_AUX_BUFFERS, 0*/
    0
  };
  vl::ref<vlWXGLCanvas> vl_gl_canvas = new vlWXGLCanvas( frame, NULL, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE, context_format );
  /* target the window so we can render on it */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderTarget( vl_gl_canvas->renderTarget() );
  /* black background */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor( vlut::black );
  /* define the camera position and orientation */
  vl::vec3 eye    = vl::vec3(0,10,35); // camera position
  vl::vec3 center = vl::vec3(0,0,0);   // point the camera is looking at
  vl::vec3 up     = vl::vec3(0,1,0);   // up direction
  vl::mat4 view_mat = vl::mat4::lookAt(eye, center, up).inverse();
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( view_mat );
  /* show the window */
  frame->Show();
  /* THE ORDER IS IMPORTANT IMPORTANT */
  vl_gl_canvas->initExtensions();
  /* bind the applet so it receives all the GUI events related to the OpenGLContext */
  vl_gl_canvas->addEventListener(applet.get());
  vl_gl_canvas->dispatchInitEvent();
  /* these must be done after the window is visible */
  int x = 0;
  int y = 0;
  int width = 512;
  int height= 512;
  frame->SetPosition( wxPoint(x,y) );
  frame->SetClientSize( wxSize(width,height) );
  frame->SetLabel(wxT("Visualization Library on wxWindows - Rotating Cube"));

  return true;
}
//-----------------------------------------------------------------------------
int MyApp::OnExit()
{
  vl::VisualizationLibrary::shutdown();
  return 0;
}
//-----------------------------------------------------------------------------
// Have fun!

Using the Win32 Utility Bindings
Complete source: src/examples/Win32_example.cpp

#include "vl/VisualizationLibrary.hpp"
#include "vlWin32/Win32Window.hpp"
#include "Applets/App_RotatingCube.hpp"

using namespace vl;
using namespace vlWin32;

int APIENTRY WinMain(HINSTANCE /*hCurrentInst*/, HINSTANCE /*hPreviousInst*/, LPSTR /*lpszCmdLine*/, int /*nCmdShow*/)
{
  /* open a console so we can see the applet's output on stdout */
  vl::showWin32Console();

  /* init Visualization Library */
  vl::VisualizationLibrary::init();

  /* setup the OpenGL context format */
  vl::OpenGLContextFormat format;
  format.setDoubleBuffer(true);
  format.setRGBABits( 8,8,8,0 );
  format.setDepthBufferBits(24);
  format.setStencilBufferBits(8);
  format.setFullscreen(false);
  format.setMultisampleSamples(16);
  format.setMultisample(true);

  /* create the applet to be run */
  vl::ref<vlut::Applet> applet = new App_RotatingCube;
  applet->initialize();
  /* create a native Win32 window */
  vl::ref<vlWin32::Win32Window> win32_window = new vlWin32::Win32Window;
  /* bind the applet so it receives all the GUI events related to the OpenGLContext */
  win32_window->addEventListener(applet.get());
  /* target the window so we can render on it */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderTarget( win32_window->renderTarget() );
  /* black background */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor( vlut::black );
  /* define the camera position and orientation */
  vl::vec3 eye    = vl::vec3(0,10,35); // camera position
  vl::vec3 center = vl::vec3(0,0,0);   // point the camera is looking at
  vl::vec3 up     = vl::vec3(0,1,0);   // up direction
  vl::mat4 view_mat = vl::mat4::lookAt(eye, center, up).inverse();
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( view_mat );
  /* Initialize the OpenGL context and window properties */
  int x = 0;
  int y = 0;
  int width = 512;
  int height= 512;
  win32_window->initWin32Window(NULL, NULL, "Visualization Library on Win32 - Rotating Cube", format, x, y, width, height );
  /* show the window */
  win32_window->show();

  /* run the Win32 message loop */
  int res = vlWin32::messageLoop();

  /* deallocate the window with all the OpenGL resources before shutting down Visualization Library */
  win32_window = NULL;

  /* shutdown Visualization Library */
  vl::VisualizationLibrary::shutdown();

  return res;
}
// Have fun!

Using the MFC Utility Bindings
Complete source: src/examples/MFC_example.cpp

Using the SDL GUI Utility Bindings

Complete source: src/examples/SDL_example.cpp

#include "vl/VisualizationLibrary.hpp"
#include "vlSDL/SDLWindow.hpp"
#include "Applets/App_RotatingCube.hpp"

int main(int argc, char* args[])
{
  /* init Visualization Library */
  vl::VisualizationLibrary::init();

  /* setup the OpenGL context format */
  vl::OpenGLContextFormat format;
  format.setDoubleBuffer(true);
  format.setRGBABits( 8,8,8,8 );
  format.setDepthBufferBits(24);
  format.setStencilBufferBits(8);
  format.setFullscreen(false);
  //format.setMultisampleSamples(16);
  //format.setMultisample(true);

  /* create the applet to be run */
  vl::ref<vlut::Applet> applet = new App_RotatingCube;
  applet->initialize();
  /* create a native SDL window */
  vl::ref<vlSDL::SDLWindow> sdl_window = new vlSDL::SDLWindow;
  /* bind the applet so it receives all the GUI events related to the OpenGLContext */
  sdl_window->addEventListener(applet.get());
  /* target the window so we can render on it */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderTarget( sdl_window->renderTarget() );
  /* black background */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor( vlut::black );
  /* define the camera position and orientation */
  vl::vec3 eye    = vl::vec3(0,10,35); // camera position
  vl::vec3 center = vl::vec3(0,0,0);   // point the camera is looking at
  vl::vec3 up     = vl::vec3(0,1,0);   // up direction
  vl::mat4 view_mat = vl::mat4::lookAt(eye, center, up).inverse();
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( view_mat );
  /* Initialize the OpenGL context and window properties */
  int x = 0;
  int y = 0;
  int width = 512;
  int height= 512;
  sdl_window->initSDLWindow( "Visualization Library on SDL - Rotating Cube", format, x, y, width, height );

  /* run SDL message loop */
  vlSDL::messageLoop();

  /* deallocate the window with all the OpenGL resources before shutting down Visualization Library */
  sdl_window = NULL;

  /* shutdown Visualization Library */
  vl::VisualizationLibrary::shutdown();

  return 0;
}
// Have fun!

Using the GLUT GUI Utility Bindings

Complete source: src/examples/GLUT_example.cpp

#include "vl/VisualizationLibrary.hpp"
#include "vlGLUT/GLUTWindow.hpp"
#include "Applets/App_RotatingCube.hpp"

int main ( int argc, char *argv[] )
{
  /* init GLUT */
  int pargc = argc;
  glutInit( &pargc, argv );

  /* init Visualization Library */
  vl::VisualizationLibrary::init();

  /* install Visualization Library shutdown function */
  atexit( vlGLUT::atexit_visualization_library_shutdown );

  /* setup the OpenGL context format */
  vl::OpenGLContextFormat format;
  format.setDoubleBuffer(true);
  format.setRGBABits( 8,8,8,8 );
  format.setDepthBufferBits(24);
  format.setStencilBufferBits(8);
  format.setFullscreen(false);
  //format.setMultisampleSamples(16);
  //format.setMultisample(true);

  /* create the applet to be run */
  vl::ref<vlut::Applet> applet = new App_RotatingCube;
  applet->initialize();
  /* create a native GLUT window */
  vl::ref<vlGLUT::GLUTWindow> glut_window = new vlGLUT::GLUTWindow;
  /* bind the applet so it receives all the GUI events related to the OpenGLContext */
  glut_window->addEventListener(applet.get());
  /* target the window so we can render on it */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderTarget( glut_window->renderTarget() );
  /* black background */
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor( vlut::black );
  /* define the camera position and orientation */
  vl::vec3 eye    = vl::vec3(0,10,35); // camera position
  vl::vec3 center = vl::vec3(0,0,0);   // point the camera is looking at
  vl::vec3 up     = vl::vec3(0,1,0);   // up direction
  vl::mat4 view_mat = vl::mat4::lookAt(eye, center, up).inverse();
  vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( view_mat );
  /* Initialize the OpenGL context and window properties */
  int x = 0;
  int y = 0;
  int width = 512;
  int height= 512;
  glut_window->initGLUTWindow( "Visualization Library on GLUT - Rotating Cube", format, x, y, width, height );

  /* ... you can open more than one GLUT window! */

  /* enter the GLUT main loop */
  glutMainLoop();

  /* this point is never reached since glutMainLoop() never returns! */

  return 0;
}
// Have fun!

    Visualization Library v2009.08 Reference Documentation

    Copyright 2005-2009 Michele Bosi. All rights reserved.

    Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Smart Pointers and Memory Management Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Smart Pointers and Memory Management Tutorial

Smart Pointers
Visualization applications often deal with a large amount of objects and complex data structures. This complexity makes it very difficult to track the reference relationship between objects. This is a typical problem in C++ since it does not provide any out-of-the-box garbage collection or automatic memory management system. Among the most common problems that a C++ application has to deal with we find:

  • invalid pointers (deallocating objects that are still being used), result: crash.
  • multiple memory release (objects released more than once), result: crash.
  • memory leaks (objects never deallocated), result: unrecoverable memory consumption.

In order to minimize this issues Visualiation Library employs a well-known, simple and effective techniqe called "reference counting". For every dynamically allocated object VL keeps a reference count that tracks the number of references that an object has. When the reference reaches zero it means that no one is using that object anymore and that it can be safely deleted. All the reference counted classes derive from vl::Object, while the actual reference count is managed by the template class vl::ref<>. The vl::ref<> class behaves similarly to Boost's smart pointer "boost::intrusive_ptr<>".

Basic usage
The following example shows the basic usage of the ref<> class:

class MyObject: public vl::Object
{
public:
    MyObject(int data): mData(data) {}
    int mData;
};

int main()
{
    // the ref<> class can be used for the most part like a normal pointer
    vl::ref<MyObject> obj1 = new MyObject(10);
    MyObject obj3(30);
    *obj1 = obj3; // supports the '*' operator
    obj1->mData = 40; // supports the '->' operator
    MyObject* naked = obj1.get(); // retrieves the naked pointer
    if (obj1) // bool operator -> obj1.get() != NULL
        doSomething();
    vl::ref<MyObject> obj2 = new MyObject(20);
    if (obj1 == obj2) // == and != operators
        doSomethingElse();
    std::map< vl::ref<MyObject>, int > mMyMap; // can be used with STD maps and sets
}

Now consider the following example:

void myfunc()
{
  vl::ref<MyObject> obj_ref = new MyObject; // ref count is 1
  obj_ref->someMethod();
}
// "obj_ref" goes out of scope and frees the allocated memory

The function myfunc() allocates an object of type MyObject deriving from (vl::Object), then calls the method someMethod() and then returns. As you can see there is no need to explicitly call the delete operator to deallocate the object pointed by obj_ref. Infact when obj_ref goes out of scope its destructor will decrement the reference count of the previously allocated object (which will reach 0) and will deallocate it.

The power of this kind of memory management system though is much more evident when applied to complex or hierarchycal data structures. Consider the following example:

class TreeNode: public vl::Object
{
public:
  TreeNode(const std::string& name): mName(name) {}

  void addChild(TreeNode* child) { mChildNodes.push_back(child); }
  void removeChild(int i) { mChildNodes.erase(mChildNodes.begin()+i); }

public:
  std::vector< vl::ref<TreeNode> > mChildNodes;
  std::string mName;
};

void mytree()
{
  vl::ref<TreeNode> nodeA = new TreeNode("A"); // A's ref count == 1
  TreeNode* nodeB = new TreeNode("B"); // B's ref count == 0
  TreeNode* nodeC = new TreeNode("C"); // C's ref count == 0
  nodeA->addChild(nodeB); // B's ref count == 1
  nodeA->addChild(nodeC); // C's ref count == 1
  nodeA = NULL;
  // A's ref count == 0
  // A is deleted, thus also it's std::vector< ref<TreeNode> > mChildNodes is deleted
  // B and C ref count reaches 0 too, so they are also deleted.
}

The above code shows a bare-bone implementation of a tree-like data structure. As you can see when child nodes are added to a node their reference count is incremented. When the parent is destroyed though, there is no need to iterate recursively over the child nodes to explicitly deallocate them, since they are automatically deallocated if nobody else is referencing them! As you can see this approach can greatly simplify the management of dynamic objects. Reference counting can at the same time simplify our programs and make them more robust, but they must be used carefully to avoid a well known issue called "cyclic dependencies".

Cyclic dependencies
To understand the problem of cyclic dependencies let's see another example:

class TreeNode: public vl::Object
{
public:
  TreeNode(const std::string& name): mName(name) {}

  void addChild(TreeNode* child)
  {
    child->mParent = this;
    mChildNodes.push_back(child);
  }

  void removeChild(int i)
  {
    mChildNodes[i]->mParent = NULL;
    mChildNodes.erase(mChildNodes.begin()+i);
  }

public:
  std::vector< vl::ref<TreeNode> > mChildNodes; // ref<> pointer
  vl::ref<TreeNode> mParent; // ref<> pointer (BAD)
  std::string mName;
};

void mytree()
{
  vl::ref<TreeNode> nodeA = new TreeNode("A"); // A's ref count == 1
  TreeNode* nodeB = new TreeNode("B"); // B's ref count == 0
  TreeNode* nodeC = new TreeNode("C"); // C's ref count == 0
  nodeA->addChild(nodeB); // B's ref count == 1, A's ref count = 2
  nodeA->addChild(nodeC); // C's ref count == 1, A's ref count = 3
  nodeA = NULL;
  // A's ref count == 2
  // A is NOT deleted!
  // B and C are NOT deleted either!
  // when this function exits we have a memory leak!
}

So what is the problem here? The problem is that A refers B and C, while at the same time B and C also refer A. So when the the function exits none of their reference count reach zero and we generated a memory leak! In order to manage this kind of cyclic dependency usually one has to define a "who owns who" policy. The owner of another object uses ref<> while the owned object uses a normal naked pointer, for example the following data structure does not generate memory leaks:

class TreeNode: public vl::Object
{
public:
  TreeNode(const std::string& name): mName(name) {}

  void addChild(TreeNode* child)
  {
    child->mParent = this;
    mChildNodes.push_back(child);
  }

  void removeChild(int i)
  {
    mChildNodes[i]->mParent = NULL;
    mChildNodes.erase(mChildNodes.begin()+i);
  }

public:
  std::vector< vl::ref<TreeNode> > mChildNodes; // ref<> pointer
  TreeNode* mParent; // naked pointer!
  std::string mName;
};

void mytree()
{
  vl::ref<TreeNode> nodeA = new TreeNode("A"); // A's ref count == 1
  TreeNode* nodeB = new TreeNode("B"); // B's ref count == 0
  TreeNode* nodeC = new TreeNode("C"); // C's ref count == 0
  nodeA->addChild(nodeB); // B's ref count == 1, A's ref count = 1
  nodeA->addChild(nodeC); // C's ref count == 1, A's ref count = 1
  nodeA = NULL;
  // A's ref count == 0, so the whole tree is deleted as expected
}

As far as the mParent pointer is kept consistent this approach works very well and without any additional complication.

If the mParent pointer is not kept consistent it means that the program has a bug. In this case it does not matter if you are using smart pointers or not, your application is doomed to crash sooner or later.

Let's see another example:

class List: public vl::Object
{
public:
  int Data;
  vl::ref<List> mNext;
};

void mylist()
{
  List* a = new List; // a's ref count = 0
  List* b = new List; // b's ref count = 0
  List* c = new List; // c's ref count = 0
  List* d = new List; // d's ref count = 0
  a->mNext = b; // b's ref count = 1
  b->mNext = c; // c's ref count = 1
  c->mNext = d; // d's ref count = 1
  d->mNext = a; // a's ref count = 1
  // now we have a cyclic dependency: a -> b -> c -> d -> a!
  // when we exit this function a, b, c and d are
  // not released since their reference count is 1!
}

Also in this case the cyclic dependency generated a memory leak since the object were not deallocated as you might have expected.

In this case you must be aware of the cyclic dependency and must break it explicitly when appropriate. In our case we would put something like a->mNext=NULL; before the end of the function. This would generate a chain-reaction whose effect whould be the deallocation of the objects in the following order: b, c, d, a.

The bottonline is that smart pointers can be very handy and can simplify a lot your life, but you still need to design appropriately your data-structures.

Returning naked pointers
A typical mistake is creating a referenced object within a function and returning the naked pointer instead of the ref<> object. Consider the following example:

MyObject* createMyObject()
{
  vl::ref<MyObject> obj = new MyObject;
  return obj.get();
}

The problem here is that when ref_obj goes out of scope it will deallocate the object, so the returned pointer will point to an invalid memory address! A way to solve the problem could be substituting the first line of the function with a naked pointer:

MyObject* createMyObject()
{
  MyObject* obj = new MyObject;
  return obj;
}

Although correct, this approach is considered bad practice since this breaks the policy that for each new there should be a corresponding ref<>, plus the function signature seem to imply that somebody else is owning the object that has just been allocated.

The policy followed by Visualization Library in this cases is to return the actual ref<> object to remark the fact that the function is creating a new object and is passing the ownership of such object to you:

vl::ref<MyObject> createMyObject()
{
  vl::ref<MyObject> obj = new MyObject;
  return obj;
}

This approach also prevent other functions to deallocate the object before it is returned as described in the following section.

Passing naked pointers
Let's take the simple example seen above with a slight modification: before returning we do some kind of operation on the object:

void doSomething(MyObject*);

vl::ref<MyObject> createMyObject()
{
  MyObject* obj = new MyObject; // naked pointer! (BAD)
  doSomething(obj);
  return obj;
}

We have a problem here. What happens if the function doSomething() internally uses a ref<> to reference the pointer we just passed? Or what happens if the function doSomething() internally uses directly or indirectly some object that create a ref<> to the pointer we just passed? The answer is that by the time doSomething() returns obj might contain an invalid pointer since the object it is pointing to might have been already deallocated!

For this reason especially in this cases it is very important to associate the ref<> pointer to an object as soon as it is allocated, like this:

void doSomething(MyObject*);

vl::ref<MyObject> createMyObject()
{
  vl::ref<MyObject> obj = new MyObject;
  doSomething(obj.get());
  return obj.get();
}

Preventing such errors is very simple, you just have to remember that for each new there must be a corresponding ref<>.

Static allocation and arrays
Sometimes you don't want to dynamically allocate your objects (usually for performance reasons) but still want to safely pass around pointers and ref<> references to them. Normally you are not allowed to do this, for example the following example will produce a crash:

void myfunc()
{
  MyObject obj; // MyObject is a subclass of vl::Object
  vl::ref<MyObject> obj_ref = &obj; // fear the "&" opearator!
}
// when 'obj_ref' goes out of scope it will try to use the 'delete' operator to deallocate the
// object it points to (which is a statically allocated): your program will crash immediately!

Whenever you use the "&" operator with an object derived from vl::Object you should reconsider why you need to use it.

In order to make ref<> work with statically allocated objects you have to disable the automatic object deletion using the method vl::Object::setAutomaticDelete(bool) passing false. If vl::Object::automaticDelete() is set to false then ref<> will not delete the object when its reference count reaches zero.

The vl::Object::setAutomaticDelete() method can also be useful when you want to allocate a large amount of object in a single chunk using the new[] operator. For example if you wanted to quickly allocate a large amount of objects and safely pass pointers to them you would do something like this:

class MyObjectPool
{
public:
  MyObjectPool(): mPool(NULL) {}
  ~MyObjectPool()
  {
    // dispose old pool
    if (mPool)
      delete [] mPool;
  }

  void allocatePool(int count)
  {
    // dispose old pool
    if (mPool)
      delete [] mPool;
    // allocate new pool
    mPool = new MyObject[count];
    // disable the automatic object deletion
    for(int i=0; i<count; ++i)
      mPool->setAutomaticDelete(false);
  }

  // the pointer returned here can be safely used also by ref<>
  MyObject* getObject(int index) { return &mPool[index]; }

public:
  MyObject* mPool;
};

Beware that if you disable the automatic deletion for an object you are responsible for tracking all its references and its deletion. In particular pay attention not to deallocate your pool while orther objects are still pointing to data within the pool. If instead of using the new[]/delete[] operator you want to use the std::vector<> class, keep in mind that any push_back(), resize() etc. might reallocate the whole internal buffer kept by std::vector<>, thus invalidating all the previously used pointers to the contained objects.

You should use vl::Object::setAutomaticDelete() very carefully and only after excluding all the other options. Usually it is worth using it only in extreme situations, when you have to allocate quickly several hundreds of thousands of complex objects.

References
For more information see also:

  • http://en.wikipedia.org/wiki/Smart_pointer
  • http://www.boost.org/doc/libs/1_38_0/libs/smart_ptr/smart_ptr.htm
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: OpenGL Texture Mapping Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

OpenGL Texture Mapping Tutorial

"Texturing" is the technique used to apply in various ways an image over the surface of an object. Textures can be used to change or modify the color, the transparency and even the lighting properties of an object. In this tutorial we will go through the implementation of the texturing test ("src/examples/Applets/App_Texturing.hpp") part of the Visualization Library regression test suite. This will give us the chance to see how to use several standard and advanced texturing techniques like 2D texturing, multi-texturing, 3D textures, 1D and 2D texture arrays, sphere-mapping and cubemaps environment mapping. We will also see how to use the texture lod bias to simulate opaque reflections.

The most important classes involved in the texturing process are:

  • vl::Texture
  • vl::TextureUnit
  • vl::TexGen
  • vl::TexEnv
  • vl::TextureMatrix
  • vl::Image

Creating the test class
Our test like all the other tests is a subclass of BaseDemo so the only thing we do is to derive from it, implement a set of functions testing the different texturing technique and reimplementing the virtual functions initEvent() and run() to initialize and animate our test.

class App_Texturing: public BaseDemo
{
public:

Multitexturing
This example will show you how to use multiple textures to enhance the detail of your 3D objects. We will create 2 cubes: the one on the right will use a single texture, the one on the left will use multitexturing to add detail to the base texture. The two cubes will be procedurally animated by the run() virtual function (see the sources).

  void multitexturing()
  {

Create a box 5x5x5 and generate texture coordinates (generates only box->texCoordArray(0)).

Compute the normals for the box.

Share the same texture coordinates for texture unit #1 and #0. This is VERY important as for every texture unit we need a corresponding set of texture coordinates. In our case makeBox() automatically generated the texture coordinates for the texture unit #0 and we can simply 'recycle' them also for texture unit #1.

    if (!GLEW_ARB_multitexture)
    {
      vl::Log::error("Multitexturing not supported.\n");
      return;
    }

    vl::ref<vl::Geometry> box = vlut::makeBox( vl::vec3(0,0,0), 5,5,5, true );
    box->computeNormals();
    box->setTexCoordArray(1, box->texCoordArray(0));

Creates a vl::Transform for each cube so we can procedurally animate them and attaches them to the scene's root transform.

    mCubeRightTransform = new vl::Transform;
    mCubeLeftTransform = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mCubeRightTransform.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mCubeLeftTransform.get());

First of all we need to load the images that we intend to use with our textures

    vl::ref<vl::Image> img_holebox = vl::loadImage("/images/holebox.tif");
    vl::ref<vl::Image> img_detail  = vl::loadImage("/images/detail.tif");

Once we loaded our images we can create our textures from them. Here we use the GL_RGBA texture format, enable mipmapping and disable texture border. Note that even if the vl::Texture will be allocated and configured, the actual OpenGL texture object will not be created yet. Instead the OpenGL texture object will be created automatically during the rendering the first time it is used. Alternatively you can explicitly create it by calling

tex_holebox->createTexture()

Another way to create a 2D texture would be

vl::ref<vl::Texture> tex_holebox = new vl::Texture;
tex_holebox->setupTexture2D(img_holebox.get(), vl::TF_RGBA, mMipmappingOn, false);

Note that upon creation of the OpenGL texture object VL will also automatically generate the mipmaps (if requested) using the hardware acceleration where available or using GLU.

    vl::ref<vl::Texture> tex_holebox = new vl::Texture(img_holebox.get(), vl::TF_RGBA, mMipmappingOn, false);
    vl::ref<vl::Texture> tex_detail  = new vl::Texture(img_detail.get(),  vl::TF_RGBA, mMipmappingOn, false);

Since we requested mipmapping we set the MinFilter to GL_LINEAR_MIPMAP_LINEAR, i.e. trilinear filtering. Note that while you can set the MinFilter to any of GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR, you can set the MagFilter only to GL_NEAREST, GL_LINEAR.

    tex_holebox->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
    tex_holebox->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);
    tex_detail->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
    tex_detail->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);

Here we are going to create 2 vl::Effect objects: cube_right_fx and cube_left_fx with the specific settings for the left and right cubes.

The right cube is going to be textured with one simple texture.

    vl::ref<vl::Light> light = new vl::Light(0);

    vl::ref<vl::Effect> cube_right_fx = new vl::Effect;
    // to ensure the cubes are drawn after the textured quads
    cube_right_fx->setRenderRank(1);
    cube_right_fx->shader()->setRenderState( light.get() );
    cube_right_fx->shader()->enable(vl::EN_LIGHTING);
    cube_right_fx->shader()->enable(vl::EN_DEPTH_TEST);
    cube_right_fx->shader()->enable(vl::EN_BLEND);
    cube_right_fx->shader()->enable(vl::EN_ALPHA_TEST);
    cube_right_fx->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, 1.0f - 0.02f);
    cube_right_fx->shader()->gocLightModel()->setTwoSide(true);
    cube_right_fx->shader()->gocTextureUnit(0)->setTexture( tex_holebox.get() );

The left cube is going to use multitexturing: base texture + detail texture.
The color of the detail texture will be used to modulate the color coming from lighiting and the base texture.

    vl::ref<vl::Effect> cube_left_fx = new vl::Effect;
    // to ensure the cubes are drawn after the textured quads
    cube_left_fx->setRenderRank(1);
    cube_left_fx->shader()->setRenderState( light.get() );
    cube_left_fx->shader()->enable(vl::EN_LIGHTING);
    cube_left_fx->shader()->enable(vl::EN_DEPTH_TEST);
    cube_left_fx->shader()->enable(vl::EN_BLEND);
    cube_left_fx->shader()->enable(vl::EN_ALPHA_TEST);
    cube_left_fx->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, 1.0f - 0.02f);
    cube_left_fx->shader()->gocLightModel()->setTwoSide(true);
    cube_left_fx->shader()->gocTextureUnit(0)->setTexture( tex_holebox.get() );
    cube_left_fx->shader()->gocTextureUnit(1)->setTexture( tex_detail.get() );
    cube_left_fx->shader()->gocTexEnv(1)->setMode( vl::TEM_MODULATE );

Add the left and right cube to the scene.

    sceneManager()->tree()->addActor( box.get(), cube_right_fx.get(), mCubeRightTransform.get() );
    sceneManager()->tree()->addActor( box.get(), cube_left_fx.get(),  mCubeLeftTransform.get() );
  }

3D textures
In this paragraph we will use 3D textures to implement a sort of animation on a 2d flat plane.

  void texture3D()
  {

As usual we start by loading our image with the difference that this time it is a 3D image and we also convert its format and type to IT_UNSIGNED_BYTE/IF_LUMINANCE

    vl::ref<vl::Image> img_volume = vl::loadImage("/volume/VLTest.dat");

Now we create a white plane 10x10 units wide, oriented towards the viewer (without the rotation it would be on the x/z plane instead of being on the x/y plane).

Note 3 things:

  1. Using vl::Geometry::transform() you can apply any kind of matrix transform to any geometry regardless of it's internal format!
  2. We don't need to compute the normals as we will not use lighting here.
  3. If all the vertices of vl::Geometry have the same color you can set such color directly using vl::Geometry::setColorArray(const fvec4& col).

    vl::ref<vl::Geometry> quad_3d = vlut::makeGrid( vl::vec3(0,0,0), 10, 10, 2, 2 );
    quad_3d->setColorArray(vlut::white);
    quad_3d->transform( vl::mat4::rotation(90, 1,0,0), false );

Since we want to animate the texture coordinates of our plane we manually allocate a vl::ArrayFVec3 to be used as the texture coordinate array for the texture unit #0. We also disable the vertex buffer objects so that any change made locally to our buffer will be immediately visible. If VBO were enabled we would have had to update the VBOs after the animation, this way we make the things a bit less efficient but easyer to follow. The animation of the texture coordinates is done in the run() method (see the sources).

    mTexCoords_3D = new vl::ArrayFVec3;
    quad_3d->setTexCoordArray(0, mTexCoords_3D.get());
    mTexCoords_3D->resize( 2*2 );
    quad_3d->setVBOEnabled(false);

This is how the animation of the 3D texture coordinates looks like:

// 5 seconds period: t = 0 -> 1
float t = sin( (float)vl::Time::timerSeconds()*vlfPI*2.0f/5.0f) * 0.5f + 0.5f;

mTexCoords_3D->at(0) = vl::fvec3(0, 0, t);
mTexCoords_3D->at(1) = vl::fvec3(0, 1, t);
mTexCoords_3D->at(2) = vl::fvec3(1, 0, t);
mTexCoords_3D->at(3) = vl::fvec3(1, 1, t);
Since the 't' coordinate changes from 0 to 1 the 2d plane will show a series of 2d slices of the 3d texture as if it was a movie!

Now we create a vl::Effect which uses our 3D texture.
In order to use any 3D texture though we have to check that our OpenGL implementation actually supports 3D textures. The GLEW library embedded in Visualization Library lets us do this in a very simple and expressive manner as you can see. We also enable mipmapping as we did in the multi-texturing example. The function that actually creates our 3D texture is setupTexture3D().

    vl::ref<vl::Effect> fx_3d = new vl::Effect;

    if(GLEW_VERSION_1_2||GLEW_EXT_texture3D)
    {
      vl::ref<vl::Texture> texture_3d = new vl::Texture;
      texture_3d->setupTexture3D( img_volume.get(), vl::TF_RGBA, mMipmappingOn, false );
      fx_3d->shader()->gocTextureUnit(0)->setTexture( texture_3d.get() );
      texture_3d->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
      texture_3d->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);
    }
    else
      vl::Log::error("Texture 3D not supported.\n");

At this point we have everything that is needed to create and add an Actor to the scene. We will position the plane on the top left corner <-6,+6,0>. Note that in this case we don't bind act_3d's Transform to any parent Transform as we will not animate it during the rendering. Instead we simply set the local matrix and compute manually the world matrix (which is the one used during the rendering).

    vl::Actor* act_3d = sceneManager()->tree()->addActor( quad_3d.get(), fx_3d.get(), new vl::Transform );
    act_3d->transform()->setLocalMatrix( vl::mat4::translation(-6,+6,0) );
    act_3d->transform()->computeWorldMatrix();
  }

2D Texture Arrays
  void texture2DArray()
  {

Using 2D texture arrays (GL_TEXTURE_2D_ARRAY) is very similar to using normal 3D textures (GL_TEXTURE_3D), but with the following differences:

  • the "r" coordinate of a 2D texture array is expressed as an integer and not as normalized floats (as it is for normal GL_TEXTURE_1D/2D/3D textures), i.e. 1, 2, 3, 4, 5 etc. instead of 0.02, 0.04, 0.06, 0.08 etc. for example.
  • The mipmaps are computed in a different way: if you have a 3D texture whose dimensions are 256x256x256 at level #0, it's mipmap level #1 will be 128x128x128. Instead in 2D texture array each "layer" is kept separate somehow from one another. In fact if the mipmap level #0 of a 2D texture array is 256x256x256, its mipmap level #1 will be 128x128x256. That is, the texture size is half but you still have 256 "layers". For this reason 2D texture arrays occupy more memory that 3D textures.
  • 3D textures can have a texture border, while 2D texture arrays are not allowed to have a border. For more information about the border of a texture refer to the OpenGL function glTexImage1D/2D/3D() documentation.
  • 1D and 2D texture arrays are not available in the fixed function pipeline. In order to take advantage of them you have to use an OpenGL Shading Language program.

For our demo we will use the 2D texture array in the very same way as we did for the 3D textures, but in this case we will put the textured plane on the top right corner. Note the use of the function setupTexture2DArray().

    vl::ref<vl::Image> img_volume = vl::loadImage("/volume/VLTest.dat");
    m2DArraySize = img_volume->depth(); // save this to be used during the animation

    vl::ref<vl::Geometry> quad_2darray = vlut::makeGrid( vl::vec3(0,0,0), 10, 10, 2, 2 );
    quad_2darray->setColorArray(vlut::white);
    quad_2darray->transform( vl::mat4::rotation(90, 1,0,0), false );

    mTexCoords_2DArray = new vl::ArrayFVec3;
    quad_2darray->setTexCoordArray(0, mTexCoords_2DArray.get());
    mTexCoords_2DArray->resize( 2*2 );
    quad_2darray->setVBOEnabled(false);

    vl::ref<vl::Effect> fx_2darray = new vl::Effect;

    if(GLEW_EXT_texture_array||GLEW_VERSION_3_0)
    {
      vl::ref<vl::Texture> texture_2darray = new vl::Texture;
      texture_2darray->setupTexture2DArray( img_volume.get(), vl::TF_RGBA, mMipmappingOn );
      fx_2darray->shader()->gocTextureUnit(0)->setTexture( texture_2darray.get() );
      texture_2darray->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
      texture_2darray->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);

      // we need an OpenGL Shading Language program that uses 'sampler2DArray()' to access the texture!
      vl::GLSLProgram* glsl = fx_2darray->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/texture_2d_array.fs") );
    }
    else
      vl::Log::error("Texture 2d array not supported.\n");

    vl::Actor* act_2darray = sceneManager()->tree()->addActor( quad_2darray.get(), fx_2darray.get(), new vl::Transform );
    act_2darray->transform()->setLocalMatrix( vl::mat4::translation(+6,+6,0) );
    act_2darray->transform()->computeWorldMatrix();
  }

The fragment shader 'glsl/texture_2d_array.fs' used in the example looks like this:

#extension GL_EXT_texture_array: enable
uniform sampler2DArray sampler0;
void main(void)
{
    gl_FragColor = texture2DArray(sampler0, gl_TexCoord[0].xyz );
}

Since the 2D texture arrays take integer coordinates we will animate them using 't*m2DArraySize' instead of simply 't' like this:

    mTexCoords_2DArray->at(0) = vl::fvec3(0, 0, t*m2DArraySize);
    mTexCoords_2DArray->at(1) = vl::fvec3(0, 1, t*m2DArraySize);
    mTexCoords_2DArray->at(2) = vl::fvec3(1, 0, t*m2DArraySize);
    mTexCoords_2DArray->at(3) = vl::fvec3(1, 1, t*m2DArraySize);

1D Texture Arrays
For 1D texture arrays count the considerations that we did for 2D texture arrays.

In this example we create again a plane oriented towards the views with the difference that this time instead of being a simple plane with 2*2=4 vertices we create 2*img_holebox->height() vertices, that is, we cut it in img_holebox->height() slices. Each slice will be textured using a 1D texture taken from the 1D texture array. The resulting image will look very similar to a 2D textured quad.

  void texture1DArray()
  {
    vl::ref<vl::Image> img_holebox = vl::loadImage("/images/holebox.tif");
    m1DArraySize = img_holebox->height(); // save this to be used during the animation

    // create a grid with img_holebox->height() slices
    vl::ref<vl::Geometry> quad_1darray = vlut::makeGrid( vl::vec3(0,0,0), 10, 10, 2, img_holebox->height() );
    quad_1darray->setColorArray(vlut::white);
    quad_1darray->transform( vl::mat4::rotation(90, 1,0,0), false );

    mTexCoords_1DArray = new vl::ArrayFVec2;
    quad_1darray->setTexCoordArray(0, mTexCoords_1DArray.get());
    mTexCoords_1DArray->resize( 2 * img_holebox->height() );
    quad_1darray->setVBOEnabled(false);

    vl::ref<vl::Effect> fx_1darray = new vl::Effect;

    if(GLEW_EXT_texture_array||GLEW_VERSION_3_0)
    {
      vl::ref<vl::Texture> texture_1darray = new vl::Texture;
      texture_1darray->setupTexture1DArray( img_holebox.get(), vl::TF_RGBA, mMipmappingOn );
      fx_1darray->shader()->gocTextureUnit(0)->setTexture( texture_1darray.get() );
      texture_1darray->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
      texture_1darray->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);

      // we need an OpenGL Shading Language program that uses 'sampler1DArray()' to access the texture!
      vl::GLSLProgram* glsl = fx_1darray->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/texture_1d_array.fs") );
    }
    else
      vl::Log::error("Texture 1d array not supported.\n");

    vl::Actor* act_1darray = sceneManager()->tree()->addActor( quad_1darray.get(), fx_1darray.get(), new vl::Transform );
    act_1darray->transform()->setLocalMatrix( vl::mat4::translation(+6,-6,0) );
    act_1darray->transform()->computeWorldMatrix();
  }

The fragment shader 'glsl/texture_1d_array.fs' used in the example looks like this:

#extension GL_EXT_texture_array: enable
uniform sampler1DArray sampler0;
void main(void)
{
    gl_FragColor = texture1DArray(sampler0, gl_TexCoord[0].xyz );
}

Inside the run() method we also animate the s/t texture coordinates of the plane in a more sofisticated way so that the slices of the plane become more apparent:

for(int i=0; i<m1DArraySize; ++i)
{
  mTexCoords_1DArray->at(i*2+0) = vl::fvec2(0+t*0.02f*(i2?+1.0f:-1.0f), (float)i);
  mTexCoords_1DArray->at(i*2+1) = vl::fvec2(1+t*0.02f*(i2?+1.0f:-1.0f), (float)i);
}
The important part to be noted here is that here 'i', an integer coordinate, is used here instead of a normalized floating point number ranging between 0 and 1, as we would have done for 1D, 2D, 3D and cubemap textures.

Texture Rectangle
A texture rectangle (GL_TEXTURE_RECTANGLE) is a special kind of 2D textures often used for post processing effects. They differ from normal 2D texture for the following:
  • Texture rectangle do not support mipmapping.
  • Texture rectangle do not support any texture border.
  • Texture rectangle s/t coordinates are expressed as integers.
  • Texture rectangle supports only the following clamping modes: GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER.

  void textureRectangle()
  {

First we load our image in the usual way

    vl::ref<vl::Image> img_holebox = vl::loadImage("/images/holebox.tif");

Now we create our plane to be textured as we did in the above examples with one major difference, we ask makeGrid() to generate for us 2d texture coordinates ranging from <0,0> to <img_holebox->width(),img_holebox->height()>.

    // generate non-normalized uv coordinates, i.e. from <0,0> to <img_holebox->width(),img_holebox->height()>
    vl::ref<vl::Geometry> quad_rect = vlut::makeGrid( vl::vec3(0,0,0), 10.0f, 10.0f, 2, 2, true, vl::fvec2(0,0), vl::fvec2((float)img_holebox->width(),(float)img_holebox->height()) );
    quad_rect->setColorArray(vlut::white);
    quad_rect->transform( vl::mat4::rotation(90, 1,0,0), false );

Now we create our texture rectangle using the function setupTextureRectangle(). Note that we disable mipmapping and set the clamping mode to vl::TPW_CLAMP (GL_CLAMP).

    vl::ref<vl::Effect> fx_rect = new vl::Effect;

    if(GLEW_ARB_texture_rectangle||GLEW_EXT_texture_rectangle||GLEW_NV_texture_rectangle/*TODO:||GLEW_VERSION_3_1*/)
    {
      vl::ref<vl::Texture> texture_rect = new vl::Texture;
      texture_rect->setupTextureRectangle( img_holebox.get(), vl::TF_RGBA );
      fx_rect->shader()->gocTextureUnit(0)->setTexture( texture_rect.get() );
      // mipmaps not allowed with texture rectangle!
      texture_rect->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
      texture_rect->getTexParameter()->setMinFilter(vl::TPF_LINEAR);
      // GL_REPEAT (the default) not allowed with texture rectangle!
      texture_rect->getTexParameter()->setWrapS(vl::TPW_CLAMP);
      texture_rect->getTexParameter()->setWrapT(vl::TPW_CLAMP);
      texture_rect->getTexParameter()->setWrapR(vl::TPW_CLAMP);
    }
    else
      vl::Log::error("Texture rectangle not supported.\n");

    vl::Actor* act_rect = sceneManager()->tree()->addActor( quad_rect.get(), fx_rect.get(), new vl::Transform );
    act_rect->transform()->setLocalMatrix( vl::mat4::translation(-6,-6,0) );
    act_rect->transform()->computeWorldMatrix();
  }

Spherical mapping
Spherical mapping is a very simple and cheap way to simulate environmental reflection over an object using simple 2D textures.

Spherical mapping is very simple to use all we need is:

  • A spherical map texture
  • A 3d object with normals
  • Appropriate texture coordinates dynamically generated using glTexGen()/GL_SPHERE_MAP

For more information about spherical mapping see also:

  • OpenGL Cube Map Texturing, http://developer.nvidia.com/object/cube_map_ogl_tutorial.html

In our test we will apply spherical mapping to a rotating torus.

  void sphericalMapping()
  {

First of all we load the 2d texture containing our spherical map.

    vl::ref<vl::Image> img_spheric = vl::loadImage("/images/spheremap_klimt.jpg");

Here we create the torus to which we will apply the spherical map. Note that in order to use glTexGen()/GL_SPHERE_MAP our model need to have normals.

    vl::ref<vl::Geometry> torus = vlut::makeTorus(vl::vec3(), 8,3, 40,40);
    // we need normals in order for GL_SPHERE_MAP to work correctly!
    torus->computeNormals();

The Effect applied to the torus will have depht testing, back face culling and lighting. Note that since no transform is specified for the light this means that the light will follow the camera (ie. a headlight).

    mFXSpheric = new vl::Effect;
    mFXSpheric->shader()->enable(vl::EN_DEPTH_TEST);
    mFXSpheric->shader()->enable(vl::EN_CULL_FACE);
    mFXSpheric->shader()->enable(vl::EN_LIGHTING);
    mFXSpheric->shader()->setRenderState( new vl::Light(0) );
    // to ensure the torus is drawn after the textured quads
    mFXSpheric->setRenderRank(1);

Now we apply the texture to the effect used by the torus and enable sphere-map automatic texture coordinate generation.

    vl::ref<vl::Texture> texture_spheric = new vl::Texture;
    texture_spheric->setupTexture2D( img_spheric.get(), vl::TF_RGBA, mMipmappingOn, false );
    mFXSpheric->shader()->gocTextureUnit(0)->setTexture( texture_spheric.get() );
    texture_spheric->getTexParameter()->setAnisotropy(16.0);
    texture_spheric->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
    texture_spheric->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);
    // enable automatic texture generation for s,t
    mFXSpheric->shader()->gocTexGen(0)->setGenModeS(vl::TGM_SPHERE_MAP);
    mFXSpheric->shader()->gocTexGen(0)->setGenModeT(vl::TGM_SPHERE_MAP);

Finally we add the torus to the scene and its transform to the scene's root transform, so that it gets updated every frame.

    mActSpheric = sceneManager()->tree()->addActor( torus.get(), mFXSpheric.get(), new vl::Transform );
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mActSpheric->transform() );
  }

Cubemaps
Cubemapping is a very flexible technique used to achieve many different kinds of effects. Here we will use cubmapping to implement the so called "environment mapping" which is a technique that simulates the environmental reflection over an object. While using spherical mapping the reflection always faces the camera (unless you regenerate it on the fly every frame), cubemapping lets you use a single cubemap texture to simulate a much more realistic three-dimensional reflection.

Implementing cubemapping is also very simple with Visualization Library, all you need is:

  • A cubemap texture
  • A 3d model with normals
  • Appropriate texture coordinates dynamically generated using glTexGen()/GL_REFLECTION_MAP

  void cubeMapping()
  {

You can load cubemap images in many different ways. You can assemble them on the fly using the vl::loadAsCubemap() functions or you can load it directly from a DDS file with the vl::loadImage() function.

    // cube mapping, see also http://developer.nvidia.com/object/cube_map_ogl_tutorial.html

    vl::ref<vl::Image> img_cubemap = vl::loadCubemap(
      "/images/cubemap/cubemap00.png", // (x+) right
      "/images/cubemap/cubemap01.png", // (x-) left
      "/images/cubemap/cubemap02.png", // (y+) top
      "/images/cubemap/cubemap03.png", // (y-) bottom
      "/images/cubemap/cubemap04.png", // (z+) back
      "/images/cubemap/cubemap05.png");// (z-) front

Create a torus and compute its normals.

    vl::ref<vl::Geometry> torus = vlut::makeTorus( vl::vec3(), 8,3, 40,40 );
    // we need normals in order for GL_REFLECTION_MAP to work correctly!
    torus->computeNormals();

Setup a simple Effect like we did for the sphere mapping example.

    mFXCubic = new vl::Effect;
    mFXCubic->shader()->enable(vl::EN_DEPTH_TEST);
    mFXCubic->shader()->enable(vl::EN_CULL_FACE);
    mFXCubic->shader()->enable(vl::EN_LIGHTING);
    mFXCubic->shader()->setRenderState( new vl::Light(0) );
    // to ensure the torus is drawn after the textured quads
    mFXCubic->setRenderRank(1);

Here we create the cubemap texture. Note that in order to use cubmaps we need to check that either the GL_ARB_texture_cube_map extension or OpenGL 1.3 is supported. Note that we use the GL_CLAMP_TO_EDGE mode here to minimize the seams of the cubemaps. This does not remove the seams totally. In order to have a cubemap without seams the cubemap must be properly generated and adjusted by the texture artist. Note that we use GL_REFLECTION_MAP texture generation mode for the S, T and R texture coordinates. Remember that this texture generation mode works properly only when the model has the normals, as we already discussed. Note also the line:

mFXCubic->shader()->gocTextureMatrix(0)->setUseCameraRotationInverse(true);
This tells VL to put in the texture matrix the inverse of the camera rotation. This puts into world-space the cubemap texture coordinates automatically generated by OpenGL, which would otherwise be in eye-space (ie. always facing the camera).

    if (GLEW_VERSION_1_3||GLEW_ARB_texture_cube_map)
    {
      vl::ref<vl::Texture> texture_cubic = new vl::Texture;
      texture_cubic->setupTextureCubemap( img_cubemap.get(), vl::TF_RGBA, mMipmappingOn, false );
      mFXCubic->shader()->gocTextureUnit(0)->setTexture( texture_cubic.get() );
      texture_cubic->getTexParameter()->setAnisotropy(16.0);
      texture_cubic->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
      texture_cubic->getTexParameter()->setMinFilter(vl::TPF_LINEAR_MIPMAP_LINEAR);
      texture_cubic->getTexParameter()->setWrapS(vl::TPW_CLAMP_TO_EDGE);
      texture_cubic->getTexParameter()->setWrapT(vl::TPW_CLAMP_TO_EDGE);
      texture_cubic->getTexParameter()->setWrapR(vl::TPW_CLAMP_TO_EDGE);
      // enable automatic texture generation for s,t,r
      mFXCubic->shader()->gocTexGen(0)->setGenModeS(vl::TGM_REFLECTION_MAP);
      mFXCubic->shader()->gocTexGen(0)->setGenModeT(vl::TGM_REFLECTION_MAP);
      mFXCubic->shader()->gocTexGen(0)->setGenModeR(vl::TGM_REFLECTION_MAP);
      // texture matrix
      mFXCubic->shader()->gocTextureMatrix(0)->setUseCameraRotationInverse(true);
    }
    else
      vl::Log::error("Texture cubemap not supported.\n");

Finally we add the torus to the scene and its transform to the scene's root transform, so that it gets updated every frame.

    mActCubic = sceneManager()->tree()->addActor( torus.get(), mFXCubic.get(), new vl::Transform );
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mActCubic->transform() );
  }

Animation
The animation of the texture coordinates and of the transformed objects is implemented in the run() virtual function as shown below:

  void run()
  {
    // rotating cubes

    if (GLEW_ARB_multitexture)
    {
      mCubeRightTransform->setLocalMatrix( vl::mat4::translation(+6,0,0) * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
      mCubeLeftTransform ->setLocalMatrix( vl::mat4::translation(-6,0,0) * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
    }

    // 5 seconds period
    float t = sin( (float)vl::Time::currentTime()*vl::fPi*2.0f/5.0f) * 0.5f + 0.5f;
    t = t * (1.0f - 0.02f*2) + 0.02f;

    // 3d texture coordinates animation

    mTexCoords_3D->at(0) = vl::fvec3(0, 0, t);
    mTexCoords_3D->at(1) = vl::fvec3(0, 1, t);
    mTexCoords_3D->at(2) = vl::fvec3(1, 0, t);
    mTexCoords_3D->at(3) = vl::fvec3(1, 1, t);

    // 2d texture array coordinates animation

    mTexCoords_2DArray->at(0) = vl::fvec3(0, 0, t*m2DArraySize);
    mTexCoords_2DArray->at(1) = vl::fvec3(0, 1, t*m2DArraySize);
    mTexCoords_2DArray->at(2) = vl::fvec3(1, 0, t*m2DArraySize);
    mTexCoords_2DArray->at(3) = vl::fvec3(1, 1, t*m2DArraySize);

    // 1d texture array coordinates animation

    for(int i=0; i<m1DArraySize; ++i)
    {
      mTexCoords_1DArray->at(i*2+0) = vl::fvec2(0+t*0.02f*(i%2?+1.0f:-1.0f), (float)i);
      mTexCoords_1DArray->at(i*2+1) = vl::fvec2(1+t*0.02f*(i%2?+1.0f:-1.0f), (float)i);
    }

    // spherical mapped torus rotation

    mActSpheric->transform()->setLocalMatrix( vl::mat4::translation(0,+6,0)*vl::mat4::rotation(45*vl::Time::currentTime(),1,0,0) );
    mActSpheric->transform()->computeWorldMatrix();

    // cube mapped torus rotation

    mActCubic->transform()->setLocalMatrix( vl::mat4::translation(0,-6,0)*vl::mat4::rotation(45*vl::Time::currentTime(),1,0,0) );
    mActCubic->transform()->computeWorldMatrix();
  }

Reflectivity
A classic method to simulate sharp/dull reflectivity is to manually change the lod bias via the glTexEnv() command. The Lod Bias modifies the way OpenGL selects the set of mipmaps to be used during the rendering. A higher lod bias will make OpenGL select mipmaps of a higher level (smaller images) thus the reflected image will look more blurry and less sharp. This will produce an effect similar to a rough and opaque surface. Instead, if the lod bias is set to 0 (default) the reflection will look very sharp and definite as if the surface was a perfectly polished mirror. In our test we can dynamically adjust the lod bias using the mouse wheel:

  virtual void mouseWheelEvent(int w)
  {
    mLodBias += w*0.3f;
    mLodBias = vl::clamp(mLodBias, 0.0f, 4.0f);

    mFXSpheric->shader()->gocTexEnv(0)->setLodBias(mLodBias);
    mFXCubic->shader()->gocTexEnv(0)->setLodBias(mLodBias);
  }

Test initialization
The following function shows the simple steps used to initialize our test and the protected data used by our applet.

  virtual void initEvent()
  {
    BaseDemo::initEvent();

    trackball()->setTransform(vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform());

    mMipmappingOn = true;
    mLodBias = 0.0;

    multitexturing();
    textureRectangle();
    texture3D();
    texture2DArray();
    texture1DArray();
    sphericalMapping();
    cubeMapping();
  }

protected:
  vl::ref<vl::Transform> mCubeRightTransform;
  vl::ref<vl::Transform> mCubeLeftTransform;
  vl::ref<vl::ArrayFVec3> mTexCoords_3D;
  vl::ref<vl::ArrayFVec3> mTexCoords_2DArray;
  vl::ref<vl::ArrayFVec2> mTexCoords_1DArray;
  int m1DArraySize;
  int m2DArraySize;
  vl::Actor* mActSpheric;
  vl::Actor* mActCubic;
  vl::ref<vl::Effect> mFXSpheric;
  vl::ref<vl::Effect> mFXCubic;
  float mLodBias;
  bool mMipmappingOn;
};

Conclusions
This tutorial gave you the basic knowledge to start using several standard and advanced texturing techniques like 2D texturing, multi-texturing, 3D textures, 1D and 2D texture arrays, sphere-mapping, cubemap environment mapping and lod bias manipulation. For all the details and secrets of OpenGL texturing the definitive guide remains the OpenGL Programmer's Guide.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Rendering Order Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Rendering Order Tutorial

This tutorial will explain how to define the rendering order of a set of objects.

Visualization Library employs a simple and extensible mechanism to define the rendering order. Once Visualization Library extracts all the visible objects present in a scene, a special class called vl::RenderQueueSorter is used to appriately sort such objects. The vl::RenderQueueSorter is the ultimate responsible for such sorting. You can even create your own vl::RenderQueueSorter and install it on your vl::Rendering.

The default vl::RenderQueueSorter is vl::RenderQueueSorterStandard, which implements a sorting mechanism that tries to achieve the following goals:

  • Enforce user-defined rendering order
  • Depth-sort transparent object
  • Minimize render state changes

The user can fine tune the rendering order of a set of Actors using the following member functions:

  • vl::Actor::setRenderBlock(int block)
  • vl::Effect::setRenderRank(int rank)
  • vl::Actor::setRenderRank(int rank)

The higher the rank or block, the later an Actor is rendered.

The Actors are first sorted by their Actor Render Block, then by their Effect Render Rank, then by their Actor Render Rank. Using this three-level sorting the developer can deal with very complex sorting scenarios. This means that first of all you can divide all your Actors into blocks. Within a block you can subdivide them by their Effect render rank. Within the same Effect render rank you can again subdivide them based on the Actor render rank. The default rank and block is zero.

When two Actors have the same block and rank it means that the application does not care about their rendering order, so Visualization Library uses this chance to sort them in a way that the objects with similar materials, textures, shaders etc. are rendered as grouped as possible to maximize the rendering performances.

If at least one of the two objects is using alpha blending then Visualization Library will automatically perform a depth-sort for two objects to obtain a correct rendering.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: OpenGL Shading Language Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

OpenGL Shading Language Tutorial

This tutorial shows how simple it is to use the OpenGL Shading Language with Visualization Library.

The example below demostrates the use of vertex shaders, fragment shaders and geometry shaders.

[From App_GLSL.hpp]

class App_GLSL: public BaseDemo
{
public:
  App_GLSL()
  {
    mTransform1 = new vl::Transform;
    mTransform2 = new vl::Transform;
    mTransform3 = new vl::Transform;
    mTransform4 = new vl::Transform;
    mTransform5 = new vl::Transform;
  }

  void initEvent()
  {
    if (!GLEW_ARB_shading_language_100)
    {
      vl::Log::error("GL_ARB_shading_language_100 not supported.\n");
      vl::Time::sleep(3000);
      openglContext()->quitApplication();
    }

    BaseDemo::initEvent();

    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform1.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform2.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform3.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform4.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform5.get());

    vl::ref<vl::ResourceDatabase> res_db = vl::loadResource("/models/3ds/monkey.3ds");
    vl::ref<vl::Geometry> model = res_db->get<vl::Geometry>(0);

    vl::ref<vl::Light> light = new vl::Light(0);

    vl::ref<vl::Effect> effect1 = new vl::Effect;
    effect1->shader()->setRenderState( light.get() );
    effect1->shader()->enable(vl::EN_LIGHTING);
    effect1->shader()->enable(vl::EN_DEPTH_TEST);
    effect1->shader()->enable(vl::EN_CULL_FACE);
    sceneManager()->tree()->addActor( model.get(), effect1.get(), mTransform1.get() );

    vl::ref<vl::Effect> effect2 = new vl::Effect;
    effect2->shader()->setRenderState( light.get() );
    effect2->shader()->enable(vl::EN_LIGHTING);
    effect2->shader()->enable(vl::EN_DEPTH_TEST);
    effect2->shader()->enable(vl::EN_CULL_FACE);
    sceneManager()->tree()->addActor( model.get(), effect2.get(), mTransform2.get() );

    vl::ref<vl::Effect> effect3 = new vl::Effect;
    effect3->shader()->setRenderState( light.get() );
    effect3->shader()->enable(vl::EN_LIGHTING);
    effect3->shader()->enable(vl::EN_DEPTH_TEST);
    effect3->shader()->enable(vl::EN_CULL_FACE);
    sceneManager()->tree()->addActor( model.get(), effect3.get(), mTransform3.get() );

    vl::ref<vl::Effect> effect4 = new vl::Effect;
    effect4->shader()->setRenderState( light.get() );
    effect4->shader()->enable(vl::EN_LIGHTING);
    effect4->shader()->enable(vl::EN_DEPTH_TEST);
    effect4->shader()->enable(vl::EN_CULL_FACE);
    sceneManager()->tree()->addActor( model.get(), effect4.get(), mTransform4.get() );

    vl::ref<vl::Effect> effect5 = new vl::Effect;
    effect5->shader()->setRenderState( light.get() );
    effect5->shader()->enable(vl::EN_LIGHTING);
    effect5->shader()->enable(vl::EN_DEPTH_TEST);
    effect5->shader()->enable(vl::EN_CULL_FACE);
    sceneManager()->tree()->addActor( model.get(), effect5.get(), mTransform5.get() );

    if (GLEW_ARB_shading_language_100)
    {
      vl::ref<vl::GLSLProgram> glsl;

      glsl = effect1->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLVertexShader("/glsl/perpixellight.vs") );
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/perpixellight_cartoon.fs") );

      glsl = effect2->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLVertexShader("/glsl/perpixellight.vs") );
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/perpixellight.fs") );

      glsl = effect3->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLVertexShader("/glsl/perpixellight.vs") );
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/heat.fs") );

      glsl = effect4->shader()->gocGLSLProgram();
      glsl->attachShader( new vl::GLSLVertexShader("/glsl/perpixellight.vs") );
      glsl->attachShader( new vl::GLSLFragmentShader("/glsl/perpixellight_interlaced.fs") );

      if (GLEW_NV_geometry_shader4)
      {
        glsl = effect5->shader()->gocGLSLProgram();
        // a vertex shader is always needed when using geometry shaders
        glsl->attachShader( new vl::GLSLVertexShader("/glsl/diffuse.vs") );
        glsl->attachShader( new vl::GLSLGeometryShader("/glsl/triangle_fur.gs") );
        glsl->setGeometryInputType(vl::GIT_TRIANGLES);
        glsl->setGeometryOutputType(vl::GOT_TRIANGLE_STRIP);
        glsl->setGeometryVerticesOut( 3*6 );
      }
      else
      {
        effect5->shader()->gocMaterial()->setDiffuse(vlut::red);
        vl::Log::print("GL_NV_geometry_shader4 not supported.\n");
      }
    }
  }

  void run()
  {
    // animate the transforms
    mTransform1->setLocalMatrix( vl::mat4::translation(-2,2,0)  * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
    mTransform2->setLocalMatrix( vl::mat4::translation(+2,2,0)  * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
    mTransform3->setLocalMatrix( vl::mat4::translation(-2,-2,0) * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
    mTransform4->setLocalMatrix( vl::mat4::translation(+2,-2,0) * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
    mTransform5->setLocalMatrix( vl::mat4::translation(0,0,0)   * vl::mat4::rotation( vl::Time::currentTime()*45, 0, 1, 0) );
  }

  void shutdown() {}

protected:
  vl::ref<vl::Transform> mTransform1;
  vl::ref<vl::Transform> mTransform2;
  vl::ref<vl::Transform> mTransform3;
  vl::ref<vl::Transform> mTransform4;
  vl::ref<vl::Transform> mTransform5;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Picking and Selection Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Picking and Selection Tutorial

This tutorial demonstrates how to use the vl::RayIntersector class to interactively pick and select objects in the scene.

In this tutorial we will populate the scene with a few random objects. Then when the mouse is pressed we compute the ray projected from the mouse click position towards the scene and use it to compute the intersections point. If any intersection is found we highlight the intersection point by moving there a green sphere.

[From App_Picking.hpp]

class App_Picking: public BaseDemo
{
public:

  void mouseDownEvent(vl::EMouseButton, int x, int y)
  {
    vl::Camera* camera = vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera();

    // convert Y coordinates to the OpenGL conventions
    y = openglContext()->height() - y;
    // compute the ray passing through the selected pixel
    vl::Ray ray = camera->computeRay(x,y);
    // instance our ray-intersector
    vl::RayIntersector intersector;
    // compute a frustum along the ray to accelerate the intersection test
    intersector.setFrustum( camera->computeRayFrustum( x,y ) );
    // compute the intersections!
    // (1) short way
    intersector.intersect(ray, sceneManager());
    // (2) long way
    /*
    // specify the Actor[s] to be tested
    intersector.actors()->clear();
    sceneManager()->appendActors( *intersector.actors() );
    // set the intersecting ray
    intersector.setRay(ray);
    // run intersection test
    intersector.intersect();
    */

    // inspect our intersections, the intersections returned are sorted according to their distance, the first one is the closest.
    if (intersector.intersections().size())
    {
      // highlight the intersection point by moving the green sphere there
      mIntersectionPoint->setLocalMatrix( vl::mat4() );
      mIntersectionPoint->translate( intersector.intersections()[0]->intersectionPoint() );
      mIntersectionPoint->computeWorldMatrix();

      // print the name of the picked object
      vl::Log::print( vl::Say("Intersections detected = %n (%s).\n") << intersector.intersections().size() << intersector.intersections()[0]->actor()->name() );
    }
    else
      vl::Log::print("No intersections detected.\n");
  }

  virtual void initEvent()
  {
    BaseDemo::initEvent();

    // populate our scene with some random objects

    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->gocLight(0)->setLinearAttenuation(0.025f);
    fx->shader()->gocMaterial()->setColorMaterialEnabled(true);

    int   count    = 1;
    float displace = 2.0f;
    for(int z=-count; z<=count; ++z)
    for(int y=-count; y<=count; ++y)
    for(int x=-count; x<=count; ++x)
    {
      vl::ref<vl::Geometry> geom = randomObject();
      vl::Actor* act = sceneManager()->tree()->addActor( geom.get(), fx.get(), new vl::Transform );
      act->setName(geom->name());
      act->transform()->translate(x*displace, y*displace, z*displace);
      act->transform()->computeWorldMatrix();
    }

    // create a uv-sphere used to highlight the intersection point

    vl::ref<vl::Geometry> intersection_point_geom = vlut::makeUVSphere(vl::vec3(0,0,0), 0.1f);
    intersection_point_geom->computeNormals();
    intersection_point_geom->setColorArray(vlut::green);
    vl::Actor* intersection_point_act = sceneManager()->tree()->addActor( intersection_point_geom.get(), fx.get(), new vl::Transform );
    mIntersectionPoint = intersection_point_act->transform();
  }

  // generate random objects
  vl::ref<vl::Geometry> randomObject()
  {
    vl::ref<vl::Geometry> geom;
    // random shape
    switch(rand() % 6)
    {
      case 0: geom = vlut::makeIcosphere(vl::vec3(0,0,0), 1, 2, false); break;
      case 1: geom = vlut::makeBox(vl::vec3(0,0,0), 1, 1, 1); break;
      case 2: geom = vlut::makeCone(vl::vec3(0,0,0),1,1); break;
      case 3: geom = vlut::makeUVSphere(vl::vec3(0,0,0),1); break;
      case 4: geom = vlut::makeCylinder(vl::vec3(0,0,0),1,1); break;
      case 5: geom = vlut::makeTorus(vl::vec3(0,0,0),2,0.5f,20,20); break;
    }
    // random color
    geom->setColorArray( vl::fvec4((float)vl::randomMinMax(0,1), (float)vl::randomMinMax(0,1), (float)vl::randomMinMax(0,1),1.0f) );
    // normals are needed for lighting
    geom->computeNormals();
    return geom;
  }

protected:
  vl::Transform* mIntersectionPoint;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Volume Rendering and Isosurfaces Extraction with Marching Cubes Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Volume Rendering and Isosurfaces Extraction with Marching Cubes Tutorial

This tutorial demonstrates how to use the marching cubes algorithm to extract isosurfaces from volume data.

[From App_MarchingCubes.hpp]

class App_MarchingCubes: public BaseDemo
/*
 * This applet demonstrates: how to use marching cubes to generate isosurfaces, how to visualize multiple intersecting volumes,
 * how to manage transparencies, how to color the isosurface using texturing and vertex color, how to implement a simple metaballs demo
 * and how to simulate a metaballs/water fountain.
 *
 * Test 0: drag and drop a volume in the window and use the mouse wheel to visualize the appropriate iso-surface level.
 * Test 1: multiple self-intersecting transparent isosurfaces visualization.
 * Test 2: isosurface colorize via texturing.
 * Test 3: isosurface colorize via vertex color.
 * Test 4: animated metaball demo implemented on top of the marching cube algorithm.
 * Test 5: animated fountain based on marching cubes.
 * Test 6: 3D function plotting with vlVolume::VolumePlot
 *
 */
{
public:
  App_MarchingCubes(): mTest(4) {}

  void initEvent()
  {
    BaseDemo::initEvent();
    openglContext()->setContinuousUpdate(true);

    srand((unsigned int)time(NULL));

    mThreshold = 0.44f;
    mFountainSpeed = 2.5f;

    // setup metaballs data

    mMetaball.resize(mParticleCount);
    mMetaballVelocity.resize(mParticleCount);
    mMetaballsFrames.resize(mFrameCount);
    for(int iframe=0; iframe<mFrameCount; ++iframe)
    {
      mMetaballsFrames[iframe].resize(mParticleCount);
      for(int iball=0; iball<mParticleCount; ++iball)
      {
        mMetaballsFrames[iframe][iball].x() = (rand()%100 / 100.0f)*0.6f+0.2f;
        mMetaballsFrames[iframe][iball].y() = (rand()%100 / 100.0f)*0.6f+0.2f;
        mMetaballsFrames[iframe][iball].z() = (rand()%100 / 100.0f)*0.6f+0.2f;
      }
    }

    // load images

    mVolumeImage = vl::loadImage("/volume/VLTest.dat")->convertFormat(vl::IF_LUMINANCE)->convertType(vl::IT_FLOAT);
    mColorImage  = vl::loadImage("/volume/VLTest.dat");

    // transform

    mTransform = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mTransform.get() );

    // text setup

    mText = new vl::Text();
    mText->setDisplayListEnabled(true);
    mText->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10) );
    mText->setMargin(5);
    mText->setViewportAlignment(vl::AlignTop | vl::AlignHCenter);
    mText->setAlignment(vl::AlignTop | vl::AlignHCenter);
    mText->setTextAlignment(vl::TextAlignCenter);
    mText->setColor(vlut::white);
    mText->setBackgroundColor(vl::fvec4(0,0,0,.75f));
    mText->setBackgroundEnabled(true);
    mText->setText("Marching Cubes Demo");

    vl::ref< vl::Effect > text_fx = new vl::Effect;
    text_fx->shader()->enable(vl::EN_BLEND);

    mTextActor = new vl::Actor( mText.get(), text_fx.get() );
    sceneManager()->tree()->addActor( mTextActor.get() );

    setupTest();
  }

  virtual void run()
  {
    if (mTest == 4)
      runTest4();
    else
    if (mTest == 5)
      runTest5();
  }

  void runTest4()
  {
    // rotate metaballs
    vl::vec3 axis;
    axis.x() = sin( vl::Time::currentTime()*3.1415*2.0f/8.0f );
    axis.y() = 0;
    axis.z() = cos( vl::Time::currentTime()*3.1415*2.0f/8.0f );
    axis.normalize();
    if (axis.isNull())
      return;
    mTransform->setLocalMatrix( vl::mat4::rotation( vl::Time::currentTime()*120.0f, axis) );
    // animate metaballs
    float t = (float)vl::fract( vl::Time::currentTime()*0.05f );
    t = vl::clamp(t, 0.0f, 0.999f);
    int frame1 = int(t * mFrameCount);
    int frame2 = (frame1+1) % mFrameCount;
    t = vl::fract(t*mFrameCount);
    float Ha = 2*t*t*t - 3*t*t + 1;
    float Hb = -2*t*t*t + 3*t*t;
    for(unsigned iball=0; iball<mMetaball.size(); ++iball)
      mMetaball[iball] = mMetaballsFrames[frame1][iball]*Ha + mMetaballsFrames[frame2][iball]*Hb;

    int idx = 0;
    float* values = &mMarchingCubes.volumeInfo()->at(0)->volume()->value(0);
    for(int z=0; z<mMetaballsResolution; ++z)
    {
      float pz = (float)z/mMetaballsResolution;
      for(int y=0; y<mMetaballsResolution; ++y)
      {
        float py = (float)y/mMetaballsResolution;
        for(int x=0; x<mMetaballsResolution; ++x, ++idx)
        {
          values[idx] = metaballFunction((float)x/mMetaballsResolution, py, pz);
        }
      }
    }
    // notify that the volume data has changed
    mMarchingCubes.volumeInfo()->at(0)->volume()->setDataDirty();
    mMarchingCubes.run(false);
  }

  void runTest5()
  {
    // animate metaballs
    for(unsigned iball=0; iball<mMetaball.size(); ++iball)
    {
      mMetaballVelocity[iball] -= vl::fvec3(0,1.5f,0)*(float)mTimer.elapsed()*mFountainSpeed;

      mMetaball[iball] = mMetaball[iball] + mMetaballVelocity[iball]*(float)mTimer.elapsed();
      if (mMetaball[iball].y() < 0)
      {
        mMetaball[iball].y() = 0;
        mMetaball[iball].x() = 0.5f;
        mMetaball[iball].z() = 0.5f;
        mMetaballVelocity[iball].x() = (float)vl::randomMinMax(-12,+12);
        mMetaballVelocity[iball].z() = (float)vl::randomMinMax(-12,+12);
        mMetaballVelocity[iball].y() = 100;
        mMetaballVelocity[iball].normalize();
        mMetaballVelocity[iball] *= (17.0f + (float)vl::randomMinMax(0,5))*0.05f*mFountainSpeed;
      }
    }
    mTimer.start();

    int idx = 0;
    float* values = &mMarchingCubes.volumeInfo()->at(0)->volume()->value(0);
    for(int z=0; z<mMetaballsResolution; ++z)
    {
      float pz = (float)z/mMetaballsResolution;
      for(int y=0; y<mMetaballsResolution; ++y)
      {
        float py = (float)y/mMetaballsResolution;
        for(int x=0; x<mMetaballsResolution; ++x, ++idx)
          values[idx] = metaballFunction((float)x/mMetaballsResolution, py, pz);
      }
    }
    // notify that the volume data has changed
    mMarchingCubes.volumeInfo()->at(0)->volume()->setDataDirty();
    mMarchingCubes.run(false);
  }

  float metaballFunction(float x, float y, float z)
  {
    float val = 0;
    for(unsigned i=0; i<mMetaball.size(); ++i)
    {
      float rx = x-mMetaball[i].x();
      float ry = y-mMetaball[i].y();
      float rz = z-mMetaball[i].z();
      float r2 = rx*rx+ry*ry+rz*rz;
      if (r2 == 0.0f)
        return 1.0e+10f;
      val += vl::fast1_inversesqrt(r2*r2);    // threshold = 400
      // val += vl::fast2_inversesqrt(r2*r2); // threshold = 400
      // val += 1.0f / r2;                    // threshold = 400
      // val += vl::fast1_inversesqrt(r2);    // threshold = 70
      // val += vl::fast2_inversesqrt(r2);    // threshold = 70
    }
    return val;
  }

  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch,key);
    bool update = false;
    if (key == vl::Key_Right)
    {
      mTest++;
      update = true;
    }
    else
    if (key == vl::Key_Left)
    {
      mTest--;
      update = true;
    }
    if (update)
    {
      if (mTest > 6) mTest = 0;
      if (mTest < 0) mTest = 6;
      setupTest();
      updateText();
    }
  }

  // generates the 2 transparent volumes or a single volume
  vl::Actor* showVolumes(bool test1)
  {
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setInverseViewMatrix( vl::mat4::translation(0,0,20) );

    vl::ref<vl::Geometry > geom = new vl::Geometry;
    geom->setVertexArray(mMarchingCubes.mVertsArray.get());
    geom->setNormalArray(mMarchingCubes.mNormsArray.get());
    geom->primitives()->push_back(mMarchingCubes.mDrawElements.get());

    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->setRenderState( new vl::Light(0) );
    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    // two side lighting
    fx->shader()->gocLightModel()->setTwoSide(true);

    vl::ref<vl::Actor> act = new vl::Actor(geom.get(), fx.get(), NULL);
    sceneManager()->tree()->actors()->clear();
    sceneManager()->tree()->addActor(act.get());
    sceneManager()->tree()->addActor( mTextActor.get() );

    vl::ref<vlVolume::Volume> volume = new vlVolume::Volume;
    volume->setup( (float*)mVolumeImage->pixels(), vl::fvec3(-5,-5,-5), vl::fvec3(+5,+5,+5), vl::ivec3(mVolumeImage->width(), mVolumeImage->height(), mVolumeImage->depth()) );

    mMarchingCubes.reset();
    mMarchingCubes.volumeInfo()->push_back( new vlVolume::VolumeInfo( volume.get(), 0.40f, /*yellow*/vl::fvec4(1, 1, 0, 0.5f)) );
    if (test1)
    {
      // generate second volume
      mMarchingCubes.volumeInfo()->push_back( new vlVolume::VolumeInfo( volume.get(), 0.50f, /*red*/vl::fvec4(1, 0, 0, 0.5f)) );
      // enable blend
      fx->shader()->enable(vl::EN_BLEND);
      // use color array
      fx->shader()->gocMaterial()->setColorMaterialEnabled(true);
      // polygon depth sorting
      act->renderingCallbacks()->push_back( new vl::DepthSortCallback );
      // binds the marching cubes color array
      geom->setColorArray (mMarchingCubes.mColorArray.get());
    }

    mMarchingCubes.run(true);

    // stats
    vl::String stats;
    stats += vl::Say("triangles = %n\n") << mMarchingCubes.mDrawElements->triangleCount();
    stats += vl::Say("vertices  = %n\n") << mMarchingCubes.mVertsArray->size();
    vl::Log::print(stats);

    return act.get();
  }

  // Coloring a volume using a 3d texture can be very useful when the color of the texture is animated
  // i.e. changes relatively rapidly or when the isosurface itself changes or is animated.
  // Cons:
  // 1 - the texture can occupy a large amount of memory
  // 2 - to guarantee maximum compatibility the texture should be a cube (not a rectangle) whose side length is a power of 2.
  void textureVolumeColor(vl::Actor* vol_act)
  {
    vl::Effect* fx = vol_act->effect();

    // automatic 3D texture coordinate generation
    #if 1
      fx->shader()->gocTextureUnit(0)->setTexture( new vl::Texture( mColorImage.get() ) );
      fx->shader()->gocTexGen(0)->setGenModeS(vl::TGM_OBJECT_LINEAR);
      fx->shader()->gocTexGen(0)->setGenModeT(vl::TGM_OBJECT_LINEAR);
      fx->shader()->gocTexGen(0)->setGenModeR(vl::TGM_OBJECT_LINEAR);
      /* the settings below are the defaults
      fx->shader()->gocTexGen(0)->setObjectPlaneS(vl::fvec4(1,0,0,0));
      fx->shader()->gocTexGen(0)->setObjectPlaneT(vl::fvec4(0,1,0,0));
      fx->shader()->gocTexGen(0)->setObjectPlaneR(vl::fvec4(0,0,1,0));
      fx->shader()->gocTexEnv(0)->setMode(vl::TEM_MODULATE);*/
      vol_act->lod(0)->computeBounds();
      vl::AABB box = vol_act->lod(0)->boundingBox();
      // transforms object vertex coordinates to 0..1 cube, this might create a "bleeding color" effect at the very side of the cube.
      // note that to be really precise we should use 1/2N ... 1-1/2N in each direction instead of 0..1.
      vl::mat4 tex_mat = vl::mat4::translation( vl::vec3(0.5f,0.5f,0.5f) ) *
                         vl::mat4::scaling(1.0f/box.width(),1.0f/box.height(),1.0f/box.depth()) *
                         vl::mat4::translation( -box.center() );
      fx->shader()->gocTextureMatrix(0)->setMatrix(tex_mat);
    #endif

    // the above code is equivalent to the code below that manually generates the texture coordinates.
    #if 0
      // transforms object vertex coordinates to 0..1 cube.
      vol_act->lod(0)->computeBounds();
      vl::AABB box = vol_act->lod(0)->boundingBox();
      vl::mat4 tex_mat = vl::mat4::translation( vl::vec3(0.5f,0.5f,0.5f) ) *
                         vl::mat4::scaling(1.0f/box.width(),1.0f/box.height(),1.0f/box.depth()) *
                         vl::mat4::translation( -box.center() );

      fx->shader()->gocTextureUnit(0)->setTexture( new vl::Texture( mColorImage.get() ) );
      vl::ref<vl::ArrayFVec3> tex_array = new vl::ArrayFVec3;
      tex_array->resize( geom->vertexArray()->size() );
      geom->setTexCoordArray(0, tex_array.get());
      for(int i=0; i<tex_array->size(); ++i)
        tex_array->at(i) = ((vl::fvec4)(tex_mat * geom->vertexArray()->vectorAsVec4(i))).xyz();
    #endif
  }

  // Coloring a volume assigning a color to each vertex directly can save memory compared to using a 3D texture,
  // and no 3D texturing is needed so there aren't compatibility issues.
  // This technique is not particularly efficient if your isosurfaces are animated and you need to recompute the colors often.
  void vertexVolumeColor(vl::Actor* vol_act)
  {
    vl::Geometry* geom = dynamic_cast<vl::Geometry*>(vol_act->lod(0).get());
    vl::Effect* fx = vol_act->effect();
    // use color array
    fx->shader()->gocMaterial()->setColorMaterialEnabled(true);

    // transforms object vertex coordinates to 0..1 cube.
    vol_act->lod(0)->computeBounds();
    vl::AABB box = vol_act->lod(0)->boundingBox();
    vl::mat4 tex_mat = vl::mat4::translation( vl::vec3(0.5f,0.5f,0.5f) ) *
                       vl::mat4::scaling(1.0f/box.width(),1.0f/box.height(),1.0f/box.depth()) *
                       vl::mat4::translation( -box.center() );

    vl::ref<vl::ArrayFVec4> color_array = new vl::ArrayFVec4;
    color_array->resize( geom->vertexArray()->size() );
    geom->setColorArray(color_array.get());
    for(int i=0; i<color_array->size(); ++i)
    {
      vl::vec4 px = tex_mat * geom->vertexArray()->vectorAsVec4(i);
      px.x() *= mColorImage->width();
      px.y() *= mColorImage->height();
      px.z() *= mColorImage->depth();
      color_array->at(i) = mColorImage->sampleLinear(px.x(), px.y(), px.z());
    }
  }

  // Setups the good old metaballs demo!
  vl::Actor* setupMetaballs()
  {
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setInverseViewMatrix( vl::mat4::translation(0,0,25) );

    sceneManager()->tree()->actors()->clear();
    sceneManager()->tree()->addActor( mTextActor.get() );

    vl::ref<vlVolume::Volume> volume = new vlVolume::Volume;
    mMarchingCubes.reset();
    mMarchingCubes.volumeInfo()->push_back( new vlVolume::VolumeInfo( volume.get(), 400.0f) );
    mMarchingCubes.volumeInfo()->at(0)->volume()->setup( NULL, vl::fvec3(-10,-10,-10), vl::fvec3(+10,+10,+10), vl::ivec3(mMetaballsResolution,mMetaballsResolution,mMetaballsResolution) );

    vl::ref<vl::Geometry > geom = new vl::Geometry;
    geom->setVertexArray(mMarchingCubes.mVertsArray.get());
    geom->setNormalArray(mMarchingCubes.mNormsArray.get());
    geom->primitives()->push_back(mMarchingCubes.mDrawElements.get());
    // disable VBO since we update the vertices every frame
    geom->setVBOEnabled(false);

    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->setRenderState( new vl::Light(0) );
    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    // two side lighting
    fx->shader()->gocLightModel()->setTwoSide(true);

    vl::ref<vl::Image> texture = vl::loadImage("/images/spheremap.png");
    fx->shader()->gocTextureUnit(0)->setTexture( new vl::Texture( texture.get() ) );
    fx->shader()->gocTexGen(0)->setGenModeS(vl::TGM_SPHERE_MAP);
    fx->shader()->gocTexGen(0)->setGenModeT(vl::TGM_SPHERE_MAP);
    fx->shader()->gocTexEnv(0)->setMode(vl::TEM_BLEND);

    vl::ref<vl::Actor> act = sceneManager()->tree()->addActor(geom.get(), fx.get(), mTransform.get());

    return act.get();
  }

  // Setups the metaballs fountain demo!
  vl::Actor* setupFountain()
  {
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setInverseViewMatrix( vl::mat4::translation(0,0,25) );

    sceneManager()->tree()->actors()->clear();
    sceneManager()->tree()->addActor( mTextActor.get() );

    vl::ref<vlVolume::Volume> volume = new vlVolume::Volume;
    mMarchingCubes.reset();
    mMarchingCubes.volumeInfo()->push_back( new vlVolume::VolumeInfo( volume.get(), 400.0f) );
    mMarchingCubes.volumeInfo()->at(0)->volume()->setup( NULL, vl::fvec3(-10,-10,-10), vl::fvec3(+10,+10,+10), vl::ivec3(mMetaballsResolution,mMetaballsResolution,mMetaballsResolution) );

    vl::ref<vl::Geometry > geom = new vl::Geometry;
    geom->setBoundingBox( vl::AABB( vl::vec3(-10,-10,1-10), vl::vec3(10,10,10) ) );
    geom->setBoundingSphere( geom->boundingBox() );
    geom->setVertexArray(mMarchingCubes.mVertsArray.get());
    geom->setNormalArray(mMarchingCubes.mNormsArray.get());
    geom->primitives()->push_back(mMarchingCubes.mDrawElements.get());
    // disable VBO since we update the vertices every frame
    geom->setVBOEnabled(false);

    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->setRenderState( new vl::Light(0) );
    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    // two side lighting
    fx->shader()->gocLightModel()->setTwoSide(true);
    fx->shader()->gocMaterial()->setDiffuse(vlut::royalblue);

    vl::ref<vl::Actor> act = sceneManager()->tree()->addActor(geom.get(), fx.get(), mTransform.get());

    for(unsigned iball=0; iball<mMetaball.size(); ++iball)
    {
      mMetaball[iball].y() = 0;
      mMetaball[iball].x() = 0.5f;
      mMetaball[iball].z() = 0.5f;
      mMetaballVelocity[iball].x() = (float)vl::randomMinMax(-15,+15);
      mMetaballVelocity[iball].z() = (float)vl::randomMinMax(-15,+15);
      mMetaballVelocity[iball].y() = 100;
      mMetaballVelocity[iball].normalize();
      mMetaballVelocity[iball] *= (5.0f + (float)vl::randomMinMax(0,20))*0.05f*mFountainSpeed;
    }

    mTransform->setLocalMatrix(vl::mat4());

    mTimer.start();
    return act.get();
  }

  class my_func: public vlVolume::VolumePlot::Function
  {
  public:
    virtual float operator()(float x, float y, float z) const
    {
      // return sqrt(x*x+y*y+z*z); == 0.9f
      // return exp(-y)*sin(z)+cos(z*x); // == 2.0f
      return -x/5.0f*sin(z/5.0f)+exp(y*y*y/5.0f/5.0f/5.0f); // == 0.900f
    }
  };

  // Shows how to use vlVolume::VolumePlot to create a 3D plot.
  void setup3Dplot()
  {
    // reset actors and camera
    sceneManager()->tree()->actors()->clear();
    sceneManager()->tree()->addActor( mTextActor.get() );
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setInverseViewMatrix( vl::mat4::lookAt( vl::vec3(5,10,20), vl::vec3(0,0,0), vl::vec3(0,1,0)) );

    float range = 5.0f;
    vl::fvec3 min_corner(-range,-range,-range);
    vl::fvec3 max_corner(+range,+range,+range);

    vlVolume::VolumePlot plot;
    plot.setMinCorner(min_corner);
    plot.setMaxCorner(max_corner);
    plot.compute( my_func(), 0.900f );
    sceneManager()->tree()->addChild(plot.actorTreeMulti());
  }

  void loadVolume(vl::ref<vl::Image> vol_img)
  {
    // reset camera
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setInverseViewMatrix( vl::mat4::translation(0,0,20) );

    // reset actors
    sceneManager()->tree()->actors()->clear();
    sceneManager()->tree()->addActor( mTextActor.get() );

    // convert the image to a one-component float volume
    vol_img = vol_img->convertFormat(vl::IF_LUMINANCE)->convertType(vl::IT_FLOAT);

    vl::ref<vlVolume::Volume> volume = new vlVolume::Volume;
    volume->setup( (float*)vol_img->pixels(), vl::fvec3(-5,-5,-5), vl::fvec3(+5,+5,+5), vl::ivec3(vol_img->width(), vol_img->height(), vol_img->depth()) );

    // start timing
    vl::Time time;

    #if 0
      // downsample volume data and perform timing.
      time.start();
      volume = volume->downsample();
      vl::Log::print( vl::Say("Downsampling time = %.2n\n") << time.elapsed() );
    #endif

    mMarchingCubes.reset();
    mMarchingCubes.volumeInfo()->push_back( new vlVolume::VolumeInfo(volume.get(), mThreshold) );

    // run MarchingCubes with timing.
    time.start();
    mMarchingCubes.run(false);
    vl::Log::print( vl::Say("Marching cubes: time = %.2n, tris = %n, verts = %n\n") << time.elapsed() << mMarchingCubes.mDrawElements->triangleCount() << mMarchingCubes.mVertsArray->size() );

    // setup isosurface geometry, actor and effect

    // geometry
    vl::ref<vl::Geometry> isosurf_geom = new vl::Geometry;
    // disable VBO since we update the vertices every frame
    isosurf_geom->setVBOEnabled(false);
    // install vertex and normal arrays and primitives generated by the marching cube algorithm
    isosurf_geom->setVertexArray(mMarchingCubes.mVertsArray.get());
    isosurf_geom->setNormalArray(mMarchingCubes.mNormsArray.get());
    isosurf_geom->primitives()->push_back(mMarchingCubes.mDrawElements.get());

    #if 0
      time.start();
      vl::PolygonSimplifier ps;
      ps.simplify( 0.1f, isosurf_geom.get() );
      isosurf_geom->computeNormals();
      vl::Log::print( vl::Say("Simplification: time = %.2n\n") << time.elapsed() );
    #endif

    // actor
    vl::ref<vl::Actor> actor = new vl::Actor(isosurf_geom.get(), new vl::Effect);

    // effect
    actor->effect()->shader()->setRenderState( new vl::Light(0) );
    actor->effect()->shader()->enable(vl::EN_DEPTH_TEST);
    actor->effect()->shader()->enable(vl::EN_LIGHTING);
    actor->effect()->shader()->gocLightModel()->setTwoSide(true);
    actor->effect()->shader()->gocMaterial()->setBackDiffuse(vlut::green);

    // add actor to the scene
    sceneManager()->tree()->addActor( actor.get() );

    updateText();
  }

  void setupTest()
  {
    sceneManager()->tree()->eraseAllChildren();
    if (mTest == 1)
      showVolumes(true);
    else
    if (mTest == 2)
      textureVolumeColor( showVolumes(false) );
    else
    if (mTest == 3)
      vertexVolumeColor( showVolumes(false) );
    else
    if (mTest == 4)
      setupMetaballs();
    else
    if (mTest == 5)
      setupFountain();
    else
    if (mTest == 6)
      setup3Dplot();

    updateText();
  }

  void updateText()
  {
    vl::String str;
    if(mTest == 0)
      str = vl::Say("Marching Cubes Test #0 - Volume Viewer - threshold = %.2n\n(drop a .dat file)") << mThreshold;
    else
    if(mTest == 1)
      str = "Marching Cubes Test #1 - Multiple Volumes & Transparency";
    else
    if(mTest == 2)
      str = "Marching Cubes Test #2 - Texture Colorized Volumes";
    else
    if(mTest == 3)
      str = "Marching Cubes Test #3 - Vertex Colorized Volumes";
    else
    if(mTest == 4)
      str = "Marching Cubes Test #4 - Metaballs";
    else
    if(mTest == 5)
      str = "Marching Cubes Test #5 - Fountain";
    else
    if(mTest == 6)
      str = "Marching Cubes Test #6 - 3D Function Plotting";

    str += "\n(press the <- or -> key to change test)";
    mText->setText( str );
    mText->setDisplayListDirty(true);
  }

  void mouseWheelEvent(int w)
  {
    if (mTest != 0)
      return;

    if (w>0)
      mThreshold += 0.010f;
    else
      mThreshold -= 0.010f;

    mThreshold = vl::clamp(mThreshold, 0.0f, 1.0f);

    vl::Time time; time.start();
    mMarchingCubes.volumeInfo()->at(0)->setThreshold(mThreshold);
    mMarchingCubes.run(false);

    vl::Log::print( vl::Say("Marching cubes: time = %.2n, tris = %n, verts = %n\n") << time.elapsed() << mMarchingCubes.mDrawElements->triangleCount() << mMarchingCubes.mVertsArray->size() );

    updateText();

    openglContext()->update();
  }

  void fileDroppedEvent(const std::vector<vl::String>& files)
  {
    mTest = 0;

    if(files.size() == 1)
    {
      if (files[0].endsWith(".dat"))
      {
        vl::ref<vl::Image> vol_img = vl::loadImage(files[0]);
        loadVolume(vol_img);
      }
    }
    else
    {
      std::vector<vl::String> files_sorted = files;
      std::sort(files_sorted.begin(), files_sorted.end());
      std::vector< vl::ref<vl::Image> > images;
      for(unsigned int i=0; i<files_sorted.size(); ++i)
        images.push_back(vl::loadImage(files_sorted[i])->convertFormat(vl::IF_LUMINANCE)->convertType(vl::IT_UNSIGNED_BYTE));
      vl::ref<vl::Image> vol_img = vl::assemble3DImage(images);
      if (vol_img)
        loadVolume(vol_img);
    }
  }

  void resizeEvent(int w, int h)
  {
    BaseDemo::resizeEvent(w,h);
    mText->setDisplayListDirty(true);
  }

  virtual void shutdown() {}

protected:
  vl::ref<vl::ResourceDatabase> mResDB;
  vl::ref<vl::Transform> mTransform;
  vl::ref< vl::Text > mText;
  vl::ref< vl::Actor > mTextActor;

  // volume
  vlVolume::MarchingCubes mMarchingCubes;
  float mThreshold;
  std::vector<vl::fvec3> mMetaball;
  std::vector<vl::fvec3> mMetaballVelocity;
  vl::Time mTimer;
  std::vector< std::vector<vl::fvec3> > mMetaballsFrames;
  static const int mMetaballsResolution = 32;
  static const int mParticleCount = 25;
  static const int mFrameCount    = 20;
  float mFountainSpeed;
  vl::ref<vl::Image> mVolumeImage;
  vl::ref<vl::Image> mColorImage;
  int mTest;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Volume Rendering with Transfer Functions and Lighting Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Volume Rendering with Transfer Functions and Lighting Tutorial

This tutorial demonstrates how to use how to render volume data, how to apply custom transfer functions and lighting.

[From App_VolumeRendering.hpp]

class App_VolumeRendering: public BaseDemo
{
public:
  virtual void initEvent()
  {
    BaseDemo::initEvent();

    // general test setup
    mUseGLSL      = GLEW_ARB_shading_language_100 != 0;
    mDynamicLight = false; // for GLSL mode only

    // transform and trackball steup
    mVolumeTr = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mVolumeTr.get() );
    trackball()->setTransform( mVolumeTr.get() );

    // volume
    vl::AABB volume_box( vl::vec3(-10,-10,-10), vl::vec3(+10,+10,+10) );
    mSlicedVolume = new vlVolume::SlicedVolume;
    mSlicedVolume->setTransform(mVolumeTr.get());
    mSlicedVolume->setBox(volume_box);
    mSlicedVolume->setRenderRank(1);
    sceneManager()->tree()->addActor( mSlicedVolume.get() );

    // volume_box outline
    vl::ref<vl::Effect> fx_box = new vl::Effect;
    fx_box->shader()->gocPolygonMode()->set(vl::PM_LINE, vl::PM_LINE);
    fx_box->shader()->enable(vl::EN_DEPTH_TEST);
    vl::ref<vl::Geometry> box_outline = vlut::makeBox(volume_box);
    box_outline->setColorArray(vlut::red);
    sceneManager()->tree()->addActor( box_outline.get(), fx_box.get(), mVolumeTr.get() );

    // light bulb

    if (mDynamicLight)
    {
      mLight = mSlicedVolume->light();
      mLightTr = new vl::Transform;
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mLightTr.get() );
      mLight->followTransform( mLightTr.get() );

      vl::ref<vl::Effect> fx_bulb = new vl::Effect;
      fx_bulb->shader()->enable(vl::EN_DEPTH_TEST);
      vl::ref<vl::Geometry> light_bulb = vlut::makeIcosphere(vl::vec3(0,0,0),1,1);
      sceneManager()->tree()->addActor( light_bulb.get(), fx_bulb.get(), mLightTr.get() );
    }

    // bias text
    mBiasText = new vl::Text;
    mBiasText->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 12) );
    mBiasText->setAlignment( vl::AlignHCenter | vl::AlignBottom);
    mBiasText->setViewportAlignment( vl::AlignHCenter | vl::AlignBottom );
    mBiasText->translate(0,5,0);
    mBiasText->setBackgroundEnabled(true);
    mBiasText->setBackgroundColor(vl::fvec4(0,0,0,0.75));
    mBiasText->setColor(vlut::white);
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_BLEND);
    sceneManager()->tree()->addActor(mBiasText.get(), effect.get());

    // bias uniform
    mAlphaBias = mSlicedVolume->glslProgram()->getUniform("val_threshold");

    // update alpha bias text
    mouseWheelEvent(0);

    setVolume( vl::loadImage("/volume/VLTest.dat") );
  }

  void fileDroppedEvent(const std::vector<vl::String>& files)
  {
    if(files.size() == 1) // if there is one file load it directly
    {
      if (files[0].endsWith(".dat"))
      {
        vl::ref<vl::Image> vol_img = vl::loadImage(files[0]);
        if (vol_img)
          setVolume(vol_img);
      }
    }
    else // if there is more than one file load all the files and assemble a 3D image
    {
      // sort files by their name
      std::vector<vl::String> files_sorted = files;
      std::sort(files_sorted.begin(), files_sorted.end());
      // load the files
      std::vector< vl::ref<vl::Image> > images;
      for(unsigned int i=0; i<files_sorted.size(); ++i)
        images.push_back( vl::loadImage(files_sorted[i]) );
      // assemble the volume
      vl::ref<vl::Image> vol_img = vl::assemble3DImage(images);
      // set the volume
      if (vol_img)
        setVolume(vol_img);
    }
  }

  void setVolume(vl::ref<vl::Image> img)
  {
    if(img->format() == vl::IF_LUMINANCE)
    {
      if (mUseGLSL) // use GLSL
      {
        vl::Log::info("IF_LUMINANCE image and GLSL supported: lighting and the transfer function will be computed in realtime.\n");
        vl::ref<vl::Image> trfunc = vl::Image::makeColorSpectrum(128, vlut::black, vlut::blue, vlut::green, vlut::yellow, vlut::red);
        // enables GLSL usage
        mSlicedVolume->setTransferFunction(trfunc.get());
        mSlicedVolume->setVolumeImage(img.get());
        mSlicedVolume->effect()->shader()->disable(vl::EN_ALPHA_TEST);
      }
      else // precompute transfer function and illumination
      {
        vl::Log::info("IF_LUMINANCE image and GLSL not supported: transfer function and lighting will be precomputed.\n");
        vl::ref<vl::Image> trfunc = vl::Image::makeColorSpectrum(128, vlut::black, vlut::blue, vlut::green, vlut::yellow, vlut::red);
        vl::ref<vl::Image> volume = vlVolume::SlicedVolume::genRGBAVolume(img.get(), trfunc.get(), vl::fvec3(1.0f,1.0f,0.0f));
        // disable GLSL usage
        mSlicedVolume->setTransferFunction(NULL);
        mSlicedVolume->setVolumeImage(volume.get());
        mSlicedVolume->effect()->shader()->enable(vl::EN_ALPHA_TEST);
        mSlicedVolume->effect()->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, 0.3f);
      }
    }
    else
    {
      vl::Log::info("Non IF_LUMINANCE image: not using GLSL.\n");
      // disable GLSL usage
      mSlicedVolume->setTransferFunction(NULL);
      mSlicedVolume->setVolumeImage( img.get() );
      mSlicedVolume->effect()->shader()->enable(vl::EN_ALPHA_TEST);
      mSlicedVolume->effect()->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, 0.3f);
    }

    mAlphaBias->setUniform(0.3f);
    updateText();
    openglContext()->update();
  }

  void updateText()
  {
    float bias = 0.0f;
    mAlphaBias->getUniform(&bias);
    mBiasText->setText(vl::Say("Bias = %n") << bias);
  }

  void mouseWheelEvent(int val)
  {
    float alpha = 0.0f;
    mAlphaBias->getUniform(&alpha);
    alpha += val * 0.01f;
    alpha =  vl::clamp(alpha, 0.0f, 1.0f);
    mAlphaBias->setUniform(alpha);

    // used for non GLSL mode volumes
    mSlicedVolume->effect()->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, alpha);

    updateText();
    openglContext()->update();
  }

  virtual void run()
  {
    if (mDynamicLight)
    {
      vl::mat4 mat = vl::mat4::rotation( vl::Time::currentTime()*45, 0,0,1 ) * vl::mat4::translation(20,0,0);
      mLightTr->setLocalMatrix(mat);
    }
  }

  protected:
    vl::ref<vl::Transform> mVolumeTr;
    vl::ref<vl::Transform> mLightTr;
    vl::ref<vl::Uniform> mAlphaBias;
    vl::ref<vl::Text> mBiasText;
    vl::ref<vl::Light> mLight;
    bool mDynamicLight;
    bool mUseGLSL;
    vl::ref<vlVolume::SlicedVolume> mSlicedVolume;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Directional, Point and Spot Lights Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Directional, Point and Spot Lights Tutorial

This tutorial demonstrates how to use the following light types: directional lights, point lights, spot lights, how to animate the position and direction of a light and how to attach a light to a camera.

[From App_Lights.hpp]

class App_Lights: public BaseDemo
{
public:
  virtual void shutdown() {}

  virtual void initEvent()
  {
    BaseDemo::initEvent();

    mCameraLightType = Disable;

    // setup our simple scene with a plane and a few columns

    mLightFx = new vl::Effect;
    mLightFx->shader()->enable(vl::EN_LIGHTING); /* IMPORTANT! */
    mLightFx->shader()->enable(vl::EN_DEPTH_TEST);

    vl::ref<vl::Geometry> ground = vlut::makeGrid( vl::vec3(0,0,0), 20, 20, 100,100 );
    ground->computeNormals();
    sceneManager()->tree()->addActor(ground.get(), mLightFx.get());

    for(int i=0; i<9; ++i)
    {
      vl::ref<vl::Geometry> pillar = vlut::makeCylinder( vl::vec3(6,2,-4*1.1f + i*1.1f), 1, 4, 100, 100, true, false);
      pillar->computeNormals();
      sceneManager()->tree()->addActor(pillar.get(), mLightFx.get());
    }

    for(int i=0; i<5; ++i)
    {
      vl::ref<vl::Geometry> pillar = vlut::makeCylinder( vl::vec3(-3,2,-2*1.1f + i*1.1f), 1, 4, 100, 100, true, false);
      pillar->computeNormals();
      sceneManager()->tree()->addActor(pillar.get(), mLightFx.get());
    }

    // light setup

    // A typical OpenGL implementation supports up to 8 lights at the same time. It means that your scene can have
    // as many lights as you want but each object can be lit "only" by 8 lights at a time, this is usually never the
    // case as lighting absorbs considerable computational resources.

    // In our example each object will be lit up to 5 lights at the same time.

    mLight0 = new vl::Light(0);
    mLight1 = new vl::Light(1);
    mLight2 = new vl::Light(2);
    mLight3 = new vl::Light(3);
    mLight4 = new vl::Light(4);

    // Add the lights to the shader in order to use them (we save light #4 for the camera)
    mLightFx->shader()->setRenderState( mLight0.get() );
    mLightFx->shader()->setRenderState( mLight1.get() );
    mLightFx->shader()->setRenderState( mLight2.get() );
    mLightFx->shader()->setRenderState( mLight3.get() );

    // Define the light diffuse color.
    // See the OpenGL Programmer's Guide for more details about the OpenGL lighting model and equations.
    mLight0->setDiffuse(vlut::red);
    mLight1->setDiffuse(vlut::green);
    mLight2->setDiffuse(vlut::blue);
    mLight3->setDiffuse(vlut::white);
    mLight4->setDiffuse(vlut::white);

    // Setup lights #0, #1 and #2 as positional lights with constant, linear and quadratic attenuation.
    // Again, see the OpenGL Programmer's Guide for more details about the OpenGL lighting model and equations.
    mLight0->setPosition(vl::fvec4(0,0,0,1)); /* default */
    mLight0->setConstantAttenuation(1.0f);
    mLight0->setLinearAttenuation(0.0f);
    mLight0->setQuadraticAttenuation(0.0f);

    mLight1->setPosition(vl::fvec4(0,0,0,1)); /* default */
    mLight1->setConstantAttenuation(0.0f);
    mLight1->setLinearAttenuation(1.0f);
    mLight1->setQuadraticAttenuation(0.0f);

    mLight2->setPosition(vl::fvec4(0,0,0,1)); /* default */
    mLight2->setConstantAttenuation(0.0f);
    mLight2->setLinearAttenuation(0.0f);
    mLight2->setQuadraticAttenuation(1.0f);

    // Setup light #3 as a spot light.
    // Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot lighting.
    mLight3->setSpotCutoff(45.0f);
    mLight3->setSpotExponent(5.0f);
    mLight3->setSpotDirection(vl::fvec3(1,0,0));
    // A spot light is essentially a special positional light so these apply to spot lights as well.
    mLight3->setConstantAttenuation(1.0f);
    mLight3->setLinearAttenuation(0.0f);
    mLight3->setQuadraticAttenuation(0.0f);

    // Setup light's Transform to animate them
    mLight0_Transform = new vl::Transform;
    mLight1_Transform = new vl::Transform;
    mLight2_Transform = new vl::Transform;
    mLight3_Transform = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mLight0_Transform.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mLight1_Transform.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mLight2_Transform.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mLight3_Transform.get());
    // light 0..3 follow the relative transform
    mLight0->followTransform(mLight0_Transform.get());
    mLight1->followTransform(mLight1_Transform.get());
    mLight2->followTransform(mLight2_Transform.get());
    mLight3->followTransform(mLight3_Transform.get());
    // light 4 follows the camera
    mLight4->followTransform(NULL);

    // add a white sphere for each light to have a better visual feedback of the light animation.
    vl::ref<vl::Geometry> bulb = vlut::makeUVSphere(vl::vec3(0,0,0), 0.5f);
    vl::ref<vl::Effect> bulb_fx = new vl::Effect;
    bulb_fx->shader()->enable(vl::EN_DEPTH_TEST);
    sceneManager()->tree()->addActor(bulb.get(), bulb_fx.get(), mLight0_Transform.get());
    sceneManager()->tree()->addActor(bulb.get(), bulb_fx.get(), mLight1_Transform.get());
    sceneManager()->tree()->addActor(bulb.get(), bulb_fx.get(), mLight2_Transform.get());
    sceneManager()->tree()->addActor(bulb.get(), bulb_fx.get(), mLight3_Transform.get());

    // Simple text to inform the user of the currently active light setup.
    vl::ref<vl::Effect> text_fx = new vl::Effect;
    text_fx->shader()->enable(vl::EN_BLEND);
    mText = new vl::Text;
    mText->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 8) );
    mText->setAlignment( vl::AlignHCenter | vl::AlignTop );
    mText->setViewportAlignment( vl::AlignHCenter | vl::AlignTop );
    mText->translate(0,-10,0);
    sceneManager()->tree()->addActor(mText.get(), text_fx.get());
    updateText();
  }

  void updateText()
  {
    switch(mCameraLightType)
    {
      case Disable:          mText->setText("Camera light: Disable");           break;
      case DirectionalLight: mText->setText("Camera light: Directional Light"); break;
      case PositionalLight:  mText->setText("Camera light: Positional Light");  break;
      case SpotLight:        mText->setText("Camera light: Spot Light");        break;
    }
  }

  // Pressing space we cycle around 4 different light setup for light #4 (the one following the camera)
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch, key);
    if (key == vl::Key_Space)
    {
      mCameraLightType = (ECameraLightType)((mCameraLightType+1)%4);

      switch(mCameraLightType)
      {
      case Disable:
        // removes light #4 from the Shader
        mLightFx->shader()->eraseRenderState(mLight4.get());
        // you can also do:
        // mLightFx->shader()->removeRenderState(vl::RS_Light4);
        // or even
        // mLightFx->shader()->removeRenderState(vl::Light(4).type());
        break;
      case DirectionalLight:
        // add the light to the shader
        mLightFx->shader()->setRenderState(mLight4.get());
        // since the fourth component is 0 OpenGL considers this a direction
        mLight4->setPosition(vl::fvec4(0,0,1,0));
        // disable spot light
        mLight4->setSpotCutoff(180.0f);
        break;
      case PositionalLight:
        // add the light to the shader (just for clarity)
        mLightFx->shader()->setRenderState(mLight4.get());
        // since the fourth component is 1 OpenGL considers this a position
        mLight4->setPosition(vl::fvec4(0,0,0,1));
        // positional light attenuation
        mLight4->setConstantAttenuation(1.0f);
        mLight4->setLinearAttenuation(0.0f);
        mLight4->setQuadraticAttenuation(0.0f);
        // disable spot light
        mLight4->setSpotCutoff(180.0f);
        break;
      case SpotLight:
        // add the light to the shader (just for clarity)
        mLightFx->shader()->setRenderState(mLight4.get());
        // since the fourth component is 1 OpenGL considers this a position
        mLight4->setPosition(vl::fvec4(0,0,0,1));
        // positional light attenuation
        mLight4->setConstantAttenuation(1.0f);
        mLight4->setLinearAttenuation(0.0f);
        mLight4->setQuadraticAttenuation(0.0f);
        // enable and setup spot light
        mLight4->setSpotCutoff(25.0f);
        mLight4->setSpotExponent(40.0f);
        mLight4->setSpotDirection(vl::fvec3(0,0,-1));
        break;
      }
    }
    updateText();
  }

  // Animate the lights
  virtual void run()
  {
    vl::Real phase = 120.0f;
    vl::mat4 m;

    m.translate(5,1,0);
    m.rotate( phase*0.0f + 1.0f*vl::Time::currentTime()*vl::fPi*15, 0, 1.0f, 0);
    mLight0_Transform->setLocalMatrix(m);

    m.setIdentity();
    m.translate(5,1,0);
    m.rotate( phase*1.0f + 1.3f*vl::Time::currentTime()*vl::fPi*15, 0, 1.0f, 0);
    mLight1_Transform->setLocalMatrix(m);

    m.setIdentity();
    m.translate(5,1,0);
    m.rotate( phase*2.0f + 1.7f*vl::Time::currentTime()*vl::fPi*15, 0, 1.0f, 0);
    mLight2_Transform->setLocalMatrix(m);

    m.setIdentity();
    m.translate( sin(vl::Time::currentTime()*vl::fPi),0.5f,0);
    m.rotate( 0.5f*vl::Time::currentTime()*vl::fPi*15, 0, 1.0f, 0);
    mLight3_Transform->setLocalMatrix(m);
  }

protected:
  vl::ref< vl::Light > mLight0;
  vl::ref< vl::Light > mLight1;
  vl::ref< vl::Light > mLight2;
  vl::ref< vl::Light > mLight3;
  vl::ref< vl::Light > mLight4;
  vl::ref< vl::Transform > mLight0_Transform;
  vl::ref< vl::Transform > mLight1_Transform;
  vl::ref< vl::Transform > mLight2_Transform;
  vl::ref< vl::Transform > mLight3_Transform;
  vl::ref< vl::Effect > mLightFx;
  vl::ref< vl::Text > mText;
  enum ECameraLightType { Disable, DirectionalLight, PositionalLight, SpotLight } mCameraLightType;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Terrains and Heightmaps Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Terrains and Heightmaps Tutorial

This tutorial demonstrates how to render a heightmap-based terrain using the Terrain scene manager.

[From App_Terrain.hpp]

class App_Terrain: public BaseDemo
{
public:
  virtual void shutdown() {}

  virtual void run() {}

  virtual void initEvent()
  {
    if (!GLEW_ARB_multitexture)
    {
      vl::Log::error("GL_ARB_multitexture required.\n");
      openglContext()->quitApplication();
      return;
    }
    BaseDemo::initEvent();

    ghostCamera()->setMovementSpeed(5);
    // allocate terrain scene manager
    vl::ref<vl::Terrain> terrain = new vl::Terrain;
    // use GLSL?
    terrain->setUseGLSL(GLEW_ARB_shading_language_100?true:false);
    // dimensions of the terrain
    terrain->setWidth(100);
    terrain->setDepth(100);
    terrain->setHeight(5.0f);
    // heightmap texture size used by the GLSL program
    if (GLEW_ATI_texture_float || GLEW_ARB_texture_float)
      terrain->setHeightmapTextureFormat(vl::TF_LUMINANCE16F);
    else
      terrain->setHeightmapTextureFormat(vl::TF_LUMINANCE);
    // origin of the terrain
    terrain->setOrigin(vl::vec3(0,0,0));
    // define textures
    terrain->setHeightmapTexture("/images/terrain-h.jpg");
    terrain->setTerrainTexture("/images/terrain-t.jpg");
    terrain->setDetailTexture("/images/noise.png");
    terrain->setDetailRepetitionCount(8);
    // define shaders to be used to render the terrain
    terrain->setFragmentShader("/glsl/terrain.fs");
    terrain->setVertexShader("/glsl/terrain.vs");
    // initialize the terrain
    terrain->init();
    // add the terrain scene manager to the rendering
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->sceneManagers()->push_back( terrain.get() );

    // adds fog if we are not using GLSL but the fixed function pipeline
    if (!terrain->useGLSL())
    {
      // set sky to white
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor(vlut::white);
      // set fog render state
      vl::ref<vl::Fog> fog = new vl::Fog;
      fog->setColor(vlut::white);
      fog->setDensity(0.045f);
      fog->setMode(vl::FM_EXP);
      // install and enable fog
      terrain->shaderNode()->setRenderState(fog.get());
      terrain->shaderNode()->setEnable(vl::EN_FOG,true);
      terrain->shaderNode()->updateHierachy();
    }

    // for debugging purposes
    #if 0
      showBoundingVolumes(1,0);
    #endif
  }
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: OpenGL-Accelerated 2D Vector Graphics Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

OpenGL-Accelerated 2D Vector Graphics Tutorial

This tutorial demonstrates how to perform all the most important vector graphics operations using the vlVG::VectorGraphics class.

[From App_VectorGraphics.hpp]

class App_VectorGraphics: public BaseDemo
{
public:
  virtual void initEvent()
  {
    BaseDemo::initEvent();

    // disable trackball and ghost camera manipulator
    trackball()->setEnabled(false);
    ghostCamera()->setEnabled(false);

    // camera setup

    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setNearFarClippingPlanesOptimized(false);
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setProjectionAsOrtho2D();
    // reset view matrix to I
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setViewMatrix( vl::mat4() );

    // load images used later as textures

    // load colorful pattern & substitute black with transparent blue
    vl::ref<vl::Image> pattern  = vl::loadImage("/images/pattern.bmp");
    pattern->substituteColorRGB_RGBA(0x000000,0x0000FFAA);
    // load transparent star
    vl::ref<vl::Image> star = vl::loadImage("/images/star.png");
    // colorize the point to green and black
    vl::ref<vl::Image> circle16_bg = vl::loadImage("/images/circle16.png");
    circle16_bg->substituteColorGreenKey(0x00FF00,0x000000);
    // colorize the point to yellow and red
    vl::ref<vl::Image> circle16_yr = vl::loadImage("/images/circle16.png");
    circle16_yr->substituteColorGreenKey(0xFFFF00,0xFF0000);
    // generate the color spectrums
    vl::ref<vl::Image> spectrum1 = vl::Image::makeColorSpectrum(128, vlut::blue,  vlut::green, vlut::yellow, vlut::red);
    vl::ref<vl::Image> spectrum2 = vl::Image::makeColorSpectrum(128, vlut::black, vlut::white, vlut::gray,   vlut::black);

    // add a new VectorGraphics to our SceneManagerVectorGraphics

    vl::ref<vlVG::VectorGraphics> vg = new vlVG::VectorGraphics;
    vl::ref<vlVG::SceneManagerVectorGraphics> vgscene = new vlVG::SceneManagerVectorGraphics;
    vgscene->vectorGraphicObjects()->push_back(vg.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->sceneManagers()->push_back(vgscene.get());

    // start drawing with our new VectorGraphics object!

    vg->startDrawing();

      // clear the viewport
      vg->clearColor(vlut::white);

      // ###### textured quad rendering ######

      vg->setImage(pattern.get());
      // this way the texels are perfectly centered on the pixels
      vg->translate(-0.5f,-0.5f);

      vg->pushMatrix();
        // textured quad #1 repeat texturing
        vg->translate(10,110);
        vg->setTextureMode(vlVG::TextureMode_Repeat);
        vg->fillQuad( 0,0 , pattern->width()*3.0f,pattern->height()*3.0f );
        // textured quad #2 stretch texturing
        vg->translate(100,0);
        vg->setTextureMode(vlVG::TextureMode_Clamp);
        vg->fillQuad( 0,0 , pattern->width()*3.0f,pattern->height()*3.0f );
        // textured quad #3 stretch texturing
        vg->translate(100,0);
        vg->setImage(spectrum2.get());
        vg->setTextureMode(vlVG::TextureMode_Clamp);
        vg->fillQuad( 0,0 , pattern->width()*3.0f,pattern->height()*3.0f );
      vg->popMatrix();

      // ###### line rendering ######

      vg->setImage(NULL);
      vg->setLineWidth(1.0f);
      vg->setColor(vlut::black);
      vg->resetMatrix();
      vg->translate(10,250);

      vg->setLineStipple(vlVG::LineStipple_Dash);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_Dash4);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_Dash8);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_DashDot);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_DashDotDot);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_Dot);
      vg->drawLine(0,0, 200,0);

      vg->translate(0,10);
      vg->setLineStipple(vlVG::LineStipple_Solid);
      vg->drawLine(0,0, 200,0);

      vg->resetMatrix();
      vg->translate(10,350);
      for(int x=0; x<=100; x+=4)
        vg->drawLine(x,0,x,100);
      for(int y=0; y<=100; y+=4)
        vg->drawLine(0,y,100,y);

      // ###### textured point rendering + scissor ######

      // with the Scissor we can clip the rendering against a specific rectangular area
      int scissor_w = 200;
      int scissor_h = 200;
      vg->setScissor(256-scissor_w/2,256+128-scissor_h/2,scissor_w,scissor_h);

      vg->setColor(vl::fvec4(1,1,1,0.5f)); // transparent white
      vg->setPoint(circle16_bg.get()); // the same as setImage(image) + setPointSize(image->width())
      vg->resetMatrix();
      vg->translate(256,256+128);
      // generate the points
      std::vector<vl::dvec2> points;
      for(int i=0; i<1000; ++i)
      {
        points.push_back(vl::dvec2(rand()%128-64,rand()%128-64));
        points[i].normalize();
        points[i] *= (rand()%1280) / 10.0f;
        // snap to integer coordinates to avoid aliasing problems
        points[i] = vl::trunc(points[i]);
      }
      // draw the points
      vg->drawPoints(points);

      vg->setPoint(circle16_yr.get()); // the same as setImage(image) + setPointSize(image->width())
      points.clear();
      for(int i=0; i<200; ++i)
      {
        points.push_back(vl::dvec2(rand()%128-64,rand()%128-64));
        points[i].normalize();
        points[i] *= (rand()%1280) / 10.0f;
        // snap to integer coordinates to avoid aliasing problems
        points[i] = vl::trunc(points[i]);
      }
      // draw the points
      vg->drawPoints(points);

      vg->removeScissor();

      // ###### rounded point rendering ######

      vg->setImage(NULL);
      vg->setPointSize(7);
      vg->setPointSmoothing(true); /* default value */
      vg->setColor(vlut::crimson);
      vg->translate(196,64);
      points.clear();
      for(int i=0; i<100; ++i)
      {
        points.push_back(vl::dvec2(rand()%128-64,rand()%128-64));
        points[i].normalize();
        points[i] *= (rand()%640) / 10.0f;
        // snap to integer coordinates to avoid aliasing problems
        points[i] = vl::trunc(points[i]);
      }
      vg->drawPoints(points);

      // ###### squared point rendering ######

      vg->setImage(NULL);
      vg->setPointSize(5);
      vg->setPointSmoothing(false);
      vg->setColor(vlut::green);
      vg->translate(0,-128);
      points.clear();
      for(int i=0; i<100; ++i)
      {
        points.push_back(vl::dvec2(rand()%128-64,rand()%128-64));
        points[i].normalize();
        points[i] *= (rand()%640) / 10.0f;
        // snap to integer coordinates to avoid aliasing problems
        points[i] = vl::trunc(points[i]);
      }
      vg->drawPoints(points);

      // ###### stencil buffer rendering ######

      // reset states
      vg->resetMatrix();
      vg->setColor(vlut::white);
      vg->setImage(NULL);

      // clear the stencil buffer
      vg->clearStencil(0);
      // enable stencil test
      vg->setStencilTestEnabled(true);
      // setup stencil test: writes 0x01 on the stencil buffer when rendering polygons, lines etc.
      vg->setStencilFunc(vl::FU_NOTEQUAL, 0x01, 0x01);
      vg->setStencilOp(vl::SO_REPLACE, vl::SO_REPLACE, vl::SO_REPLACE);

      // ###### render the rose on the stencil buffer ######

      // rose create and bind transform
      mRoseTransform = new vl::Transform;
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mRoseTransform.get());
      // draw our rotating rose as a set of 4 filled ellipses and bind them to mRoseTransform
      vg->fillEllipse(0,0 , 150,25)->setTransform(mRoseTransform.get());
      vg->pushMatrix();
      vg->rotate(45);
      vg->fillEllipse(0,0 , 150,25)->setTransform(mRoseTransform.get());
      vg->rotate(45);
      vg->fillEllipse(0,0 , 150,25)->setTransform(mRoseTransform.get());
      vg->rotate(45);
      vg->fillEllipse(0,0 , 150,25)->setTransform(mRoseTransform.get());
      vg->popMatrix();

      // ###### fill the rose with color ######

      // setup stencil test: renders only where the stencil buffer is set to 0x01
      vg->setStencilFunc(vl::FU_EQUAL, 0x01, 0x01);
      vg->setStencilOp(vl::SO_KEEP, vl::SO_KEEP, vl::SO_KEEP);

      // make sure our matrix is clean
      vg->resetMatrix();
      // render random blue ellipses
      vg->setColor(vlut::blue);
      for(int i=0; i<400; ++i)
        vg->drawEllipse(rand()%512,rand()%512 , rand()%20+10,rand()%20+10);
      // renders concentric red circles
      vg->setColor(vlut::red);
      for(int i=0; i<256/4; ++i)
        vg->drawEllipse(256,256 , i*8,i*8);

      // finish with the stencil
      vg->setStencilTestEnabled(false);

      // render text following our rotating rose
      vg->setFont("/font/bitstream-vera/Vera.ttf", 14, false);
      vg->setColor(vlut::black);
      // note that the 2D text is not transformed by mRoseTransform but just follows an idea point transformed by mRoseTransform.
      vg->drawText("Stencil buffer in action here!", vl::AlignHCenter|vl::AlignVCenter)->setTransform(mRoseTransform.get());

      // ###### draws a rotated text ######

      vg->setColor(vlut::black);
      vg->setFont("/font/bitstream-vera/VeraMono.ttf", 14, true);
      vg->pushMatrix();
      vg->rotate(45);
      vg->drawText(256, 256, "Rotated Text", vl::AlignHCenter|vl::AlignVCenter);
      vg->popMatrix();

      // ###### transparent star image ######

      vg->pushState();
        vg->setColor(vl::fvec4(1,1,1,0.75f)); // transparent white
        vg->setImage(star.get());
        vg->translate(-star->width()/2,-star->height()/2); // center the quad
        vl::Actor* rota_star = vg->fillQuad(0,0,star->width(),star->height());
        mStarTransform = new vl::Transform;
        rota_star->setTransform( mStarTransform.get() );
        vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mStarTransform.get() );
      vg->popState();

      // ###### how to instance multiple times the same object ######

      // generate 5 corner star: line loop primitive
      std::vector<vl::dvec2> star_line_loop;
      for(int i=0; i<5; ++i)
      {
        vl::dvec3 v = vl::dmat4::rotation(90.0+i*360.0/5.0*2.0 , 0,0,1) * vl::dvec3(50.0,0,0);
        // snap to integer coordinates to avoid aliasing
        v = vl::trunc(v);
        star_line_loop.push_back(v.xy());
      }

      // ###### generate 5 corner star: lines primitive ######
      std::vector<vl::dvec2> star_lines;
      for(int i=0; i<5; ++i)
      {
        vl::dvec3 v1 = vl::dmat4::rotation(90.0+i*360.0/5.0*2.0 , 0,0,1) * vl::dvec3(50.0,0,0);
        vl::dvec3 v2 = vl::dmat4::rotation(90.0+((i+1)%5)*360.0/5.0*2.0 , 0,0,1) * vl::dvec3(50.0,0,0);
        // snap to integer coordinates to avoid aliasing
        v1 = vl::trunc(v1);
        v2 = vl::trunc(v2);
        star_lines.push_back(v1.xy());
        star_lines.push_back(v2.xy());
      }

      // star1
      vg->setLineWidth(4.0f);
      vg->setColor(vlut::gold);
      vl::Actor* star1 = vg->drawLineLoop(star_line_loop);
      // star2 - recycle the geometry from star1
      vg->setLineWidth(2.0f);
      vg->setColor(vlut::red);
      vl::Actor* star2 = vg->drawActorCopy(star1);
      // star3 - recycle the geometry from star1
      vg->setLineWidth(1.0f);
      vg->setLineStipple(vlVG::LineStipple_DashDotDot);
      vl::Actor* star3 = vg->drawActorCopy(star1);
      // star4 - texturing #1
      vg->setColor(vlut::white); // make sure color is white so that the texture color is not filtered
      vg->setImage(spectrum1.get());
      vg->setLineWidth(2.0f);
      vg->setLineStipple(vlVG::LineStipple_Solid);
      // Here we call drawLineLoop() because we need to create a new geometry instance
      // so that VL can generate appropriate UV texture coordinates that are dependent
      // on the currently active Image.
      vl::Actor* star4 = vg->drawLineLoop(star_line_loop);
      // star5 - texturing #2
      // Here we draw the star using drawLines() instead or drawLineLoop().
      // Note how drawLines() and drawLineLoop() generate different texturing effects.
      vl::Actor* star5 = vg->drawLines(star_lines);

      // render the 4 instances in 4 different points
      star1->setTransform( new vl::Transform );
      star2->setTransform( new vl::Transform );
      star3->setTransform( new vl::Transform );
      star4->setTransform( new vl::Transform );
      star5->setTransform( new vl::Transform );
      star1->transform()->setLocalMatrix( vl::mat4::translation(50,50,0) );
      star2->transform()->setLocalMatrix( vl::mat4::translation(150,50,0) );
      star3->transform()->setLocalMatrix( vl::mat4::translation(250,50,0) );
      star4->transform()->setLocalMatrix( vl::mat4::translation(350,50,0) );
      star5->transform()->setLocalMatrix( vl::mat4::translation(450,50,0) );
      // Since they are not animated we can setup the matrices without binding it to the Rendering's root Transform
      star1->transform()->computeWorldMatrix();
      star2->transform()->computeWorldMatrix();
      star3->transform()->computeWorldMatrix();
      star4->transform()->computeWorldMatrix();
      star5->transform()->computeWorldMatrix();

    vg->endDrawing();
  }

  virtual void run()
  {
    vl::mat4 mat = vl::mat4::rotation(vl::Time::currentTime() * 60.0f, 0, 0, 1);
    mat = vl::mat4::translation(sin(vl::Time::currentTime()*vl::fPi*0.25f)*200.0f,0,0) * mat;
    mat = vl::mat4::rotation(vl::Time::currentTime() * 5.0f, 0, 0, 1) * mat;
    mat = vl::mat4::translation(256,256,0) * mat;
    mRoseTransform->setLocalMatrix(mat);

    mat.setIdentity();
    mat.rotate(vl::Time::currentTime()*60, 0,0,1);
    mat.translate(256,256,0);
    mat.translate(200*cos(vl::Time::currentTime()*vl::fPi*2.0f/17.0f),0,0);
    mat.translate(0,200*sin(vl::Time::currentTime()*vl::fPi*2.0f/9.0f),0);
    mStarTransform->setLocalMatrix(mat);
  }

  void resizeEvent(int w, int h)
  {
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setWidth(w);
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->viewport()->setHeight(h);
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->camera()->setProjectionAsOrtho2D();
  }

  virtual void shutdown() {}

protected:
  vl::ref<vl::Transform> mRoseTransform;
  vl::ref<vl::Transform> mStarTransform;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Clipping Planes Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Clipping Planes Tutorial

This tutorial shows how to use clipping, planes, how to animate them and how to use them with multipassing rendering.

[From App_ClipPlanes.hpp]

class App_ClipPlanes: public BaseDemo
{
public:
  void initEvent()
  {
    BaseDemo::initEvent();

    // load model
    vl::ref<vl::Geometry> model = vl::loadResource("/models/3ds/monkey.3ds")->get<vl::Geometry>(0);

    // install transform
    mClipTr = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mClipTr.get());

    // to be used later
    vl::ref<vl::Light> light = new vl::Light(0);

    // demonstrates multipassing clipping

    vl::ref<vl::Effect> clip_fx  = new vl::Effect;
    vl::ref<vl::Shader> clip1_sh = new vl::Shader;
    vl::ref<vl::Shader> clip2_sh = new vl::Shader;
    // setup clipping pass 1
    clip1_sh->setRenderState( light.get() );
    clip1_sh->enable(vl::EN_LIGHTING);
    clip1_sh->enable(vl::EN_DEPTH_TEST);
    clip1_sh->gocMaterial()->setBackDiffuse(vlut::yellow);
    clip1_sh->gocLightModel()->setTwoSide(true);
    // clipping plane 1 setup
    clip1_sh->gocClipPlane(0)->setPlane( vl::Plane(0.2f, vl::vec3(0,+1,0)) );
    clip1_sh->gocClipPlane(0)->followTransform( mClipTr.get() );
    // setup clipping pass 2
    clip2_sh->setRenderState( light.get() );
    clip2_sh->enable(vl::EN_LIGHTING);
    clip2_sh->enable(vl::EN_DEPTH_TEST);
    clip2_sh->gocMaterial()->setBackDiffuse(vlut::green);
    clip2_sh->gocLightModel()->setTwoSide(true);
    // clipping plane 2 setup
    clip2_sh->gocClipPlane(0)->setPlane( vl::Plane(0.2f, vl::vec3(0,-1,0)) );
    clip2_sh->gocClipPlane(0)->followTransform( mClipTr.get() );
    // install the two passes for LOD 0
    clip_fx->setLOD(0, clip1_sh.get(), clip2_sh.get());
    // add model to the scene
    sceneManager()->tree()->addActor( model.get(), clip_fx.get(), NULL );

    // renders a plane for visual feedback

    // setup effect
    vl::ref<vl::Effect> plane_fx = new vl::Effect;
    plane_fx->setRenderRank(1); // draw after the clipped model
    plane_fx->shader()->enable(vl::EN_DEPTH_TEST);
    plane_fx->shader()->enable(vl::EN_BLEND);
    plane_fx->shader()->gocMaterial()->setColorMaterialEnabled(true);
    plane_fx->shader()->gocLightModel()->setTwoSide(true);
    // add plane actor
    vl::ref<vl::Geometry> plane = vlut::makeGrid( vl::vec3(0,0,0), 4,4, 2,2 );
    plane->setColorArray(vl::fvec4(1,0,0,0.3f)); // transparent red
    sceneManager()->tree()->addActor( plane.get(), plane_fx.get(), mClipTr.get() );
  }

  virtual void run()
  {
    // animate the clipping planes and the rendered plane
    vl::Real t = (vl::Real)vl::Time::currentTime();
    mClipTr->setLocalMatrix( vl::mat4::rotation(t*90.0f, sin(t*(vl::fPi-3.0f)),1,cos(t)) );
  }

  virtual void shutdown() {}

protected:
  vl::ref<vl::Transform> mClipTr;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Polygon Tessellation Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Polygon Tessellation Tutorial

In this tutorial you will learn how to use the vl::Tessellator class to tessellate a concave or self intersecting polygon into a set of triangles that can be rendered with Visualization Library.

[From App_Tessellator.hpp]

class App_Tessellator: public BaseDemo
{
public:
  App_Tessellator() {}

  void initEvent()
  {
    // Basic initialization
    BaseDemo::initEvent();

    // Filled effect
    vl::ref<vl::Effect> filled_fx = new vl::Effect;

    // Wireframe effect
    vl::ref<vl::Effect> wireframe_fx = new vl::Effect;
    wireframe_fx->shader()->gocPolygonMode()->set(vl::PM_LINE,vl::PM_LINE);

    // Add empty Actors
    mStar1 = sceneManager()->tree()->addActor( new vl::Actor(NULL, filled_fx.get(), new vl::Transform) );
    mStar2 = sceneManager()->tree()->addActor( new vl::Actor(NULL, wireframe_fx.get(), new vl::Transform) );
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mStar1->transform());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mStar2->transform());
  }

  void run()
  {
    // Animation: compute rotation matrix to rotate the small star, 45°/sec rotation.
    vl::dmat4 m = vl::dmat4::rotation( vl::Time::currentTime()*45, 0,0,1 );
    // Filled star on the left, wireframe star on the right
    mStar1->transform()->setLocalMatrix( vl::mat4::translation(-4,0,0) );
    mStar2->transform()->setLocalMatrix( vl::mat4::translation(+4,0,0) );

    // Concave and self-intersecting polygons cannot be directly rendered by OpenGL, for this
    // reason in order to render them we have to tessellate them first, i.e. we have to decompose
    // them into a set of triangles using the Tessellator class.

    // The Tessellator class takes as input a set of contours defining a complex polygon and
    // outputs a series of triangles that can be rendered by OpenGL and Visualization Library
    vl::Tessellator tess;

    // Setup tessellation options, see also gluTessProperty() documentation.
    tess.setWindingRule(vl::TW_TESS_WINDING_ODD); // default
    tess.setTessNormal(vl::fvec3(0,0,1)); // default is vl::fvec3(0,0,0)
    tess.setBoundaryOnly(false); // default
    tess.setTolerance(0.0); // default

    // Outline #1 - generate 5-points star (small)
    int size = 2;
    tess.contours().push_back(5);
    for(int i=0; i<5; ++i)
    {
      float t = (float)i/5.0f*vl::fPi*2.0f*2.0f + vl::fPi/2.0f;
      // Fill the first contour
      tess.contourVerts().push_back( m * vl::dvec3(cos(t)*size,sin(t)*size,0.0f) );
    }

    // Outline #2 - generate 5-points star (big)
    size = 4;
    tess.contours().push_back(5);
    for(int i=0; i<5; ++i)
    {
      float t = (float)i/5.0f*vl::fPi*2.0f*2.0f + vl::fPi/2.0f;
      // Fill the second contour
      tess.contourVerts().push_back( vl::dvec3(cos(t)*size,sin(t)*size,0.0f) );
    }

    // Tessellate the two contours into a single polygon
    tess.setTessellateIntoSinglePolygon(true); // default
    tess.tessellate();

    /*
    You can also tessellate each contour separately selecting setTessellateIntoSinglePolygon(false).
    This way each contour will be processed separately and will generate its own set of triangles, this
    is useful when you want to tessellate a large number of polygons with a single tessellate() call.
    */

    // Create a new Geometry and vertex array with the tessellated triangles
    vl::ref<vl::Geometry> tess_poly = new vl::Geometry;
    vl::ref<vl::ArrayFVec3> vert_array = new vl::ArrayFVec3;
    tess_poly->setVertexArray(vert_array.get());
    // Fill the vertex array with the tessellated triangles
    *vert_array = tess.tessellatedTris();
    // Add the primitive description
    tess_poly->primitives()->push_back( new vl::DrawArrays(vl::PT_TRIANGLES,0,vert_array->size()) );

    // Bind the created Geometry to the star Actor
    mStar1->lod(0) = tess_poly.get();
    mStar2->lod(0) = tess_poly.get();
  }

protected:
  // the Actor defining our complex star
  vl::Actor* mStar1;
  vl::Actor* mStar2;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Extrusion Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Extrusion Tutorial

In this tutorial you will learn how to use the vl::Extrusion class to extrude a 2d silhouette along a 3d path in order to generate 3d geometries.

Remember that you can also use a vl::Interpolator to generate paths and silhouettes to be used with vl::Extrusion.

Generated by showSimplePipe() | Generated by showFancyArch() | Generated by showVortex() | Generated by showNail()

[From App_Extrusion.hpp]

class App_Extrusion: public BaseDemo
{
public:
  App_Extrusion(): mTest(0) {}

  // Creates a simple extrusion
  void showSimplePipe()
  {
    // Generates the actual extrusion
    vl::Extrusion extrusion;

    // Define the silhouette to be extruded: 24 sided circle
    const int sides = 24;
    const float radius = 1.0f;
    for(int i=0; i<sides; ++i)
    {
      float t = (float)i/sides*vl::fPi*2.0f;
      extrusion.silhouette().push_back(vl::fvec2(::cos(t)*radius, ::sin(t)*radius));
    }

    // Define the path along which the silhouette is extruded.
    // Note: the first and last control points are not part of the actual extrusion
    // but are used to define the orientation of the first and start segment.
    extrusion.positionPath().push_back(vl::fvec3(-5, 0, 0) + vl::fvec3(-1,0,0));
    extrusion.positionPath().push_back(vl::fvec3(-5, 0, 0));
    extrusion.positionPath().push_back(vl::fvec3(-5, 5, 0));
    extrusion.positionPath().push_back(vl::fvec3(+5, 5, 0));
    extrusion.positionPath().push_back(vl::fvec3(+5, 0, 0));
    extrusion.positionPath().push_back(vl::fvec3(+5, 0, 0) + vl::fvec3(+1,0,0));

    // Setup the extrusion options.
    extrusion.setSilhouetteMode(vl::SilhouetteClosed);
    extrusion.setSmooth(false);
    extrusion.setFillBottom(true); // start of the extrusion is closed
    extrusion.setFillTop(true);    // end of the extrusion is closed

    // Setup a simple white effect.
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->enable(vl::EN_DEPTH_TEST);

    // Generates the extrusion.
    vl::ref<vl::Geometry> geom = extrusion.extrude();
    sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL );

    // Utility function that visualizes the extrusion path.
    showPath(extrusion.positionPath(),vlut::red);
  }

  // Creates a fancy arch applying rotation and scaling to the extrusion
  void showFancyArch()
  {
    // Generates the actual extrusion
    vl::Extrusion extrusion;

    // Define the silhouette to be extruded (a quad).
    const int sides = 4;
    const float radius = 1.0f;
    for(int i=0; i<sides; ++i)
    {
      float t = (float)i/sides*vl::fPi*2.0f;
      extrusion.silhouette().push_back(vl::fvec2(::cos(t)*radius, ::sin(t)*radius));
    }

    // Define the path along which the silhouette is extruded.
    // Note: the first and last control points are not part of the actual extrusion
    // but are used to define the orientation of the first and start segment.
    extrusion.positionPath().push_back(vl::fvec3(-5, 0, 0) + vl::fvec3(0,-1,0));
    extrusion.positionPath().push_back(vl::fvec3(-5, 0, 0));
    for(int j=0; j<640; ++j)
    {
      float t = (float)j/(640-1)*vl::fPi;
      extrusion.positionPath().push_back(vl::fvec3(-cos(t)*5, sin(t)*5, 0) + vl::fvec3(0,5,0));
    }
    extrusion.positionPath().push_back(vl::fvec3(+5, 0, 0));
    extrusion.positionPath().push_back(vl::fvec3(+5, 0, 0) + vl::fvec3(0,-1,0));

    // Defines a rotation key (in degrees) for each segment generated in order
    // to rotate the silhouette along the extrusion path.
    // Note that the segments generated are extrusion.positionPath().size()-2 as
    // the first and last control points are not part of the actual extrusion
    // but are used to define the orientation of the first and start segment.
    for(unsigned i=0; i<extrusion.positionPath().size()-2; ++i)
    {
      float t = (float)i/(extrusion.positionPath().size()-2-1);
      // rotate of 360*2 degrees (turns around twice)
      extrusion.rotationPath().push_back(t*360.0f*2.0f);
    }

    // Defines a scaling key (in degrees) for each segment generated in order
    // to rotate the silhouette along the extrusion path.
    // Note that the segments generated are extrusion.positionPath().size()-2 as
    // the first and last control points are not part of the actual extrusion
    // but are used to define the orientation of the first and start segment.
    for(unsigned i=0; i<extrusion.positionPath().size()-2; ++i)
    {
      float t = (float)i/(extrusion.positionPath().size()-2-1);
      // make it smaller in the middle
      float s = 1.0f - ::sin( t*vl::fPi )*0.8f;
      extrusion.scalingPath().push_back(s);
    }

    // Setup the extrusion options.
    extrusion.setSilhouetteMode(vl::SilhouetteClosed);
    extrusion.setSmooth(false);
    extrusion.setFillBottom(false); // start of the extrusion is closed
    extrusion.setFillTop(false);    // end of the extrusion is closed

    // Setup a simple white effect.
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->enable(vl::EN_DEPTH_TEST);

    // Generates the extrusion.
    vl::ref<vl::Geometry> geom = extrusion.extrude();
    sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL );

    // Utility function that visualizes the extrusion path.
    showPath(extrusion.positionPath(),vlut::red);
  }

  // Creates a vortex whose section is a flower.
  void showVortex()
  {
    vl::Extrusion extrusion;

    // Generate flower-like silhouette.
    const int lati = 128;
    for(int i=0; i<lati; ++i)
    {
      float t = (float)i/lati*vl::fPi*2.0f+3.14159365f/2.0f;
      extrusion.silhouette().push_back(vl::fvec2(::cos(t)*0.4f, ::sin(t)*0.4f));
      extrusion.silhouette().back() *= 2.0f + fabs(sin(t*8.0f)*2.0f-1.0f)*0.1f;
    }

    // Generate fancy vortex path.
    float freq   = 5.0f;
    float width  = 10.0f;
    const int size = 250;
    extrusion.positionPath().resize( size );
    for(int i=0; i<size; ++i)
    {
      float t = (float)i/(size-1);
      extrusion.positionPath()[i].y() = (t - 0.5f)*width;
      float a = t * vl::fPi*2.0f*freq - vl::fPi/4.0f ;
      float s = ::sin( t*vl::fPi/2.0f );
      s = 5.0f*s + 0.5f*(1.0f-s);
      extrusion.positionPath()[i].x() = ::sin(a)*s;
      extrusion.positionPath()[i].z() = ::cos(a)*s;
    }

    // Generate color path: linearly interpolate from blue to yellow.
    for(int i=0; i<size-2; ++i)
    {
      float t = (float)i/(size-2-1);
      vl::fvec4 c = vlut::yellow*t + vlut::blue*(1.0f-t);
      extrusion.colorPath().push_back(c);
    }

    // Scaling factor along the vortex: starts small, ends big.
    for(unsigned i=0; i<extrusion.positionPath().size()-2; ++i)
    {
      float t = (float)i/(extrusion.positionPath().size()-2-1);
      float s = ::sin( t*vl::fPi/2.0f )*0.8f;
      extrusion.scalingPath().push_back(s);
    }

    // Extrusion options.
    extrusion.setSilhouetteMode(vl::SilhouetteClosed);
    extrusion.setSmooth(false);
    extrusion.setFillBottom(true);
    extrusion.setFillTop(true);

    // Simple white effect.
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    // Enable color material to visualize the generated vertex colors.
    effect->shader()->gocMaterial()->setColorMaterialEnabled(true);

    // Generates the actual extrusion.
    vl::ref<vl::Geometry> extr = extrusion.extrude();
    sceneManager()->tree()->addActor( extr.get(), effect.get(), NULL );
  }

  // Creates a vortex whose section is a flower.
  void showNail()
  {
    vl::Extrusion extrusion;

    // Defines the silhouette as a cross.
    float diam = 1.0f;
    extrusion.silhouette().push_back(vl::fvec2(-diam*3.0f,-diam));
    extrusion.silhouette().push_back(vl::fvec2(-diam,-diam));
    extrusion.silhouette().push_back(vl::fvec2(-diam,-diam*3.0f));
    extrusion.silhouette().push_back(vl::fvec2(+diam,-diam*3.0f));
    extrusion.silhouette().push_back(vl::fvec2(+diam,-diam));
    extrusion.silhouette().push_back(vl::fvec2(+diam*3.0f,-diam));
    extrusion.silhouette().push_back(vl::fvec2(+diam*3.0f,+diam));
    extrusion.silhouette().push_back(vl::fvec2(+diam,+diam));
    extrusion.silhouette().push_back(vl::fvec2(+diam,+diam*3.0f));
    extrusion.silhouette().push_back(vl::fvec2(-diam,+diam*3.0f));
    extrusion.silhouette().push_back(vl::fvec2(-diam,+diam));
    extrusion.silhouette().push_back(vl::fvec2(-diam*3.0f,+diam));

    // Extrusion path.
    int segments = 500;
    for(int i=0; i<segments; ++i)
    {
      float t = (float)i/(segments-1);
      extrusion.positionPath().push_back( vl::fvec3( 0, t*20.0f-10.0f, 0) );
    }

    // Extrusion color.
    for(int i=0; i<segments-2; ++i)
    {
      float t = (float)i/(segments-2-1);
      vl::fvec4 c = vlut::gold * t + vlut::royalblue*(1.0f-t);
      extrusion.colorPath().push_back(c);
    }

    // Extrusion color.
    for(int i=0; i<segments-2; ++i)
    {
      float t = (float)i/(segments-2-1);
      extrusion.scalingPath().push_back( t );
    }

    // Extrusion rotaion.
    for(int i=0; i<segments-2; ++i)
    {
      float t = (float)i/(segments-2-1);
      extrusion.rotationPath().push_back(360*t);
    }

    // Extrusion options.
    extrusion.setSilhouetteMode(vl::SilhouetteClosed);
    extrusion.setSmooth(false);
    extrusion.setFillBottom(true);
    extrusion.setFillTop(true);

    // Simple effect
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    // Enable color material in order to see the generated vertex colors.
    effect->shader()->gocMaterial()->setColorMaterialEnabled(true);

    // Generates the actual extrusion.
    vl::ref<vl::Geometry> geom = extrusion.extrude();
    sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL );
  }

  // Utility function to display a path
  void showPath(const std::vector<vl::fvec3>& ctrl_points, const vl::fvec4& color)
  {
    // generate line geometry with lines and points
    vl::ref<vl::Geometry>   geom       = new vl::Geometry;
    vl::ref<vl::ArrayFVec3> vert_array = new vl::ArrayFVec3;
    geom->setVertexArray( vert_array.get() );
    *vert_array = ctrl_points;
    geom->setColorArray(color);
    geom->primitives()->push_back(new vl::DrawArrays(vl::PT_LINE_STRIP, 0, vert_array->size())); // lines
    geom->primitives()->push_back(new vl::DrawArrays(vl::PT_POINTS,     0, vert_array->size())); // points

    // setup simple effect
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_LINE_STIPPLE);
    effect->shader()->gocPointSize()->set(3);
    effect->shader()->gocLineStipple()->setPattern(0x3333);
    effect->setRenderRank(1); // always draw over the pipe

    sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL );
  }

  // Press the left/right arrow buttons to navigate through the examples.
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch,key);

    if (key == vl::Key_Left || key == vl::Key_Right)
    {
      if (key == vl::Key_Left)
        mTest--;
      if (key == vl::Key_Right)
        mTest++;
      if (mTest < 0) mTest = 3;
      if (mTest > 3) mTest = 0;
      sceneManager()->tree()->actors()->clear();
      switch(mTest)
      {
        case 0: showSimplePipe(); break;
        case 1: showFancyArch(); break;
        case 2: showVortex(); break;
        case 3: showNail(); break;
      }
      showText();
    }
  }

  // displays the text
  void showText()
  {
    vl::ref<vl::Text> text = new vl::Text;
    text->setText("Press the left/right arrow keys to change test.");
    text->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10) );
    text->setAlignment( vl::AlignHCenter | vl::AlignTop );
    text->setViewportAlignment( vl::AlignHCenter | vl::AlignTop );
    text->translate(0,-5,0);
    text->setColor(vlut::white);
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_BLEND);
    sceneManager()->tree()->addActor(text.get(), effect.get());
  }

  void initEvent()
  {
    BaseDemo::initEvent();
    showSimplePipe();
    showText();
  }

protected:
  int mTest;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Interpolators Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Interpolators Tutorial

In this tutorial you will learn how to use the various interpolator classes to generate splines and smooth aniamtions.

You can also use an interpolator to generate paths and silhouettes for the vl::Extrusion class.

Generated by showCatmullRomPentagonOpen() | Generated by showCatmullRomPentagonClosed() | Generated by showLinearPentagon() | Generated by showInterpolatorAnimation()

[From App_Interpolators.hpp]

class App_Interpolators: public BaseDemo
{
public:
  // Constructor.
  App_Interpolators()
  {
    mTest = 0;
    mLinearInterpolator     = new vl::LinearInterpolatorFVec3;
    mCatmullRomInterpolator = new vl::CatmullRomInterpolatorFVec3;
    mTransform1 = new vl::Transform; // will follow linear interpolation
    mTransform2 = new vl::Transform; // will follow Catmull-Rom interpolation
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform1.get());
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(mTransform2.get());
  }

  void showCatmullRomPentagonOpen()
  {
    // generate the pentagon control points
    std::vector<vl::fvec3> pentagon;
    float radius = 5.0f;
    for(int i=0; i<5; ++i)
    {
      float a = (float)i/5.0f*vl::fPi*2.0f + vl::fPi/2.0f;
      pentagon.push_back(vl::fvec3(cos(a)*radius,sin(a)*radius,0));
    }
    // show the pentagon
    showPath(pentagon, vlut::green);

    // Catmull-Rom interpolation over the pentagon control points
    std::vector<vl::fvec3> pentagon_spline;
    vl::CatmullRomInterpolatorFVec3 catmull;
    catmull.interpolator()->setPath( pentagon );
    // automatically generate the appropriate Catmull-Rom spline end-points
    catmull.interpolator()->setupEndPoints(false/*loop = no*/);
    // sample the spline over 41 points
    int segments = 41;
    for(int i=0; i<segments; ++i)
    {
      float t = (float)i/(segments-1); // interpolate from 0.0 to 1.0 included
      pentagon_spline.push_back( catmull.computePoint(t) );
    }
    // show the interpolated pentagon
    showPath(pentagon_spline, vlut::red, true/*show points*/);
  }

  void showCatmullRomPentagonLoop()
  {
    // generate the pentagon
    std::vector<vl::fvec3> pentagon;
    float radius = 5.0f;
    for(int i=0; i<5; ++i)
    {
      float a = (float)i/5.0f*vl::fPi*2.0f + vl::fPi/2.0f;
      pentagon.push_back(vl::fvec3(cos(a)*radius,sin(a)*radius,0));
    }
    showPath(pentagon, vlut::green);

    // Catmull-Rom interpolation over the pentagon
    vl::CatmullRomInterpolatorFVec3 catmull;
    catmull.interpolator()->setPath( pentagon );
    std::vector<vl::fvec3> pentagon_loop;
    // automatically generate the appropriate Catmull-Rom spline end-points
    catmull.interpolator()->setupEndPoints(true/*loop = yes*/);
    int segments = 50;
    for(int i=0; i<segments; ++i)
    {
      // interpolate from 0 to 0.9x, never reach 1.0 otherwise the last point would be the same as the first one
      float t = (float)i/segments;
      pentagon_loop.push_back( catmull.computePoint(t) );
    }
    showPath(pentagon_loop, vlut::yellow, true/*show points*/, true/*close line loop*/);
  }

  void showLinearPentagon()
  {
    // generate the pentagon
    std::vector<vl::fvec3> pentagon;
    float radius = 5.0f;
    for(int i=0; i<5; ++i)
    {
      float a = (float)i/5.0f*vl::fPi*2.0f + vl::fPi/2.0f;
      pentagon.push_back(vl::fvec3(cos(a)*radius,sin(a)*radius,0));
    }
    showPath(pentagon, vlut::green);

    // linear interpolation over the pentagon
    vl::LinearInterpolatorFVec3 linear;
    linear.interpolator()->setPath( pentagon );
    std::vector<vl::fvec3> pentagon_linear;
    int segments = 20; /* 21 would perfectly overlap the pentagon */
    for(int i=0; i<segments; ++i)
    {
      // interpolate from 0 to 1.0
      float t = (float)i/(segments-1);
      pentagon_linear.push_back( linear.computePoint(t) );
    }
    vl::Actor* line = showPath(pentagon_linear, vlut::blue, true/*show points*/);
    // ensure the blue line is over the green one.
    line->setRenderRank(1);
  }

  // creates two paths one linearly-interpolated and the other Catmull-Rom-interpolated
  void showInterpolatorAnimation()
  {
    // generate a 5-points star.
    std::vector<vl::fvec3> pentagon;
    float radius = 5.0f;
    for(int i=0; i<5; ++i)
    {
      float a = (float)i/5.0f*vl::fPi*2.0f*2.0f + vl::fPi/2.0f;
      pentagon.push_back(vl::fvec3(cos(a)*radius,sin(a)*radius,0));
    }

    // Catmull-Rom interpolation over the star
    mCatmullRomInterpolator->interpolator()->setPath( pentagon );
    // generate line for visual feedback.
    std::vector<vl::fvec3> pentagon_loop;
    // automatically generate the appropriate Catmull-Rom spline end-points
    mCatmullRomInterpolator->interpolator()->setupEndPoints(true/*loop = yes*/);
    int segments = 50;
    for(int i=0; i<segments; ++i)
    {
      // interpolate from 0 to 0.9x, never reach 1.0 otherwise the last point would be the same as the first one
      float t = (float)i/segments;
      pentagon_loop.push_back( mCatmullRomInterpolator->computePoint(t)*1.2f /*1.2f -> makes it a bit larger*/ );
    }
    showPath(pentagon_loop, vlut::yellow, true/*show points*/, true/*close line loop*/);

    // linear interpolation over the star (loop)
    mLinearInterpolator->interpolator()->setPath( pentagon );
    // close the pentagon
    mLinearInterpolator->interpolator()->path().push_back(pentagon[0]);
    // generate line for visual feedback.
    std::vector<vl::fvec3> pentagon_linear;
    segments = 20;
    for(int i=0; i<segments; ++i)
    {
      // interpolate from 0 to 0.9x, never reach 1.0 otherwise the last point would be the same as the first one
      float t = (float)i/segments;
      pentagon_linear.push_back( mLinearInterpolator->computePoint(t) );
    }
    showPath(pentagon_linear, vlut::blue, true/*show points*/, true/*close line loop*/);

    // display animated arrows
    vl::ref<vl::Geometry> arrow = vlut::makePyramid(vl::vec3(0,0,0),0.5f,1.0f);
    arrow->transform( vl::mat4::rotation(-90.0f,1,0,0) );
    arrow->computeNormals();
    vl::ref<vl::Effect> arrow_fx = new vl::Effect;
    arrow_fx->shader()->enable(vl::EN_DEPTH_TEST);
    arrow_fx->shader()->enable(vl::EN_LIGHTING);
    arrow_fx->shader()->setRenderState(new vl::Light(0));
    sceneManager()->tree()->addActor( arrow.get(), arrow_fx.get(), mTransform1.get() );
    sceneManager()->tree()->addActor( arrow.get(), arrow_fx.get(), mTransform2.get() );
  }

  // displays a closed or open path, with or without points
  vl::Actor* showPath(const std::vector<vl::fvec3>& ctrl_points, const vl::fvec4& color, bool points=false, bool loop=false)
  {
    // simple effect
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    effect->shader()->gocPointSize()->set(4);

    // generates the line/points geometry
    vl::ref<vl::Geometry>   geom       = new vl::Geometry;
    vl::ref<vl::ArrayFVec3> vert_array = new vl::ArrayFVec3;
    geom->setVertexArray( vert_array.get() );
    *vert_array = ctrl_points;
    geom->setColorArray(color);
    geom->primitives()->push_back(new vl::DrawArrays(loop ? vl::PT_LINE_LOOP : vl::PT_LINE_STRIP, 0, vert_array->size()));
    if (points)
      geom->primitives()->push_back(new vl::DrawArrays(vl::PT_POINTS, 0, vert_array->size()));

    // adds the geometry to the scene
    return sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL );
  }

  // Animates the arrows along the path.
  void run()
  {
    if (mTest == 3)
    {
      float delta = 1.0f/50.0f;
      vl::fvec3 up(0,0,1);
      // get the fractional part of the time to loop 0..1
      float eye  = vl::fract((float)vl::Time::currentTime() * 0.1f);
      float look = vl::fract(eye+delta); // we have to remain in the range 0..1
      vl::fmat4 m;
      // linear interpolation
      m = vl::fmat4::lookAt(mLinearInterpolator->computePoint(eye),mLinearInterpolator->computePoint(look),up);
      mTransform1->setLocalMatrix((vl::mat4)m);
      // Catmull-Rom interpolation
      m = vl::fmat4::lookAt(mCatmullRomInterpolator->computePoint(eye)*1.2f,mCatmullRomInterpolator->computePoint(look)*1.2f,up);
      mTransform2->setLocalMatrix((vl::mat4)m);
    }
  }

  // Press the left/right arrow buttons to navigate through the examples.
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch,key);

    if (key == vl::Key_Left || key == vl::Key_Right)
    {
      if (key == vl::Key_Left)
        mTest--;
      if (key == vl::Key_Right)
        mTest++;
      if (mTest < 0) mTest = 3;
      if (mTest > 3) mTest = 0;
      sceneManager()->tree()->actors()->clear();
      switch(mTest)
      {
        case 0: showCatmullRomPentagonOpen(); break;
        case 1: showCatmullRomPentagonLoop(); break;
        case 2: showLinearPentagon(); break;
        case 3: showInterpolatorAnimation(); break;
      }
      showText();
    }
  }

  // displays the text
  void showText()
  {
    vl::ref<vl::Text> text = new vl::Text;
    text->setText("Press the left/right arrow keys to change test.");
    text->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10) );
    text->setAlignment( vl::AlignHCenter | vl::AlignTop );
    text->setViewportAlignment( vl::AlignHCenter | vl::AlignTop );
    text->translate(0,-5,0);
    text->setColor(vlut::white);
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_BLEND);
    sceneManager()->tree()->addActor(text.get(), effect.get());
  }

  void initEvent()
  {
    BaseDemo::initEvent();
    showCatmullRomPentagonOpen();
    showText();
  }

protected:
  int mTest;
  vl::ref<vl::LinearInterpolatorFVec3>     mLinearInterpolator;
  vl::ref<vl::CatmullRomInterpolatorFVec3> mCatmullRomInterpolator;
  vl::ref<vl::Transform> mTransform1;
  vl::ref<vl::Transform> mTransform2;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Molecule Visualization Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Molecule Visualization Tutorial

This tutorial demonstrates how to use the vlMolecule module classes to manipulate and render molecules and chemical structures.

The vlMolecule module is a simple and minimalistic framework to manipulate and render chemical structures. The vlMolecule::Molecule class is the most important member of the module and represents a molecular structure as a collection of vlMolecule::Atom[s] and vlMolecule::Bond[s]. The vlMolecule::Molecule class allows you to add and remove both atoms and bonds in order to create any kind of molecule. The vlMolecule framework is flexible and intuitive, it allows you for example to set the color, the size, the visibility etc. for each atom and for each bond, it allows you to define the geometrical detail for bonds and atoms, it allows you highlight aromatic rings and much more.

The vlMolecule module also provide a comprehensive atom database, in fact using the vlMolecule::atomInfo() function the user can retrieve information like element name, element symbol, atom number, electronegativity, cpk color, various radii etc. for a given atom type (vlMolecule::EAtomType).

Using the vlMolecule::loadMOL2() function you can also load a MOL2 (or multi-MOL2) file.

The example below implements a simple molecule viewer.

Wireframe style | Sticks style | Ball & Sticks style | CPK space fill style

[From App_Molecules.hpp]

class App_Molecules: public BaseDemo
{
public:
  App_Molecules(): mCurrentMolecule(0), mCurrentStyle(0), mText( new vl::Text ) {}

  void updateMolecule()
  {
    if (mCurrentStyle == 0) // wireframe
    {
      // activate "wireframe" style
      mMolecules[mCurrentMolecule]->setMoleculeStyle(vlMolecule::MS_Wireframe);
      // colorize the atoms by their CPK color
      mMolecules[mCurrentMolecule]->setCPKAtomColors();
      // define the line width
      mMolecules[mCurrentMolecule]->setLineWidth(2.0f);
      // activate line anti-aliasing
      mMolecules[mCurrentMolecule]->setSmoothLines(true);
    }
    else
    if (mCurrentStyle == 1) // ball & stick
    {
      // activate "ball & stick" style
      mMolecules[mCurrentMolecule]->setMoleculeStyle(vlMolecule::MS_BallAndStick);
      // colorize the atoms by their CPK color
      mMolecules[mCurrentMolecule]->setCPKAtomColors();
      // set all the atom radii to 0.30A
      mMolecules[mCurrentMolecule]->setAtomRadii(0.30f);
      // set all the bond radii to 0.15A
      mMolecules[mCurrentMolecule]->setBondRadii(0.15f);
    }
    else
    if (mCurrentStyle == 2) // sticks
    {
      // activate "sticks" style
      mMolecules[mCurrentMolecule]->setMoleculeStyle(vlMolecule::MS_Sticks);
      // colorize the atoms by their CPK color
      mMolecules[mCurrentMolecule]->setCPKAtomColors();
      // set all the bond radii to 0.10A
      mMolecules[mCurrentMolecule]->setBondRadii(0.10f);
    }
    else
    if (mCurrentStyle == 3) // cpk space fill
    {
      // activates "atoms only" style
      mMolecules[mCurrentMolecule]->setMoleculeStyle(vlMolecule::MS_AtomsOnly);
      // colorize the atoms by their CPK color
      mMolecules[mCurrentMolecule]->setCPKAtomColors();
      // set all the atom radii to their van der Waals radii value as returned by atomInfo().
      mMolecules[mCurrentMolecule]->setVanDerWaalsAtomRadii();
    }

    /*

    SETUP TO RENDER THE ATOM LABELS:

    ... choose the style: font, color, alignment etc.
    mMolecules[mCurrentMolecule]->atomLabelTemplate()->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10) );
    mMolecules[mCurrentMolecule]->atomLabelTemplate()->setColor(vlut::white);
    mMolecules[mCurrentMolecule]->atomLabelTemplate()->setOutlineColor(vlut::black);
    mMolecules[mCurrentMolecule]->atomLabelTemplate()->setOutlineEnabled(true);
    mMolecules[mCurrentMolecule]->atomLabelTemplate()->setAlignment(vl::AlignHCenter|vl::AlignVCenter);

    ... enable the atom label rendering at the molecule level
    mMolecules[mCurrentMolecule]->setShowAtomNames(true);

    ... enable the atom label rendering at the atom level
    mMolecules[mCurrentMolecule]->atom(4)->setShowAtomName(true);

    OTHER COMMON OPERATIONS:

    ... aromatic ring settings
    mMolecules[mCurrentMolecule]->setAromaticRingColor(vlut::red);
    mMolecules[mCurrentMolecule]->setAromaticBondsColor(vlut::gold);

    ... geometrical detail for bonds and atoms
    mMolecules[mCurrentMolecule]->setBondDetail(50);
    mMolecules[mCurrentMolecule]->setAtomDetail(3);

    ... toggle visibility by atom type
    mMolecules[mCurrentMolecule]->setAtomTypeVisible(vlMolecule::AT_Hydrogen, false);

    ... define per-atom color
    mMolecules[mCurrentMolecule]->atom(4)->setColor(vlut::fuchsia);

    ... define per-atom and per-bond visibility
    mMolecules[mCurrentMolecule]->atom(5)->setVisible(false);
    mMolecules[mCurrentMolecule]->bond(6)->setVisible(false);
    */

    /* generates the actual geometry to be rendered, the result of this function will be in
       mMolecules[mCurrentMolecule]->actorTree() and mMolecules[mCurrentMolecule]->transformTree() */
    mMolecules[mCurrentMolecule]->prepareForRendering();

    /* remove any previously installed child node */
    sceneManager()->tree()->eraseAllChildren();
    /* add the node containing the molecule's Actors to the scene */
    sceneManager()->tree()->addChild( mMolecules[mCurrentMolecule]->actorTree() );
    /* updates the text on top of the window with the current molecule name and style */
    updateText();
  }

  /* initialization */
  void initEvent()
  {
    BaseDemo::initEvent();

    /* initialize the text actor */
    mText->setText("Drop a MOL2 file inside the window.");
    mText->setFont( vl::VisualizationLibrary::fontManager()->acquireFont("/font/bitstream-vera/VeraMono.ttf", 10) );
    mText->setAlignment( vl::AlignHCenter | vl::AlignTop );
    mText->setViewportAlignment( vl::AlignHCenter | vl::AlignTop );
    mText->setTextAlignment(vl::TextAlignCenter);
    mText->translate(0,-5,0);
    mText->setColor(vlut::white);
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->enable(vl::EN_BLEND);
    sceneManager()->tree()->addActor(mText.get(), effect.get());
  }

  /* loads a MOL2 file when it is dropped in the window */
  void fileDroppedEvent(const std::vector<vl::String>& files)
  {
    mCurrentMolecule = 0;
    /*loads only the first .mol2 file if more are dropped*/
    vlMolecule::loadMOL2( files[0], mMolecules );
    if (!mMolecules.empty())
      updateMolecule();

    /* adjust the camera position to nicely see the scene, it also position the rotation pivot to the center of the molecule */
    trackball()->adjustView( vl::VisualizationLibrary::rendering()->as<vl::Rendering>(), vl::vec3(0,0,1), vl::vec3(0,1,0), 1.0f );
  }

  /* user controls to change the molecule (if we loaded a multi-MOL2 file) and the style */
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch,key);
    if (key == vl::Key_Up || key == vl::Key_Down || key == vl::Key_Left || key == vl::Key_Right)
    {
      if (key == vl::Key_Up  )  mCurrentStyle++;
      if (key == vl::Key_Down)  mCurrentStyle--;
      if (key == vl::Key_Left)  mCurrentMolecule--;
      if (key == vl::Key_Right) mCurrentMolecule++;
      if (mCurrentMolecule<0)                   mCurrentMolecule = mMolecules.size()-1;
      if (mCurrentMolecule>(int)mMolecules.size()-1) mCurrentMolecule = 0;
      if (mCurrentStyle<0) mCurrentStyle = 3;
      if (mCurrentStyle>3) mCurrentStyle = 0;
      updateMolecule();
    }
  }

  /* updates the text on top of the window with the current molecule name and style */
  void updateText()
  {
    vl::String msg = mMolecules[mCurrentMolecule]->moleculeName().c_str();
    msg += vl::Say(" (%n/%n)") << mCurrentMolecule+1 << mMolecules.size();
    if (mCurrentStyle == 0)
      msg += " - Wireframe";
    if (mCurrentStyle == 1)
      msg += " - Ball & Stick";
    if (mCurrentStyle == 2)
      msg += " - Sticks";
    if (mCurrentStyle == 3)
      msg += " - CPK";

    msg += "\nuse the arrow keys to change molecule and style";
    mText->setText(msg);
  }

protected:
  std::vector< vl::ref<vlMolecule::Molecule> > mMolecules;
  int mCurrentMolecule;
  int mCurrentStyle;
  vl::ref<vl::Text> mText;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Edge Enhancement and Wireframe Rendering Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Edge Enhancement and Wireframe Rendering Tutorial

This tutorial demonstrates how to improve the perception of the objects in a scene and how to perform hidden line removal wireframe rendering using the edge extraction and enhnacement capabilities of Visualization Library.

Edge Rendering Off | Silhouettes | Silhouettes + Creases | Silhouettes + Creases + Hidden Lines
Cartoonish models with silhouette enhancement
Hidden line removal wireframe

In this tutorial we will implement a simple application capable of loading models by drag&drop and applying edge enhancement and hidden line removal wireframe rendering to the whole scene. The user will also be able to interactively switch on and off various edge rendering features:

Key | Mode
'1' | edge rendering off
'2' | edge rendering on: silhouette only
'3' | edge rendering on: silhouette + creases
'4' | edge rendering on: silhouette + creases + hidden lines
'5' | hidden line removal wireframe: silhouette + creases
'6' | hidden line removal wireframe: silhouette + creases + hidden lines

The edges are always extracted from the triangles or quads that are part of a vl::Geometry and can be of three types: silhouette edges, crease edges and boundary edges.

  • Silhouette edges are those edges that are shared by a backfacing and front facing quad or triangle.

  • Crease edges are those edges that are shared by two triangles or quads and that form an angle >= creaseAngle(), ie: 0 means that the two triangles or quads are coplanar; the edges of a cube define 90 degrees angles; the lateral edges of a 10 faces cylinder define 36 (360/10) degrees angles and so on.

  • Boundary edges are those edges that belong to a single triangle or quad.

For more information see also vl::EdgeExtractor and vl::EdgeRenderer.

[From App_EdgeRendering.hpp]

class App_EdgeRendering: public BaseDemo
{
public:
  void setupScene()
  {
    // setup common states
    vl::ref<vl::Light> camera_light = new vl::Light(0);
    vl::ref<vl::EnableSet> enables = new vl::EnableSet;
    enables->enable(vl::EN_DEPTH_TEST);
    enables->enable(vl::EN_LIGHTING);

    // red material fx
    vl::ref<vl::Effect> red_fx = new vl::Effect;
    red_fx->shader()->setEnableSet(enables.get());
    red_fx->shader()->gocMaterial()->setDiffuse(vlut::red);
    red_fx->shader()->setRenderState(camera_light.get());

    // green material fx
    vl::ref<vl::Effect> green_fx = new vl::Effect;
    green_fx->shader()->setEnableSet(enables.get());
    green_fx->shader()->gocMaterial()->setDiffuse(vlut::green);
    green_fx->shader()->setRenderState(camera_light.get());

    // blue material fx
    vl::ref<vl::Effect> yellow_fx = new vl::Effect;
    yellow_fx->shader()->setEnableSet(enables.get());
    yellow_fx->shader()->gocMaterial()->setDiffuse(vlut::yellow);
    yellow_fx->shader()->setRenderState(camera_light.get());

    // add box, cylinder, cone actors to the scene
    vl::ref<vl::Geometry> geom1 = vlut::makeBox     (vl::vec3(-7,0,0),5,5,5);
    vl::ref<vl::Geometry> geom2 = vlut::makeCylinder(vl::vec3(0,0,0), 5,5, 10,2, true, true);
    vl::ref<vl::Geometry> geom3 = vlut::makeCone    (vl::vec3(+7,0,0),5,5, 20, true);

    // needed since we enabled the lighting
    geom1->computeNormals();
    geom2->computeNormals();
    geom3->computeNormals();

    // add the actors to the scene
    mSceneManager->tree()->addActor( geom1.get(), red_fx.get(),    mSolidRendering->transform() );
    mSceneManager->tree()->addActor( geom2.get(), green_fx.get(),  mSolidRendering->transform() );
    mSceneManager->tree()->addActor( geom3.get(), yellow_fx.get(), mSolidRendering->transform() );
  }

  void initEvent()
  {
    BaseDemo::initEvent();

    // initialize our renderings to use the camera, the scene-manager, rendering target etc. from the default renderingTree()
    mSolidRendering = new vl::Rendering;
    *mSolidRendering = *(vl::VisualizationLibrary::rendering()->as<vl::Rendering>());
    mEdgeRendering  = new vl::Rendering;
    *mEdgeRendering  = *(vl::VisualizationLibrary::rendering()->as<vl::Rendering>());

    /*
    Outline of our rendering tree:

                renderingTree() <- empty rendering
                  /   \
                 /     \
    mSolidRendering   mEdgeRendering  <- first calls the solid rendering, then calls the edge rendering
    */

    // install the new rendering tree
    vl::ref<vl::RenderingTree> render_tree = new vl::RenderingTree;
    vl::VisualizationLibrary::setRendering(render_tree.get());
    render_tree->subRenderings()->push_back(mSolidRendering.get());
    render_tree->subRenderings()->push_back(mEdgeRendering.get());

    // bind the scene manager containing the actors to be rendered to both the solid and the edge rendering
    mSceneManager = new vl::SceneManagerActorTree;
    mSolidRendering->sceneManagers()->push_back(mSceneManager.get());
    mEdgeRendering ->sceneManagers()->push_back(mSceneManager.get());

    // bind an vl::EdgeRenderer to the mEdgeRendering in order to perform automatic edge extraction and rendering.
    // we set the clear flags to be vl::CF_CLEAR_DEPTH (by default is set to CF_CLEAR_COLOR_DEPTH) because when the
    // wireframe rendering starts we want to preserve the color-buffer as generated by the solid rendering but we
    // want to clear the Z-buffer as it is needed by the hidden-line-removal algorithm implemented by vl::EdgeRenderer.
    mEdgeRenderer = new vl::EdgeRenderer;
    mEdgeRendering->setRenderer( mEdgeRenderer.get() );
    mEdgeRendering->setClearFlags(vl::CF_CLEAR_DEPTH);

    // hidden line and crease options
    mEdgeRenderer->setShowHiddenLines(true);
    mEdgeRenderer->setShowCreases(true);
    mEdgeRenderer->setCreaseAngle(35.0f);

    // style options
    mEdgeRenderer->setLineWidth(2.0f);
    mEdgeRenderer->setSmoothLines(true);
    mEdgeRenderer->setDefaultLineColor(vlut::black);

    // fills mSceneManager with a few actors.
    // the beauty of this system is that you setup your actors ony once in a single scene managers and
    // they will be rendered twice, first using a normal renderer and then using the wireframe renderer.
    setupScene();
  }

  // user controls:
  // '1' = edge rendering off.
  // '2' = edge rendering on: silhouette only.
  // '3' = edge rendering on: silhouette + creases.
  // '4' = edge rendering on: silhouette + creases + hidden lines.
  // '5' = hidden line removal wireframe: silhouette + creases.
  // '6' = hidden line removal wireframe: silhouette + creases + hidden lines.
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch, key);

    if (ch == '1')
    {
      mSolidRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRendering->setEnableMask(0);
      vl::Log::print("Edge rendering disabled.\n");
    }
    else
    if (ch == '2')
    {
      mSolidRendering->setEnableMask(0xFFFFFFFF);
      // preserve color buffer, clear depth buffer
      mEdgeRendering->setClearFlags(vl::CF_CLEAR_DEPTH);
      mEdgeRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRenderer->setShowCreases(false);
      mEdgeRenderer->setShowHiddenLines(false);
      vl::Log::print("Edge rendering enabled. Creases = off, hidden lines = off.\n");
    }
    else
    if (ch == '3')
    {
      mSolidRendering->setEnableMask(0xFFFFFFFF);
      // preserve color buffer, clear depth buffer
      mEdgeRendering->setClearFlags(vl::CF_CLEAR_DEPTH);
      mEdgeRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRenderer->setShowCreases(true);
      mEdgeRenderer->setShowHiddenLines(false);
      vl::Log::print("Edge rendering enabled. Creases = on, hidden lines = off.\n");
    }
    else
    if (ch == '4')
    {
      mSolidRendering->setEnableMask(0xFFFFFFFF);
      // preserve color buffer, clear depth buffer
      mEdgeRendering->setClearFlags(vl::CF_CLEAR_DEPTH);
      mEdgeRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRenderer->setShowCreases(true);
      mEdgeRenderer->setShowHiddenLines(true);
      vl::Log::print("Edge rendering enabled. Creases = on, hidden lines = on.\n");
    }
    else
    if (ch == '5')
    {
      mSolidRendering->setEnableMask(0);
      // clear color and depth buffer
      mEdgeRendering->setClearFlags(vl::CF_CLEAR_COLOR_DEPTH);
      mEdgeRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRenderer->setShowCreases(true);
      mEdgeRenderer->setShowHiddenLines(false);
      vl::Log::print("Hidden line removal wireframe enabled. Creases = on, hidden lines = off.\n");
    }
    if (ch == '6')
    {
      mSolidRendering->setEnableMask(0);
      // clear color and depth buffer
      mEdgeRendering->setClearFlags(vl::CF_CLEAR_COLOR_DEPTH);
      mEdgeRendering->setEnableMask(0xFFFFFFFF);
      mEdgeRenderer->setShowCreases(true);
      mEdgeRenderer->setShowHiddenLines(true);
      vl::Log::print("Hidden line removal wireframe enabled. Creases = on, hidden lines = on.\n");
    }
  }

  void resizeEvent(int /*w*/, int /*h*/)
  {
    // solid rendering: update viewport and projection matrix
    mSolidRendering->camera()->viewport()->setWidth(mSolidRendering->renderTarget()->width());
    mSolidRendering->camera()->viewport()->setHeight(mSolidRendering->renderTarget()->height());
    mSolidRendering->camera()->setProjectionAsPerspective();

    // edge rendering: update viewport and projection matrix
    mEdgeRendering->camera()->viewport()->setWidth(mEdgeRendering->renderTarget()->width());
    mEdgeRendering->camera()->viewport()->setHeight(mEdgeRendering->renderTarget()->height());
    mEdgeRendering->camera()->setProjectionAsPerspective();
  }

  void loadModel(const std::vector<vl::String>& files)
  {
    // resets the scene
    mSceneManager->tree()->actors()->clear();
    // resets the EdgeRenderer cache
    mEdgeRenderer->clearCache();

    for(unsigned int i=0; i<files.size(); ++i)
    {
      vl::ref<vl::ResourceDatabase> resource_db = vl::loadResource(files[i],true);

      if (!resource_db || resource_db->count<vl::Actor>() == 0)
      {
        vl::Log::error("No data found.\n");
        continue;
      }

      std::vector< vl::ref<vl::Actor> > actors;
      resource_db->get<vl::Actor>(actors);
      for(unsigned i=0; i<actors.size(); ++i)
      {
        vl::ref<vl::Actor> actor = actors[i].get();
        // define a reasonable Shader
        actor->effect()->shader()->setRenderState( new vl::Light(0) );
        actor->effect()->shader()->enable(vl::EN_DEPTH_TEST);
        actor->effect()->shader()->enable(vl::EN_LIGHTING);
        actor->effect()->shader()->gocLightModel()->setTwoSide(true);
        // add the actor to the scene
        mSceneManager->tree()->addActor( actor.get() );
      }
    }

    // position the camera to nicely see the objects in the scene
    trackball()->adjustView( mSceneManager.get(), vl::vec3(0,0,1)/*direction*/, vl::vec3(0,1,0)/*up*/, 1.0f/*bias*/ );
  }

  // laod the files dropped in the window
  void fileDroppedEvent(const std::vector<vl::String>& files) { loadModel(files); }

protected:
  vl::ref< vl::EdgeRenderer > mEdgeRenderer;
  vl::ref<vl::Rendering> mSolidRendering;
  vl::ref<vl::Rendering> mEdgeRendering;
  vl::ref<vl::SceneManagerActorTree> mSceneManager;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Portal-Based Culling and Scene Management Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Portal-Based Culling and Scene Management Tutorial

This tutorial shows how to use the powerful vl::SceneManagerPortals class to render indoor or highly occluded scenes order of magnitudes more quickly than simply using frustum culling methods (even if using KdTrees or other accelation structures).

There are cases in which you want to render indoor or highly occluded but very complex scenes. Using frustum culling in this cases is not enough because the objects that remain in the view frustum are still too many. In such situations the solution is to avoid drawing the objects that are occluded by other objects. The vl::SceneManagerPortals class allows you to do so using the so called portal-based hidden surface removal algorithm. The basic concept is very simple, in a typical indoor environment most of the objects are hidden by the walls, the furniture etc. and the content of each room is visible either because the camera is in that room or through a door or window. We will call the rooms Sectors and the doors and windows Portals. If a door is not in our view frustum then also the room behind that door is not visible (unless we can see it through another door or window). Similarly, when a sector is visible the algorithm looks for all the Portals in that sector and checks if the Sectors behind those Portals are visible as well. This process is recursive and the algorithm might end up (but is definitely something you want to avoid!) traversing the whole scene going from sector to sector but usually only a small subset is traversed. When a new sector is discovered the Actors that contains are checked against not only the view frustum but also against the view frustum passing through the portals. This mechanism ensures a much higher probability of culling the Actors in the scene than using plain frustum culling, and the best part is that this is done traversing only a minimal part of the whole data set.

Using the vl::SceneManagerPortals class is extremely simple once you have defined your Portals, Sectors and the Actors that are in each sector. The challenging aspect is defining a good set of Portals and Sectors. This can be relatively simple for highly occluded environments or very difficult for complex or more open scenes. Furthermore the process of defining appropriate Portals and Sectors is very difficult to automate and usually requires human intervention. For example many FPS and even racing games use it. In this case the level editors and artists create appropriate portals in the right places and define by hand the Sectors. Portal and sector automatic generation is possible, for example it has been implemented already in the well-known game Quake I from Id Software, but usually severe limitations apply to the kinds of geometry that can be used and special tools are required.

On the other hand portal-based hidden surface removal not only can be tremendously efficient for the right kind of scenarios but it does not require any special OpenGL extension and thus works the same on any hardware and OpenGL implementation (unlike the various OpenGL extensions to perform occlusion queries like GL_ARB_occlusion_query which suffer other kinds of limitations).

Note that the vl::SceneManagerPortals can be used in combination or side by side with other scene managers and demonstrates how flexible and versatile Visualization Library's architecture is.

For more information on how to use the vl::SceneManagerPortals class in combination with other scene managers see:

  • vl::Sector::VisibilityCallback
  • vl::SceneManagerPortals::externalSector()

For more information about portal-based hidden surface removal see:

  • http://en.wikipedia.org/wiki/Portal_rendering
  • http://en.wikipedia.org/wiki/Hidden_surface_determination
  • http://www.devmaster.net/articles/hidden-surface-removal/

View of the normal scene. | View of the detected portals. | Geometry rendered using only view frustum culling. Note how much geometry is rendered in the background that will never be visible. | Geometry rendered using portal-based hidden surface removal. As we see portal-based hsr can take advantage of highly occluded scenes and can greatly boost the rendering process.

In the following example we will procedurally create a dungeon with many rooms and will automatically create all the Portals and Sectors. Much of the code is taken by the geometry, portal and sector generation. As you will see the actual code that uses the vl::SceneManagerPortals class is very few. If we had the portals and sectors ready we would just load them into a vl::SceneManagerPortals and install the portal scene manager in a few lines of code!

Note that to outline even more the benefits of the portal-based hidden surface removal algorithm we will also add several highly detailed spheres to each sector. Pressing <F8> will enable/disable the portal-based culling.

[From App_PortalCulling.hpp]

#include "vl/SceneManagerPortals.hpp"
#include "vl/Effect.hpp"
#include "vl/Geometry.hpp"
#include "BaseDemo.hpp"

// Here we define our dungeon which will be the test platform for our portal scene manager.
// X = room, for each room a sector is generated, each room is filled with a couple of spheres.
// When an X is next to another X a passage (and relative Portal) is generated.
const int map_size = 7;
const char* map[map_size] =
{
  "       ",
  " XXXXX ",
  " XXXXX ",
  " XXXXX ",
  " XXXXX ",
  " XXXXX ",
  "       "
};
const float room_h        = 5.0f;
const float room_size_out = 20.0f;
const float room_size_in  = 18.0f;
// Initialize the Sectors.
vl::ref<vl::Sector> sectors[map_size][map_size] =
{
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector },
  { new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector, new vl::Sector }
};

// When the demo starts press the "f" key to activate the "fly" or "ghost" camera mode.
class App_PortalCulling: public BaseDemo
{
public:
  App_PortalCulling() {}

  void initEvent()
  {
    // Basic initialization
    BaseDemo::initEvent();
    ghostCamera()->setMovementSpeed(5.0f);

    generateDungeon();
  }

  // keyboard controls
  // F6 = toggle wireframe
  // F7 = toggle show portals
  // F8 = enable/disable portal-based culling
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch, key);
    if (key == vl::Key_F6)
    {
      if (mPolygonMode->frontFace() == vl::PM_LINE)
        mPolygonMode->set(vl::PM_FILL, vl::PM_FILL);
      else
        mPolygonMode->set(vl::PM_LINE, vl::PM_LINE);
    }
    else
    if (key == vl::Key_F7)
      mPortalSceneManager->setShowPortals( !mPortalSceneManager->showPortals() );
    else
    if (key == vl::Key_F8)
      mPortalSceneManager->setCullingEnabled( !mPortalSceneManager->cullingEnabled() );
  }

  // simple method to keep the camera on the floor
  void run()
  {
    vl::mat4 im = trackball()->camera()->inverseViewMatrix();
    vl::vec3 t = im.getT(); t.y() = 1.5f; im.setT(t);
    trackball()->camera()->setInverseViewMatrix(im);
  }

  // procedurally generate the dungeon with sectors, geometry and portals
  void generateDungeon()
  {
    // ###########################################
    // # Install and use our SceneManagerPortals! #
    // ###########################################
    mPortalSceneManager = new vl::SceneManagerPortals;
    mPortalSceneManager->setShowPortals(true);
    // remove all the other scene managers
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->sceneManagers()->clear();
    // install our SceneManagerPortals!
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->sceneManagers()->push_back(mPortalSceneManager.get());

    // Skip the boring code below and just pay attention to how the Sector and Portal classes are used!

    // generate the effects we will use for the walls, ceilings etc. of our dungeon
    mPolygonMode = new vl::PolygonMode;
    vl::ref<vl::Effect> floor_fx = new vl::Effect;
    floor_fx->shader()->enable(vl::EN_DEPTH_TEST);
    floor_fx->shader()->enable(vl::EN_LIGHTING);
    floor_fx->shader()->gocLight(0);
    floor_fx->shader()->gocLightModel()->setTwoSide(true);
    floor_fx->shader()->gocMaterial()->setDiffuse(vlut::crimson);
    floor_fx->shader()->setRenderState(mPolygonMode.get());

    vl::ref<vl::Effect> ceiling_fx = new vl::Effect;
    ceiling_fx->shader()->enable(vl::EN_DEPTH_TEST);
    ceiling_fx->shader()->enable(vl::EN_LIGHTING);
    ceiling_fx->shader()->gocLight(0);
    ceiling_fx->shader()->gocLightModel()->setTwoSide(true);
    ceiling_fx->shader()->gocMaterial()->setDiffuse(vlut::gray);
    ceiling_fx->shader()->setRenderState(mPolygonMode.get());

    vl::ref<vl::Effect> wall_fx = new vl::Effect;
    wall_fx->shader()->enable(vl::EN_DEPTH_TEST);
    wall_fx->shader()->enable(vl::EN_LIGHTING);
    wall_fx->shader()->gocLight(0)->setLinearAttenuation(0.025f);
    wall_fx->shader()->gocLightModel()->setTwoSide(true);
    wall_fx->shader()->gocMaterial()->setDiffuse(vlut::gold);
    wall_fx->shader()->setRenderState(mPolygonMode.get());

    // boring code to generate the gometry of various kinds of walls, with out door, with door, with the passage and portal.

    vl::ref<vl::Geometry> wall_1_a = vlut::makeGrid(vl::vec3(room_h/2.0f,0,0),room_h,room_size_in,20,20);
    wall_1_a->computeNormals();
    wall_1_a->transform(vl::mat4::rotation(90,0,0,1));

    vl::ref<vl::Geometry> wall_2_a = vlut::makeGrid(vl::vec3(0,0,room_h/2.0f),room_size_in,room_h,20,20);
    wall_2_a->computeNormals();
    wall_2_a->transform(vl::mat4::rotation(-90,1,0,0));

    float w1 = room_size_in / 6.0f;
    float h1 = room_h       / 3.0f * 2.0f;
    float w2 = room_size_in / 2.0f;
    float h2 = room_h;
    vl::ref<vl::ArrayFVec3> vert_array;
    vl::ref<vl::DrawElementsUInt> de;

    // wall 1 b
    vl::ref<vl::Geometry> wall_1_b = new vl::Geometry;
    vert_array = new vl::ArrayFVec3;
    wall_1_b->setVertexArray(vert_array.get());
    vert_array->resize(8);
    // 1-----------2
    // |           |
    // |   6---5   |
    // |   |   |   |
    // 0---7   4---3
    vert_array->at(0) = vl::fvec3(0, 0, -w2);
    vert_array->at(1) = vl::fvec3(0,+h2,-w2);
    vert_array->at(2) = vl::fvec3(0,+h2,+w2);
    vert_array->at(3) = vl::fvec3(0, 0, +w2);
    vert_array->at(4) = vl::fvec3(0, 0, +w1);
    vert_array->at(5) = vl::fvec3(0,h1, +w1);
    vert_array->at(6) = vl::fvec3(0,h1, -w1);
    vert_array->at(7) = vl::fvec3(0, 0, -w1);
    de = new vl::DrawElementsUInt(vl::PT_QUADS);
    wall_1_b->primitives()->push_back(de.get());
    de->indices()->resize(12);
    de->indices()->at(0) = 1; // a
    de->indices()->at(1) = 0;
    de->indices()->at(2) = 7;
    de->indices()->at(3) = 6;
    de->indices()->at(4) = 1; // b
    de->indices()->at(5) = 6;
    de->indices()->at(6) = 5;
    de->indices()->at(7) = 2;
    de->indices()->at(8)  = 5; // c
    de->indices()->at(9)  = 4;
    de->indices()->at(10) = 3;
    de->indices()->at(11) = 2;
    wall_1_b->computeNormals();

    // wall_1_c
    vl::fvec3 v1c(room_size_out-room_size_in,0,0);
    vl::ref<vl::Geometry> wall_1_c = new vl::Geometry;
    vert_array = new vl::ArrayFVec3;
    wall_1_c->setVertexArray(vert_array.get());
    vert_array->resize(8);
    // 1-----------2
    // |   6---5   |
    // |   |   |   |
    // |   7---4   |
    // 0-----------3
    vert_array->at(0) = vl::fvec3(0, 0, -w1);
    vert_array->at(1) = vl::fvec3(0,h1, -w1);
    vert_array->at(2) = vl::fvec3(0,h1, +w1);
    vert_array->at(3) = vl::fvec3(0, 0, +w1);
    vert_array->at(4) = vl::fvec3(0, 0, +w1) + v1c;
    vert_array->at(5) = vl::fvec3(0,h1, +w1) + v1c;
    vert_array->at(6) = vl::fvec3(0,h1, -w1) + v1c;
    vert_array->at(7) = vl::fvec3(0, 0, -w1) + v1c;
    de = new vl::DrawElementsUInt(vl::PT_QUADS);
    wall_1_c->primitives()->push_back(de.get());
    de->indices()->resize(16);
    de->indices()->at(0) = 1; // a
    de->indices()->at(1) = 0;
    de->indices()->at(2) = 7;
    de->indices()->at(3) = 6;
    de->indices()->at(4) = 1; // b
    de->indices()->at(5) = 6;
    de->indices()->at(6) = 5;
    de->indices()->at(7) = 2;
    de->indices()->at(8)  = 5; // c
    de->indices()->at(9)  = 4;
    de->indices()->at(10) = 3;
    de->indices()->at(11) = 2;
    de->indices()->at(12) = 0; // d
    de->indices()->at(13) = 3;
    de->indices()->at(14) = 4;
    de->indices()->at(15) = 7;
    wall_1_c->computeNormals();

    // wall 2 b
    vl::ref<vl::Geometry> wall_2_b = new vl::Geometry;
    vert_array = new vl::ArrayFVec3;
    wall_2_b->setVertexArray(vert_array.get());
    vert_array->resize(8);
    // 1-----------2
    // |           |
    // |   6---5   |
    // |   |   |   |
    // 0---7   4---3
    vert_array->at(0) = vl::fvec3(-w2, 0, 0);
    vert_array->at(1) = vl::fvec3(-w2,+h2,0);
    vert_array->at(2) = vl::fvec3(+w2,+h2,0);
    vert_array->at(3) = vl::fvec3(+w2, 0, 0);
    vert_array->at(4) = vl::fvec3(+w1, 0, 0);
    vert_array->at(5) = vl::fvec3(+w1,h1, 0);
    vert_array->at(6) = vl::fvec3(-w1,h1, 0);
    vert_array->at(7) = vl::fvec3(-w1, 0, 0);
    de = new vl::DrawElementsUInt(vl::PT_QUADS);
    wall_2_b->primitives()->push_back(de.get());
    de->indices()->resize(12);
    de->indices()->at(0) = 1; // a
    de->indices()->at(1) = 0;
    de->indices()->at(2) = 7;
    de->indices()->at(3) = 6;
    de->indices()->at(4) = 1; // b
    de->indices()->at(5) = 6;
    de->indices()->at(6) = 5;
    de->indices()->at(7) = 2;
    de->indices()->at(8)  = 5; // c
    de->indices()->at(9)  = 4;
    de->indices()->at(10) = 3;
    de->indices()->at(11) = 2;
    wall_2_b->computeNormals();

    // wall_2_c
    vl::fvec3 v2c(0,0,room_size_out-room_size_in);
    vl::ref<vl::Geometry> wall_2_c = new vl::Geometry;
    vert_array = new vl::ArrayFVec3;
    wall_2_c->setVertexArray(vert_array.get());
    vert_array->resize(8);
    // 1-----------2
    // |   6---5   |
    // |   |   |   |
    // |   7---4   |
    // 0-----------3
    vert_array->at(0) = vl::fvec3(-w1, 0, 0);
    vert_array->at(1) = vl::fvec3(-w1,h1, 0);
    vert_array->at(2) = vl::fvec3(+w1,h1, 0);
    vert_array->at(3) = vl::fvec3(+w1, 0, 0);
    vert_array->at(4) = vl::fvec3(+w1, 0, 0) + v2c;
    vert_array->at(5) = vl::fvec3(+w1,h1, 0) + v2c;
    vert_array->at(6) = vl::fvec3(-w1,h1, 0) + v2c;
    vert_array->at(7) = vl::fvec3(-w1, 0, 0) + v2c;
    de = new vl::DrawElementsUInt(vl::PT_QUADS);
    wall_2_c->primitives()->push_back(de.get());
    de->indices()->resize(16);
    de->indices()->at(0) = 1; // a
    de->indices()->at(1) = 0;
    de->indices()->at(2) = 7;
    de->indices()->at(3) = 6;
    de->indices()->at(4) = 1; // b
    de->indices()->at(5) = 6;
    de->indices()->at(6) = 5;
    de->indices()->at(7) = 2;
    de->indices()->at(8)  = 5; // c
    de->indices()->at(9)  = 4;
    de->indices()->at(10) = 3;
    de->indices()->at(11) = 2;
    de->indices()->at(12) = 0; // d
    de->indices()->at(13) = 3;
    de->indices()->at(14) = 4;
    de->indices()->at(15) = 7;
    wall_2_c->computeNormals();

    // very heavy spheres to be added to the sectors to outline more clearly the advantages of portal-based culling.
    vl::ref<vl::Geometry> sphere = vlut::makeUVSphere(vl::vec3(0,3,0),1,200,200);
    sphere->computeNormals();
    vl::ref<vl::Effect> ball_fx = new vl::Effect;
    ball_fx->shader()->enable(vl::EN_DEPTH_TEST);
    ball_fx->shader()->enable(vl::EN_LIGHTING);
    ball_fx->shader()->gocLight(0);
    ball_fx->shader()->setRenderState(mPolygonMode.get());

    // for each cell of the dungeon
    for(int y=0; y<map_size; ++y)
    {
      for(int x=0; x<map_size; ++x)
      {
        if (map[y][x] == 'X')
        {
          // ###########################
          // # allocate the new Sector #
          // ###########################
          vl::Sector* sector1 = sectors[y][x].get();
          mPortalSceneManager->sectors().push_back(sector1);

          // add floor to the sector/room
          vl::ref<vl::Geometry> floor = vlut::makeGrid(vl::vec3(x*room_size_out, 0, y*room_size_out), room_size_in, room_size_in, 20, 20);
          floor->computeNormals();
          sector1->actors()->push_back( new vl::Actor(floor.get(), floor_fx.get(), NULL) );

          // add ceiling to the sector/room
          vl::ref<vl::Geometry> ceiling = vlut::makeGrid(vl::vec3(x*room_size_out, room_h, y*room_size_out), room_size_in, room_size_in, 20, 20);
          ceiling->computeNormals();
          sector1->actors()->push_back( new vl::Actor(ceiling.get(), ceiling_fx.get(), NULL) );

          // generate walls, doors and portals:

          vl::mat4 m;
          vl::ref<vl::Transform> tr;

          if(map[y][x-1] == 'X') // west door: the two sectors comunicate
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(-room_size_in/2.0f,0,0));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            // add to the sector
            sector1->actors()->push_back( new vl::Actor(wall_1_b.get(), wall_fx.get(), tr.get()) );
          }
          else
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(-room_size_in/2.0f,0,0));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            // add to the sector
            sector1->actors()->push_back( new vl::Actor(wall_1_a.get(), wall_fx.get(), tr.get()) );
          }

          if(map[y][x+1] == 'X') // east door: the two sectors comunicate
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(+room_size_in/2.0f,0,0));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            // add to the sector
            sector1->actors()->push_back( new vl::Actor(wall_1_b.get(), wall_fx.get(), tr.get()) );
            sector1->actors()->push_back( new vl::Actor(wall_1_c.get(), wall_fx.get(), tr.get()) );

            // #####################################################
            // # create the two Portals to connect the two Sectors #
            // #####################################################
            // portal1: sector1 -> sector2
            // portal2: sector2 -> sector1
            // This is very important: in order to connect two sectors A and B you have to create a
            // portal in A whose target is B, and other portal in B whose target is A.
            // This way each sector can see the other.

            // new portal
            vl::ref<vl::Portal> portal1 = new vl::Portal;
            vl::ref<vl::Portal> portal2 = new vl::Portal;
            vl::Sector* sector2 = sectors[y][x+1].get();
            // link each sector to the other using their portals
            sector1->portals().push_back(portal1.get()); portal1->setTargetSector( sector2 );
            sector2->portals().push_back(portal2.get()); portal2->setTargetSector( sector1 );
            // setup portal geometry - note: the portal geometry must be a planar, convex polygon, in world space coordinates.
            portal1->geometry().resize(4);
            portal1->geometry().at(0) = (vl::fmat4)m * (vl::fvec3(0, 0,+w1) + v1c);
            portal1->geometry().at(1) = (vl::fmat4)m * (vl::fvec3(0,h1,+w1) + v1c);
            portal1->geometry().at(2) = (vl::fmat4)m * (vl::fvec3(0,h1,-w1) + v1c);
            portal1->geometry().at(3) = (vl::fmat4)m * (vl::fvec3(0, 0,-w1) + v1c);
            portal2->geometry().resize(4);
            portal2->geometry().at(0) = (vl::fmat4)m * (vl::fvec3(0, 0,+w1) + v1c);
            portal2->geometry().at(1) = (vl::fmat4)m * (vl::fvec3(0,h1,+w1) + v1c);
            portal2->geometry().at(2) = (vl::fmat4)m * (vl::fvec3(0,h1,-w1) + v1c);
            portal2->geometry().at(3) = (vl::fmat4)m * (vl::fvec3(0, 0,-w1) + v1c);
          }
          else
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(+room_size_in/2.0f,0,0));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(wall_1_a.get(), wall_fx.get(), tr.get()) );
          }

          if(map[y-1][x] == 'X') // south door: the two sectors comunicate
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(0,0,-room_size_in/2.0f));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(wall_2_b.get(), wall_fx.get(), tr.get()) );
          }
          else
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(0,0,-room_size_in/2.0f));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(wall_2_a.get(), wall_fx.get(), tr.get()) );
          }

          if(map[y+1][x] == 'X') // north door: the two sectors comunicate
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(0,0,+room_size_in/2.0f));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(wall_2_b.get(), wall_fx.get(), tr.get()) );
            sector1->actors()->push_back( new vl::Actor(wall_2_c.get(), wall_fx.get(), tr.get()) );

            // same as seen above...
            // #####################################################
            // # create the two Portals to connect the two Sectors #
            // #####################################################
            // portal1: sector1 -> sector2
            // portal2: sector2 -> sector1
            // This is very important: in order to connect two sectors A and B you have to create a
            // portal in A whose target is B, and other portal in B whose target is A.
            // This way each sector can see the other.

            // new portal
            vl::ref<vl::Portal> portal1 = new vl::Portal;
            vl::ref<vl::Portal> portal2 = new vl::Portal;
            vl::Sector* sector2 = sectors[y+1][x].get();
            // link each sector to the other using their portals
            sector1->portals().push_back(portal1.get()); portal1->setTargetSector( sector2 );
            sector2->portals().push_back(portal2.get()); portal2->setTargetSector( sector1 );
            // setup portal geometry - note: the portal geometry must be a planar, convex polygon, in world space coordinates.
            portal1->geometry().resize(4);
            portal1->geometry().at(0) = (vl::fmat4)m * (vl::fvec3(+w1, 0, 0) + v2c);
            portal1->geometry().at(1) = (vl::fmat4)m * (vl::fvec3(+w1,h1, 0) + v2c);
            portal1->geometry().at(2) = (vl::fmat4)m * (vl::fvec3(-w1,h1, 0) + v2c);
            portal1->geometry().at(3) = (vl::fmat4)m * (vl::fvec3(-w1, 0, 0) + v2c);
            portal2->geometry().resize(4);
            portal2->geometry().at(0) = (vl::fmat4)m * (vl::fvec3(+w1, 0, 0) + v2c);
            portal2->geometry().at(1) = (vl::fmat4)m * (vl::fvec3(+w1,h1, 0) + v2c);
            portal2->geometry().at(2) = (vl::fmat4)m * (vl::fvec3(-w1,h1, 0) + v2c);
            portal2->geometry().at(3) = (vl::fmat4)m * (vl::fvec3(-w1, 0, 0) + v2c);
          }
          else
          {
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(0,0,+room_size_in/2.0f));
            tr = new vl::Transform; tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(wall_2_a.get(), wall_fx.get(), tr.get()) );
          }

          // add other actors to the scene
          for(unsigned int i=0; i<25; ++i)
          {
            vl::ref<vl::Transform> tr = new vl::Transform;
            float tx = (rand()%100) / 100.0f * room_size_in - room_size_in / 2.0f;
            float tz = (rand()%100) / 100.0f * room_size_in - room_size_in / 2.0f;
            m = vl::mat4::translation(vl::vec3(x*room_size_out, 0, y*room_size_out) + vl::vec3(tx,0,tz));
            tr->setLocalMatrix(m); tr->computeWorldMatrix();
            sector1->actors()->push_back( new vl::Actor(sphere.get(), ball_fx.get(), tr.get()) );
          }

          // ############################################
          // # simple way to define the Sector's volume #
          // ############################################
          // Each Sector must have a set of volumes that are checked at the beginning of each rendering
          // to decide in which one the camera is. In our case we just use the bounding box of the
          // Sector itself. Note that the volumes of a Sector must not intersect the volumes of the other
          // Sectors, otherwise the algorithm won't be able to determine in which Sector the camera is in.
          // I.e, it will randomly pick the first found!
          sector1->volumes().push_back( sector1->computeBoundingBox() );
        }
      }
    }

    // #######################################
    // # initialize the portal scene manager #
    // #######################################
    // Precomputes some internal data and performs some sanity checks.
    mPortalSceneManager->initialize();
  }

protected:
  vl::ref<vl::PolygonMode> mPolygonMode;
  vl::ref<vl::SceneManagerPortals> mPortalSceneManager;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: OpenGL-Accelerated Occlusion Culling Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

OpenGL-Accelerated Occlusion Culling Tutorial

This tutorial demonstrates how to perform hadware accelerated occlusion culling using the OpenGL extension GL_ARB_occlusion_query.

For more information about the OpenGL extension GL_ARB_occlusion_query see also http://oss.sgi.com/projects/ogl-sample/registry/ARB/occlusion_query.txt

Sample Foreset Model (1681 trees) - Benchmark on NVIDIA GeForce 8600M GT, Intel Core 2 Duo 2.0GHz
Large occluder in red:
  • Occlusion culling off: 7.9 fps.
  • Occlusion culling on: 46.0 fps.
  • Speedup: 582%
View of the forest from above:
  • Occlusion culling off: 10.2 fps.
  • Occlusion culling on: 24.8 fps.
  • Speedup: 243%
View from under, the ground is a very good occluder:
  • Occlusion culling off: 8.4 fps.
  • Occlusion culling on: 52.0 fps.
  • Speedup: 620%
View of the forest from inside:
  • Occlusion culling off: 8.5 fps.
  • Occlusion culling on: 42.3 fps.
  • Speedup: 497%

When rendering highly detailed and densely populated scenes most of the rendered geometry is actually hidden by the other objects and geometry which are closer to the camera. This means that a consistent part the GPU time and computational power is spent to render objects that will not be visible in the final rendering. Consider for example a dense forest with thousands of trees. The trees that are close to the camera will have a high chance to be visible but the ones that are far away from the camera will probably not be visible due to the fact that the close ones occlude a significant part of the view. The term "occlusion culling" refers to a set of techniques that try to exploit this fact. By detecting in advance which objects will be occluded and thus invisible, we can avoid rendering objects that will not significantly contribute to the scene, potentially obtaining a dramatic rendering boost as seen from the figures above.

Drawbacks
The OpenGL extension GL_ARB_occlusion_query allows a program to request if a given object will contribute or not to the final rendering providing a huge potential in terms of rendering performances increase as we have seen. Unfortunately this technique has also some drawbacks due to the way the GPU and CPU collaborate, the most important being the fact that once you requested this occlusion visibility check, the OpenGL driver cannot reply before having executed all the OpenGL commands that precede such request. For this reason in order to maximize the CPU/GPU concurrency (and with it the rendering performances) Visualization Library waits one rendering frame before checking the result of the occlusion queries. This means that at any given frame the result of such query actually refers to the position that the camera and the objects had relative to each other in the previous frame. As a result of this occasional flickers might occur when an invisible object becomes visible especially when the camera or such object is moving fast compared to the rendering refresh rate. An example of such problem is shown below.

In the image above the camera is quickly moving to the left uncovering a part of the trees that in the preceding frame were covered by the red occluder. Such trees weren't visible in the previous frame and are thus not rendered in the current frame producing a temporary "hole" in the forest. Note that such "hole" lasts for a single rendering frame but potentially new holes might occur while the camera continues its movement.

Artifacts like this might be more or less noticeable based on the kind of scene rendered and based on the refresh rate of the rendering. For example, it is very easy to notice this effect at 10 fps, but is much more difficult if not impossible to notice them at let say 160 fps.

Note that requesting the result of an occlusion query in the same frame in which it is issued is not an option as this would not only kill the GPU/CPU concurrency but would also cause a vicious cpu-stall/gpu-starvation circle that would result in unacceptable performances even for simple scenes.

Enabling Occlusion Culling
Exploiting the huge potential of OpenGL accelerated occlusion culling with Visualization Library is extremely simple provided you pay attention to a few details.

  • To enable the occlusion culling you set a simple flag using the method vl::Renderer::setOcclusionCullingEnabled(). This will enable the occlusion culling for all the vl::Actor[s] rendered from then on.
  • Enabling the occlusion culling though is not enough. In order to maximize its efficiency we need to render the solid (non translucent) objects in front-to-back order, that is, we first render the close ones and then the ones far away to maximize the chance of culling away as many objects as possible. In order to do this we will install a special vl::RenderQueueSorter called vl::RenderQueueSorterOcclusion using the method vl::Rendering::setRenderQueueSorter().

Large Occluders
In order to be sure to maximize the efficiency of the occlusion culling you want to make sure that large occluders are rendered before all the other objects. In our case for example we assign a rendering rank of -1 to the ground vl::Actor. You should always pay particular attention to very large occluders like the ground vl::Actor in our scene. In fact the vl::RenderQueueSorterOcclusion sorts the vl::Actor[s] based on the distance between the camera and their center. This means that a very large occluder might actually be in front of all the other objects but its center might be further away. Consider for example the image below:

The red dot on the left represents the camera, the gray object is a large occluder, the boxes are other objects occluded by the large gray one. As we can see if we simply render the objects in front to back order based on their centers we end up rendering first the red boxes (thus wasting time since they will not be visible!), then the large gray occluder which overdraws the red boxes when rendered on the screen, and then the green boxes (which are actually not rendered thanks to the occlusion culling). With this approach we rendered six boxes (the red ones) which are actually not visible. To optimize this case we would render the gray occluder for first, specifying for it a render rank lower than the boxes' render rank. Remember that the user specified ordering (Actor render rank and render block and Effect render rank) always wins against any eventual automatic sorting performed by a vl::RenderQueueSorter.

Also keep in mind that the concept of "large occluder" is heavily subjective as a skyscraper seen from 1 Km away is not a good occluder while a matchbox seen from very close can become a very good one!

[From App_OcclusionCulling.hpp]

class App_OcclusionCulling: public BaseDemo
{
public:
  void initEvent()
  {
    BaseDemo::initEvent();

    // #######################################################################
    // # These 2 lines are the only code needed to enable occlusion culling! #
    // #######################################################################
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->renderer()->setOcclusionCullingEnabled(true);
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->setRenderQueueSorter(new vl::RenderQueueSorterOcclusion);

    /* the rest of the code simply generates a forest of thousands of trees */

    /* setup a simple effect to use for all our objects */
    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->gocMaterial()->setColorMaterialEnabled(true);
    fx->shader()->gocLight(0)->setLinearAttenuation(0.0025f);

    /* the ground under the trees */
    float side = 400;
    vl::ref<vl::Geometry> ground = vlut::makeGrid(vl::vec3(0,0,0), side*2.0f,side*2.0f, (int)side, (int)side);
    ground->computeNormals();
    ground->setColorArray(vlut::green);
    vl::Actor* ground_act = sceneManager()->tree()->addActor(ground.get(), fx.get(), NULL);
    /* assign a render rank of -1 (default is 0) to be sure to render the ground before all the trees */
    ground_act->setRenderRank(-1);

    /* the red wall in front of the camera */
    vl::ref<vl::Geometry> wall = vlut::makeBox(vl::vec3(0,25,500), 50,50,1);
    wall->computeNormals();
    wall->setColorArray(vlut::red);
    sceneManager()->tree()->addActor(wall.get(), fx.get(), NULL);

    /* the trees */
    float trunk_h   = 20;
    float trunk_w   = 4;
    /* the tree's branches */
    vl::ref<vl::Geometry> branches = vlut::makeIcosphere(vl::vec3(0,trunk_h/2.0f,0), 7, 1, false);
    branches->computeNormals();
    branches->setColorArray( vlut::green );
    /* the tree's trunk */
    vl::ref<vl::Geometry> trunk = vlut::makeCylinder(vl::vec3(0,0,0),trunk_w,trunk_h, 35, 35);
    trunk->computeNormals();
    trunk->setColorArray( vlut::gold );

    /* fill our forest with trees! */
    int trunk_count = 20;
    for(int i=-trunk_count; i<=trunk_count; ++i)
    for(int j=-trunk_count; j<=trunk_count; ++j)
    {
      float x = (float) i * side / trunk_count;
      float z = (float) j * side / trunk_count;

      vl::ref<vl::Transform> tr = new vl::Transform( vl::mat4::translation(x,trunk_h/2.0f+0.1f,z) );
      tr->computeWorldMatrix();
      sceneManager()->tree()->addActor(trunk.get(), fx.get(), tr.get());
      sceneManager()->tree()->addActor(branches.get(), fx.get(), tr.get());
    }
  }

  /* spacebar = toggles occlusion culling */
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch, key);
    if (key == vl::Key_Space)
    {
      bool on = vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->renderer()->occlusionCullingEnabled();
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->renderer()->setOcclusionCullingEnabled(!on);
      vl::Log::print( vl::Say("Occlusion = %s\n") << (vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->renderer()->occlusionCullingEnabled() ? "On" : "Off") );
    }
  }
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Bicubic Bézier Patches and Surfaces Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Bicubic Bézier Patches and Surfaces Tutorial

In the following tutorial you will learn how to manage and generate bicubic Bezier surfaces and how to concatenate multiple patches.

A Bézier surface defined by multiple concatenated patches rendered with an ascending (from left to right) tessellation level. The dots and the white lines represent the control points of the patches, the red dots represent the corner control points that are guaranteed to touch the Bézier surface.

From Wikipedia [http://en.wikipedia.org/wiki/Bézier_surface]:

"Bézier surfaces are a species of mathematical spline used in computer graphics, computer-aided design, and finite element modelling. As with the Bézier curve, a Bézier surface is defined by a set of control points. Similar to interpolation in many respects, a key difference is that the surface does not, in general, pass through the central control points; rather, it is "stretched" toward them as though each were an attractive force. They are visually intuitive, and for many applications, mathematically convenient."

"Bézier surfaces were first described in 1972 by the French engineer Pierre Bézier who used them to design automobile bodies. Bézier surfaces can be of any degree, but bicubic Bézier surfaces generally provide enough degrees of freedom for most applications."

As you will se the actual code dealing with the Bezier patches is less than ten lines of code! The majority of the code is dedicated to generate the patch data, to setup the effects, to manage the user input and so on.

[From App_BezierSurfaces.hpp]

class App_BezierSurfaces: public BaseDemo
{
public:
  App_BezierSurfaces(): mDetail(10) {}

  void initEvent()
  {
    BaseDemo::initEvent();

    /* 2 pass shader: 1 = solid, 2 = wireframe */

    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->lod(0)->push_back( new vl::Shader);

    fx->shader()->enable(vl::EN_LIGHTING);
    fx->shader()->gocLightModel()->setTwoSide(true);
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    fx->shader()->gocLight(0)->setLinearAttenuation(0.025f);

    fx->shader(0,1)->enable(vl::EN_DEPTH_TEST);
    fx->shader(0,1)->gocPolygonOffset()->set(-0.5f, -0.5f);
    fx->shader(0,1)->enable(vl::EN_POLYGON_OFFSET_LINE);
    fx->shader(0,1)->gocPolygonMode()->set(vl::PM_LINE, vl::PM_LINE);
    fx->shader(0,1)->gocDepthMask()->set(false);

    /* Generate random Bézier patches

    - The simplest bicubic Bézier patch requires 4x4 = 16 control points: A, B, C, D, E, F, G, H, I, L, M, N, O, P, Q, R
    - The Bézier surface is guaranteed to touch only the 4 corner control points A, D, O and R.

    A---B---C---D
    |   |   |   |
    E---F---G---H
    |   |   |   |
    I---L---M---N
    |   |   |   |
    O---P---Q---R

    - You can concatenate two bicubic Bézier patches to form a larger suface by sharing their control points like this:

       patch 1     patch 2
    A---+---+---B---+---+---G
    |   |   |   |   |   |   |
    +---+---+---C---+---+---+
    |   |   |   |   |   |   |
    +---+---+---D---+---+---+
    |   |   |   |   |   |   |
    F---+---+---E---+---+---H

    - In this case the two patches share the control points B, C, D and E.
    - As we can see the total control points needed are 28 = (2 (patches along x) * 3 + 1) * (1 (patches along y) * 3 + 1)
    - Also in this case the Bézier surface is guaranteed to touch only the 6 corner control points A, B, E, F, G and H.

    */

    // This concatenated patch will actually contain 3*2 = 6 bicubic Bézier patches for a total of 70 control points!
    int x = 3;
    int y = 2;
    // We use the formula seen above to compute the number of control points required in each direction.
    vl::ref<vl::BezierPatch> patch1 = new vl::BezierPatch(x*3+1,y*3+1);
    for(int y=0;y<patch1->y();++y)
      for(int x=0;x<patch1->x();++x)
        patch1->points()[x][y] = vl::dvec3(x,vl::randomMinMax(-2.0,+2.0),y);

    /* Add Bézier patches to our Bézier surface */

    // Instance our Bézier surface
    mBezier = new vl::BezierSurface;
    // We can actually add multiple Bézier patches
    mBezier->patches().push_back(patch1.get());
    // Define the subdivision detail
    mBezier->setDetail(mDetail);
    // Generate the actual geometry using the current patches and detail
    mBezier->updateBezierSurface(false);
    // Compute the normals as we have lighting activated
    mBezier->computeNormals();
    // Used by the line rendering
    mBezier->setColorArray(vlut::blue);
    // Add the Bézier surface to our scene
    sceneManager()->tree()->addActor(mBezier.get(), fx.get(), NULL);

    /* Show the control points */

    showPatchControlPoints(mBezier.get());
  }

  /*
    up/down arrow = increase/decrease the Bézier surface tessellation detail
    space         = toggle control points visibility
  */
  void keyPressEvent(unsigned short ch, vl::EKey key)
  {
    BaseDemo::keyPressEvent(ch,key);
    if (key == vl::Key_Up)
    {
      ++mDetail;
      mDetail = vl::clamp(mDetail, 2, 64);
      mBezier->setDetail(mDetail);
      mBezier->updateBezierSurface(false);
      mBezier->computeNormals();
      mBezier->setVBODirty(true);
    }
    else
    if (key == vl::Key_Down)
    {
      --mDetail;
      mDetail = vl::clamp(mDetail, 2, 64);
      mBezier->setDetail(mDetail);
      mBezier->updateBezierSurface(false);
      mBezier->computeNormals();
      mBezier->setVBODirty(true);
    }
    else
    if(key == vl::Key_Space)
    {
      if (sceneManager()->tree()->actors()->find(mCtrlPoints_Actor.get()) == -1)
        sceneManager()->tree()->actors()->push_back(mCtrlPoints_Actor.get());
      else
        sceneManager()->tree()->actors()->erase(mCtrlPoints_Actor.get());
    }
  }

  /* Generates the geometry to render the control points */
  void showPatchControlPoints(vl::BezierSurface* bezier)
  {
    vl::ref<vl::Effect> fx = new vl::Effect;
    fx->shader()->enable(vl::EN_DEPTH_TEST);
    fx->shader()->gocPolygonMode()->set(vl::PM_LINE, vl::PM_LINE);
    fx->shader()->gocLineWidth()->set(1.0f);
    fx->shader()->gocPointSize()->set(5.0f);

    vl::ref<vl::Geometry> geom = new vl::Geometry;

    int istart = 0;
    std::vector<vl::fvec3> verts;
    std::vector<vl::fvec4> colos;
    for(unsigned ipatch=0; ipatch<bezier->patches().size(); ++ipatch)
    {
      const vl::BezierPatch::Points& p = bezier->patches()[ipatch]->points();
      for(unsigned ix=0; ix<p.size()-3;     ix+=3)
      for(unsigned iy=0; iy<p[ix].size()-3; iy+=3, istart+=16)
      {
        verts.push_back((vl::fvec3)p[ix+0][iy+0]); colos.push_back(vlut::red);
        verts.push_back((vl::fvec3)p[ix+0][iy+1]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+0][iy+2]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+0][iy+3]); colos.push_back(vlut::red);

        verts.push_back((vl::fvec3)p[ix+1][iy+0]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+1][iy+1]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+1][iy+2]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+1][iy+3]); colos.push_back(vlut::white);

        verts.push_back((vl::fvec3)p[ix+2][iy+0]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+2][iy+1]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+2][iy+2]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+2][iy+3]); colos.push_back(vlut::white);

        verts.push_back((vl::fvec3)p[ix+3][iy+0]); colos.push_back(vlut::red);
        verts.push_back((vl::fvec3)p[ix+3][iy+1]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+3][iy+2]); colos.push_back(vlut::white);
        verts.push_back((vl::fvec3)p[ix+3][iy+3]); colos.push_back(vlut::red);

        vl::ref<vl::DrawArrays> da = new vl::DrawArrays(vl::PT_POINTS,istart,16);
        vl::ref<vl::DrawElementsUInt> de = new vl::DrawElementsUInt(vl::PT_QUADS);
        de->indices()->resize(4*9);
        unsigned int quads[] = { 0,1,5,4, 4,5,9,8, 8,9,13,12, 1,2,6,5, 5,6,10,9, 9,10,14,13, 2,3,7,6, 6,7,11,10, 10,11,15,14 };
        for(int q=0; q<4*9; ++q)
          quads[q] += istart;
        memcpy(de->indices()->ptr(), quads, sizeof(quads));
        geom->primitives()->push_back(de.get());
        geom->primitives()->push_back(da.get());
      }
    }

    vl::ref<vl::ArrayFVec3> vert_array = new vl::ArrayFVec3;
    geom->setVertexArray(vert_array.get());
    *vert_array = verts;

    vl::ref<vl::ArrayFVec4> cols_array = new vl::ArrayFVec4;
    geom->setColorArray(cols_array.get());
    *cols_array = colos;

    mCtrlPoints_Actor = sceneManager()->tree()->addActor(geom.get(), fx.get(), NULL);
  }

protected:
  vl::ref<vl::BezierSurface> mBezier;
  vl::ref<vl::Actor> mCtrlPoints_Actor;
  int mDetail;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Transparency and Polygon Depth Sorting Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Transparency and Polygon Depth Sorting Tutorial

In this tutorial you will learn how to perform primitive depth sorting in order to obtain correct transparencies.

Managing transparent objects in the correct way using OpenGL (but also DirectX) can be quite challenging at times. This is because in general, when rendering transparent objects, the order in which such objects are rendered affects the final result. Theoretically the problem could be solved by sorting back to front each single pixel that is generated by the rendering process. In practice this approach is too expensive to implement and for simple cases it is enough to sort front to back entire objects. This works well util the transparent objects in the scene are convex but when we add concave objects we will start noticing some artifacts. In this cases it is necessary to sort back to font the polygons of each object. When two transparent objects intersect each other, though, not even this approach yelds correct results in general. Fortunately this last case is relatively rare compared to the previous ones.

Depth sorting on:
Depth sorting off:

The example below shows how to apply a vl::DepthSortCallback callback to an Actor in order to sort its polygons. In the example we load an object and we display it with and without polygon sorting to hightlight the effect of the vl::DepthSortCallback callback.

The DepthSortCallback class sorts the primitives of the Geometry object bound to the Actor in which the callback is installed.

This callback in order to work requires the following conditions:

  • The Actor must be bound to a Geometry
  • The bound Geometry must have a Geometry::vertexArray() of type ArrayFVec3
  • Sorts only DrawElementsUInt/UShort/UByte objects with primitive type: PT_POINTS, PT_LINES, PT_TRIANGLES, PT_QUADS

Remarks:
  • The sorting is based on the position of the vertices as specified by Geometry::vertexArray() and for obvious reasons cannot take into consideration transformations made in the vertex shader or in the geometry shader.
  • The sorting is performed on a per Primitives basis. For example, if a Geometry has 2 Primitives A and B bound to it, then the polygons, lines or points of A will alway be rendered before the ones specified by B. For this reason avoid using Geometry with more than one Primitives whenever possible to render transparent objects, but rather rearrange each Primitives in its own Geometry and Actor.
  • vl::DepthSortCallback cannot resolve transparency ordering when two or more transparent objects intersect each other.
  • You need to use vl::DepthSortCallback only when using order-dependent blending (as for the default alpha blending settings). If for example you are using additive blending you would simply set the depth mask to false (vl::DepthMask) and enable the depth test (vl::EN_DEPTH_TEST), but you wouldn't need to perform any sorting.

[From App_PolyDepthSorting.hpp]

class App_PolyDepthSorting: public BaseDemo
{
public:
  App_PolyDepthSorting(const vl::String& filename): mFileName(filename) {}

  void initEvent()
  {
    BaseDemo::initEvent();

    /* bind Transform */
    mTransform_Left  = new vl::Transform;
    mTransform_Right = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mTransform_Left.get() );
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild( mTransform_Right.get() );

    /* define the Effect to be used */
    vl::ref<vl::Effect> effect = new vl::Effect;
    /* enable depth test and lighting */
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    /* enable lighting and material properties */
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->gocMaterial()->setDiffuse( vl::fvec4(1.0f,1.0f,1.0f,0.5f) );
    effect->shader()->gocLightModel()->setTwoSide(true);
    /* enable alpha blending */
    effect->shader()->enable(vl::EN_BLEND);

    /* load the object*/
    vl::ref<vl::Geometry> geom_no_sort;
    vl::ref<vl::Geometry> geom_sorted;
    vl::ref<vl::ResourceDatabase> res_db;
    res_db = vl::loadResource(mFileName); if ( res_db && res_db->count<vl::Geometry>() ) geom_no_sort = res_db->get<vl::Geometry>(0);
    res_db = vl::loadResource(mFileName); if ( res_db && res_db->count<vl::Geometry>() ) geom_sorted  = res_db->get<vl::Geometry>(0);

    /*
     if you want you can do

     geom_sorted->setDisplayListEnabled(true);

     or

     geom_sorted->setVBOEnabled(true);

     but note that in this case the DepthSortCallback will schedule an update of the VBO or of the display list
     at every frame! This will almost centainly make the use of VBOs or display lists useful if not harmful, performance-wise.
    */

    /* add the two objects to the scene manager */
    vl::ref<vl::Actor> actor_no_sort = sceneManager()->tree()->addActor( geom_no_sort.get(), effect.get(), mTransform_Left.get() );
    vl::ref<vl::Actor> actor_sort    = sceneManager()->tree()->addActor( geom_sorted.get(),  effect.get(), mTransform_Right.get() );
    /* install the vl::DepthSortCallback that will depth-sort each primitive of the Actor upon rendering */
    actor_sort->renderingCallbacks()->push_back( new vl::DepthSortCallback );

    /* compute the appropriate offset to be used in updateTransforms() */
    geom_no_sort->computeBounds();
    geom_sorted->computeBounds();
    mOffset = float( (geom_no_sort->boundingSphere().radius() + geom_sorted->boundingSphere().radius()) * 0.5 );

    /* positions the two objects next to one another */
    updateTransforms();

    /* Position the camera to nicely see the objects in the scene.
       You must call this function after having positioned your objects in the scene! */
    trackball()->adjustView( sceneManager(), vl::vec3(0,0,1), vl::vec3(0,1,0), 1.0f );
  }

  void updateTransforms()
  {
    vl::Real degrees = vl::Time::currentTime() * 45.0f;
    vl::mat4 matrix  = vl::mat4::rotation( degrees, 0,1,0 );
    mTransform_Left->setLocalMatrix( vl::mat4::translation(-mOffset,0,0) * matrix );
    mTransform_Right->setLocalMatrix(vl::mat4::translation(+mOffset,0,0) * matrix );
  }

  void run() { updateTransforms(); }

protected:
  vl::ref<vl::Transform> mTransform_Left;
  vl::ref<vl::Transform> mTransform_Right;
  float mOffset;
  vl::String mFileName;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Antialiasing and Multisampling Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Antialiasing and Multisampling Tutorial

Text Antialiasing

Visualization Library addresses text rendering and line/polygon/points antialiasing separately. Visualization Library uses FreeType for text rendering which natively supports high quality sub-pixel antialiasing. Of course the antialiasing effect depends on the type and quality of the font used. The fonts distributed with VL (Bitstream Vera from the Gnome project) for example are excellent fonts and render high quality text. Poor fonts will always render poor text. The user does not need to enable text antialiasing, the text is always rendered antialiased, regardless of the settings discussed below.

Geometry Antialiasing
Antialiasing gometrical primitives is a totally different issue. In this case we can achieve antialiasing in two ways.

1) Smoothing.

Smoothing off | Smoothing on

Enabling point, line and polygon smoothing:

   ref<Effect> fx = new Effect;
   fx->shader()->enable(EN_BLEND);
   fx->shader()->enable(EN_POINT_SMOOTH);
   fx->shader()->enable(EN_LINE_SMOOTH);
   fx->shader()->enable(EN_POLYGON_SMOOTH);

Point, line and polygon smoothing requires alpha blending, for this reason we also enabled EN_BLEND. Unfortunately the fact that we are using blending makes our rendering order-dependent. That is, the order in which the primitives are drawn affects the final result. See also Transparency and Polygon Depth Sorting Tutorial for more information. You can use vl::DepthSortCallback to sort the primitives within an object but since this implies a consistent performance penalty one often accepts a few artifacts to preserve good performances. Usually this is not a big problem for smoothed lines or points, while smoothed polygons are used much more rarely in comparison.

  • Pro: supported by basically every OpenGL implementation.
  • Cons: needs blending enabled; needs back to front sorting; usually you have to accept some artifacts.

Keep also in mind that smoothed primitives require always more computational power compared to non smoothed ones.

2) Multisampling.

Multisampling off | Multisampling 8x on

When creating your OpenGL context enable multisampling. Doing this using a GUI framework supported by VL is very simple (see also Spinning Cube Tutorial):

 OpenGLContextFormat format;
 ...
 format.setMultisampleSamples(8);
 format.setMultisample(true);

The code above enables 8x multisampling (if your system supports it). Note that, for example, if you require 8x and your system supports only 4x, VL automatically selects 4x multisampling. Note also that selecting the appropriate pixel format is not an OpenGL issues but is rather a GUI framework issue. For this reason you might need to search through the documentation of your GUI framework (Win32, Qt, wxWidgets etc.) in order to open a multisampling-capable OpenGL rendering context.

Multisampling is basically transparent to the application, once is it enabled, everything becomes antialiased. Note that you can still enable/disable multisample on a per-Shader basis using

   ref<Effect> fx = new Effect;
   fx->shader()->enable/disable(EN_MULTISAMPLE); // disabled by default, as all the OpenGL enables.

  • Pro: virtually well supported (OpenGL 1.3 upwards); nicely and correctly multisamples everything; just need to set EN_MULTISAMPLE where appropriate; no blending or sorting is needed.
  • Cons: slower rendering; can use a consistent amount of GPU memory to store the extra samples; antialiasing quality and support depends on the user's system capability.

For more information on multisampling see http://www.opengl.org/registry/specs/ARB/multisample.txt

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Billboards Tutorial

Visualization Library Reference Documentation » Visualization Library Tutorials

Billboards Tutorial

This tutorial demonstrates how to use the vl::Billboard class to orient objects towards the camera.

The term "billboard" in computer graphics refers to an object that always faces the camera. Visualization Library supports two kinds of billboards, "spherical billboards" and "axis aligned billboards". The first kind is free to rotate in any direction and always faces the camera perfectly. The second kind rotates towards the camera but only around a specific rotation axis. This last kind is often used to create billboard trees which should face the camera but whose rotational axis must remain parallel to the world Y axis.

The following tutorial implements a simple forest using axis aligned billboards. To make the scene more interesting we will also add stars on the sky using spherical billboards. At the center of the scene we will also put a cube whose transform is a billboard attached to an animated transform tree. This demonstrates how billboards behave when attached to animated transform trees. When running the demo note how the cube keeps facing the camera while following its transform's parent's rotation.

[From App_Billboards.hpp]

class App_Billboards: public BaseDemo
{
public:
  // initialization
  void initEvent()
  {
    BaseDemo::initEvent();
    srand((unsigned int)time(NULL));

    generateTrees (100.0f, 500);
    generateStars (100.0f, 500);
    generateGround(100.0f);
    generateLunapark();
  }

  void generateTrees(float side, int tree_count)
  {
    // simple effect to render a tree billboard
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_BLEND);
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    effect->shader()->gocDepthMask()->set(false);
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->gocLight(0)->setLinearAttenuation(0.025f);
    effect->shader()->gocTextureUnit(0)->setTexture( new vl::Texture("images/tree.png") );

    vl::ref<vl::Geometry> tree = generateQuad();
    tree->transform( vl::mat4::translation(0,+0.5f,0) );
    tree->transform( vl::mat4::scaling(1.0f,+2.0f,1.0f) );
    tree->computeNormals();

    for(int i=0; i<tree_count; i++)
    {
      // new billboard
      vl::ref<vl::Billboard> billboard = new vl::Billboard;
      // set axis-aligned billboard type: rotate the billboard towards the camera but only around the specified axis.
      billboard->setType(vl::BT_AxisAlignedBillboard);
      billboard->setAxis(vl::vec3(0,1.0f,0));
      // bind billboard to the transform tree
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(billboard.get());
      // generate a random position
      vl::Real x = vl::randomMinMax(-side/2.0f,+side/2.0f);
      vl::Real y = 0;
      vl::Real z = vl::randomMinMax(-side/2.0f,+side/2.0f);
      billboard->setPosition( vl::vec3(x,y,z) );
      // add the tree actor
      sceneManager()->tree()->addActor(tree.get(), effect.get(), billboard.get());
    }
  }

  void generateStars(float side, int star_count)
  {
    // simple effect to render a star billboard
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_BLEND);
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    effect->shader()->gocTextureUnit(0)->setTexture( new vl::Texture("images/sun.png", vl::TF_RGBA, true) );

    vl::ref<vl::Geometry> star = generateQuad();

    for(int i=0; i<star_count; i++)
    {
      // new billboard
      vl::ref<vl::Billboard> billboard = new vl::Billboard;
      // set spherical billboard type: orient the object always towards the camera.
      billboard->setType(vl::BT_SphericalBillboard);
      // add billboard to the transform tree
      vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(billboard.get());
      // compute a random point on the skydome
      vl::Real x = vl::randomMinMax(-1.0f,+1.0f);
      vl::Real y = vl::randomMinMax(0,2.0f);
      vl::Real z = vl::randomMinMax(-1.0f,+1.0f);
      vl::vec3 n(x,y,z);
      n.normalize();
      n = n * sqrt(side*side/2.0f);
      n.y() *= 0.2f;
      // set the billboard position and rotation center.
      billboard->setPosition( n );
      // add the star actor
      sceneManager()->tree()->addActor(star.get(), effect.get(), billboard.get());
    }
  }

  // generates the ground
  void generateGround(float side)
  {
    // orange effect using lighting
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_LIGHTING);
    effect->shader()->gocLight(0)->setLinearAttenuation(0.025f);
    effect->shader()->gocMaterial()->setDiffuse(vlut::orange);
    effect->shader()->enable(vl::EN_DEPTH_TEST);

    // use a simple plane to render the ground
    vl::ref<vl::Geometry> geom = vlut::makeGrid(vl::vec3(0,0,0), side, side, 200, 200);
    geom->computeNormals();
    sceneManager()->tree()->addActor( geom.get(), effect.get(), NULL);
  }

  // returns a Geometry that renders a single quad
  vl::ref<vl::Geometry> generateQuad()
  {
    // geometry
    vl::ref<vl::Geometry> quad = new vl::Geometry;
    // quad vertices
    vl::ref<vl::ArrayFVec3> vert = new vl::ArrayFVec3;
    vert->resize( 4 );
    quad->setVertexArray(vert.get());
    vert->at(0) = vl::fvec3( -0.5f, -0.5f, 0.0f );
    vert->at(1) = vl::fvec3( +0.5f, -0.5f, 0.0f );
    vert->at(2) = vl::fvec3( +0.5f, +0.5f, 0.0f );
    vert->at(3) = vl::fvec3( -0.5f, +0.5f, 0.0f );
    // texture coords
    vl::ref<vl::ArrayFVec2> texc = new vl::ArrayFVec2;
    texc->resize( 4 );
    quad->setTexCoordArray(0,texc.get());
    texc->at(0) = vl::fvec2( 0.0f, 0.0f );
    texc->at(1) = vl::fvec2( 1.0f, 0.0f );
    texc->at(2) = vl::fvec2( 1.0f, 1.0f );
    texc->at(3) = vl::fvec2( 0.0f, 1.0f );
    // quad primitive
    quad->primitives()->push_back( new vl::DrawArrays(vl::PT_QUADS,0,4) );
    return quad;
  }

  // This function demonstrates how a billboard behaves when it is put under an animated transform hierarchy.
  // Note how the cube always faces the camera even if it follows its parent's rotation.
  void generateLunapark()
  {
    vl::ref<vl::Effect> effect = new vl::Effect;
    effect->shader()->setRenderState( new vl::Light(0) );
    effect->shader()->enable(vl::EN_BLEND);
    effect->shader()->enable(vl::EN_DEPTH_TEST);
    effect->shader()->enable(vl::EN_LIGHTING);

    vl::ref<vl::Geometry>  arm_g = vlut::makeCylinder(vl::vec3(0,0,0), 0.5f, 4.0f);
    arm_g->computeNormals();
    vl::ref<vl::Transform> arm1_t = new vl::Transform;
    vl::ref<vl::Transform> arm2_t = new vl::Transform;
    vl::VisualizationLibrary::rendering()->as<vl::Rendering>()->transform()->addChild(arm1_t.get());
    arm1_t->addChild(arm2_t.get());
    arm2_t->setLocalMatrix(vl::mat4::translation(0.0f,2.0f,0.0f) * vl::mat4::rotation(90,0,0,1) * vl::mat4::translation(0.0f,2.0f,0.0f));

    sceneManager()->tree()->addActor( arm_g.get(), effect.get(), arm1_t.get());
    sceneManager()->tree()->addActor( arm_g.get(), effect.get(), arm2_t.get());

    vl::ref<vl::Geometry> box = vlut::makeBox(vl::vec3(0,-0.75f,0), 1, 1, 1);
    box->computeNormals();

    // the billboard
    vl::ref<vl::Billboard> billboard = new vl::Billboard;
    // use an axis aligned billboard
    billboard->setType(vl::BT_AxisAlignedBillboard);
    // the axis is always in world coordinates
    billboard->setAxis(vl::vec3(0,1,0));
    // remember that "position" is relative to the billboard's parent's coordinates
    billboard->setPosition(0,2,0);
    // add the billboard to its transform parent
    arm2_t->addChild(billboard.get());
    // add the box actor
    sceneManager()->tree()->addActor( box.get(), effect.get(), billboard.get());

    // to be animated below
    mArm1Transform = arm1_t;
  }

  // animate the lunapark
  void run()
  {
    mArm1Transform->setLocalMatrix(
      vl::mat4::rotation(vl::Time::currentTime()*45,0,1,0) *
      vl::mat4::translation(0.0f,2.0f,0.0f)
    );
  }

protected:
  vl::ref<vl::Transform> mArm1Transform;
};

// Have fun!
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Grouped classes and functions

Visualization Library Reference Documentation

Grouped classes and functions

This are the most important Visualization Library classes and functions divided into groups.

Some items might appear in more than one group. Hovering with the mouse on the name of a class or function will display a tooltip with a brief description.

Math
  • vl::Real
  • vl::vec4, vl::vec3, vl::vec2
  • vl::dvec4, vl::dvec3, vl::dvec2
  • vl::fvec4, vl::fvec3, vl::fvec2
  • vl::ivec4, vl::ivec3, vl::ivec2
  • vl::uvec4, vl::uvec3, vl::uvec2
  • vl::svec4, vl::svec3, vl::svec2
  • vl::usvec4, vl::usvec3, vl::usvec2
  • vl::bvec4, vl::bvec3, vl::bvec2
  • vl::ubvec4, vl::ubvec3, vl::ubvec2
  • vl::mat4, vl::mat3, vl::mat2
  • vl::dmat4, vl::dmat3, vl::dmat2
  • vl::fmat4, vl::fmat3, vl::fmat2
  • vl::imat4, vl::imat3, vl::imat2
  • vl::umat4, vl::umat3, vl::umat2
  • vl::quat
  • vl::Sphere
  • vl::AABB
  • vl::RectI
  • vl::RectF

  • GLSLmath.hpp

Text manipulation and rendering
  • vl::String
  • vl::TextStream
  • vl::Say
  • vl::Log
  • vl::Text
  • vl::Font
  • vl::FontManager

Image
  • vl::loadImage()
  • vl::saveImage()
  • vl::Image
  • vl::Image::convertType()
  • vl::Image::convertFormat()
  • vl::Image::sample()
  • vl::Image::sampleLinear()
  • vl::Image::makeColorSpectrum()
  • vl::Image::subImage()

Input / Output
  • vl::ResourceDatabase
  • vl::LoadWriterManager
  • vl::ResourceLoadWriter
  • vl::LoadCallback
  • vl::WriteCallback
  • vl::LoadWriterDICOM
  • vl::LoadWriterPNG
  • vl::LoadWriterJPG
  • vl::LoadWriterTIFF
  • vl::LoadWriterDDS
  • vl::LoadWriterTGA
  • vl::LoadWriterBMP
  • vl::LoadWriterDAT
  • vl::LoadWriter3DS
  • vl::LoadWriterOBJ
  • vl::LoadWriterAC3D
  • vl::LoadWriterPLY
  • vl::LoadWriterSTL
  • vl::LoadWriterMD2
  • vl::loadResource()
  • vl::loadImage()

Virtual File System
  • vl::VisualizationLibrary::fileSystem()
  • vl::FileSystem
  • vl::VirtualDirectory
  • vl::DiskDirectory
  • vl::ZippedDirectory
  • vl::MemoryDirectory
  • vl::VirtualFile
  • vl::DiskFile
  • vl::ZippedFile
  • vl::MemoryFile
  • vl::GZipCodec
  • vl::loadResource()
  • vl::loadImage()

OpenGL Shading Language
  • vl::GLSLProgram
  • vl::GLSLVertexShader
  • vl::GLSLFragmentShader
  • vl::GLSLGeometryShader
  • vl::Uniform
  • vl::Shader::glslProgram()

Framebuffer Objects
  • vl::FBORenderTarget
  • vl::FBOAttachmentAbstract
    • vl::FBORenderbufferAttachment
      • vl::FBOColorBufferAttachment
      • vl::FBODepthBufferAttachment
      • vl::FBODepthStencilBufferAttachment
      • vl::FBOStencilBufferAttachment
    • vl::FBOTexture1DAttachment
    • vl::FBOTexture2DAttachment
    • vl::FBOTexture3DAttachment
    • vl::FBOTextureAttachment
    • vl::FBOTextureLayerAttachment
  • vl::BlitFramebuffer
  • vl::OpenGLContext::createFBORenderTarget()

Renderables
  • vl::Renderable
    • vl::Geometry
    • vl::BezierSurface
    • vl::Text
    • vl::DrawPixels
    • vl::Clear

Texturing
  • vl::Image
  • vl::Texture
  • vl::TexParameter
  • vl::TexEnv
  • vl::TexGen
  • vl::TextureMatrix
  • vl::TextureUnit
  • vl::CopyTexSubImage1D
  • vl::CopyTexSubImage2D
  • vl::CopyTexSubImage3D

Callback objects
  • vl::RenderingCallback
    • vl::BlitFramebuffer
    • vl::ReadPixels
    • vl::CopyTexSubImage1D
    • vl::CopyTexSubImage2D
    • vl::CopyTexSubImage3D
  • vl::ActorRenderingCallback
    • vl::DepthSortCallback
    • vl::MorphingCallback
    • vl::EdgeUpdateCallback
  • vl::LoadCallback
  • vl::WriteCallback

Rendering definition
  • vl::SceneManager
  • vl::Rendering
  • vl::Renderer
  • vl::Camera
  • vl::Viewport
  • vl::RenderTarget
  • vl::OpenGLContext
  • vl::OpenGLContextFormat
  • vl::OpenGLContext::renderTarget()
  • vl::Actor
  • vl::Effect
  • vl::Shader
  • vl::ShaderNode
  • vl::Transform
  • vl::Billboard
  • vl::Scissor

Scene managers and spatial partitioning
  • vl::SceneManager
    • vl::SceneManagerBVH
      • vl::SceneManagerActorTree
      • vl::SceneManagerActorKdTree
        • vl::Terrain
    • vl::SceneManagerPortals
    • vlVG::SceneManagerVectorGraphics
  • vl::ActorTree
  • vl::ActorKdTree

Geometry
  • vl::Geometry
  • vl::BezierSurface
  • vl::Tessellator
  • vl::Extrusion
  • vl::DoubleVertexRemover
  • vl::PolygonSimplifier
  • vl::TriangleStripGenerator
  • vl::Geometry::computeNormals()
  • vl::DrawArrays
  • vl::DrawElements
  • vl::VertexAttributeArray
  • vl::ArrayAbstract
  • vl::ArrayFVec4
  • vl::ArrayAbstract::computeBoundingSphere()
  • vl::ArrayAbstract::computeBoundingBox()
  • vl::ArrayAbstract::transform()
  • vl::ArrayAbstract::normalize()
  • vl::ArrayAbstract::vectorAsVec4()

Geometry primitives
  • vlut::makeIcosphere()
  • vlut::makeCylinder()
  • vlut::makeUVSphere()
  • vlut::makeTorus()
  • vlut::makeCone()
  • vlut::makePyramid()
  • vlut::makeBox()
  • vlut::makeGrid()
  • vlut::makeIcosahedron()
  • vlut::makePoints()
  • vlut::makeCircle()
  • vlut::makeCapsule()

Animation
  • vl::Time
  • vl::MorphingActor
  • vl::ActorRenderingCallback
  • vl::Interpolator
  • vl::LinearInterpolator
  • vl::CatmullRomInterpolator
  • vl::Shader::update()
  • vl::Actor::update()

User interaction
  • vl::UIEventListener
  • vl::OpenGLContext
  • vl::TrackballManipulator
  • vl::GhostCameraManipulator

Volume Rendering
  • vlVolume::MarchingCubes
  • vlVolume::SlicedVolume
  • vlVolume::VolumePlot

Rendering enhancement
  • vl::EdgeRenderer
  • vl::EdgeExtractor

Vector graphics
  • vlVG::VectorGraphics
  • vlVG::SceneManagerVectorGraphics

Molecule Visualization
  • vlMolecule::Molecule
  • vlMolecule::Atom
  • vlMolecule::Bond
  • vlMolecule::RingExtractor

GUI bindings
  • vlWin32::Win32Window
  • vlWin32::Win32Context
  • vlMFC::MFCWindow
  • vlWX::vlWXGLCanvas
  • vlQt4::Qt4Widget
  • vlSDL::SDLWindow
  • vlGLUT::GLUTWindow

Memory
  • vl::ref
  • vl::Object
  • vl::Buffer
  • vl::GLBufferObject
  • vl::ArrayAbstract
  • vl::Array

Shader render states
  • vl::Shader
  • vl::ShaderNode
  • vl::AlphaFunc, see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml
  • vl::BlendColor, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml
  • vl::BlendEquation, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml
  • vl::BlendFunc, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml
  • vl::ClipPlane, see also http://www.opengl.org/sdk/docs/man/xhtml/glClipPlane.xml
  • vl::ColorMask, see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml
  • vl::CullFace, see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml
  • vl::DepthFunc, see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml
  • vl::DepthMask, see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml
  • vl::DepthRange, see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml
  • vl::Fog, see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml
  • vl::FrontFace, see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml
  • vl::GLSLProgram
  • vl::Hint, see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml
  • vl::Light, see also http://www.opengl.org/sdk/docs/man/xhtml/glLight.xml
  • vl::LightModel, see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml
  • vl::LineStipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml
  • vl::LineWidth, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml
  • vl::LogicOp, see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml
  • vl::Material, see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml
  • vl::PixelTransfer, see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml
  • vl::PointParameter, see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml
  • vl::PointSize, see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml
  • vl::PolygonMode, see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml
  • vl::PolygonOffset, see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml
  • vl::PolygonStipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml
  • vl::SampleCoverage, see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml
  • vl::ShadeModel, see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml
  • vl::StencilFunc, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml
  • vl::StencilMask, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml
  • vl::StencilOp, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml
  • vl::TexEnv, see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml
  • vl::TexGen, see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml
  • vl::TextureMatrix
  • vl::TextureUnit
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Contributing to Visualization Library

Visualization Library Reference Documentation

Contributing to Visualization Library

There are several ways to become a contributor of Visualization Library:

  1. Developing new features or extending existing ones and contributing the source code back to Visualization Library.
  2. Testing Visualization Library's features, releases, build system etc.
  3. Writing documentation, articles, tutorials etc. about Visualization Library to be published as part of VL's own documentation or on third party websites.
  4. Inserting a link pointing to http://www.visualizationlibrary.com from your website or from your product pages.
  5. Sending pictures of your applications using Visualization Library.
  6. Donating content to be distributed with Visualization Library, such as glsl shaders, textures, models etc.
  7. Replying to user questions on Visualization Library forums.
  8. Becoming a Visualization Library evangelist!

Why contributing?
First of all because Visualization Library is your favourite 3D graphics library! :) Secondly, helping the development of Visualization Library ensures that the features you are interested in are well supported and tested. Third, substantial contributors are listed in the credits page and are rewarded with extra support, special discounts or even free professional licenses.

To have access to the latest releases of VL directly from our Subversion repository or for more information please contact info@visualizationlibrary.com.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Licensing

Visualization Library Reference Documentation

Licensing

Visualization Library is released under a dual licensing model:

  • For proprietary and commercial products you must to obtain a Professional Edition License.

  • For open source applications: by default Visualization Library is distributed under the GNU General Public License Version 3.

If you have any questions regarding the licensing terms contact info@visualizationlibrary.com.

If you are aware that an individual or organization is infringing Visualization Library's licensing terms you can report the issue contacting fraud@visualizationlibrary.com.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Professional Edition License (VPL)

Visualization Library Reference Documentation

Professional Edition License (VPL)

If you would like to develop proprietary applications using Visualization Library you need to subscribe to our Professional Edition License.

You need one license for each developer for each year of development. You can subscribe to a Professional Edition License for a flat annual fee.

Subscribe to a Visualization Library Professional Edition License Now!

Benefits of the Professional Edition License
  • Develop proprietary and commercial applications.
  • Develop an unlimited number of products.
  • One single license allows you to develop products for Windows, Linux and Mac OS X (using any compiler).
  • Freely update to any new version of Visualization Library (including major revisions) for 1 whole year.
  • Redistribution of binary runtimes and source code.
  • 1 month of prioritized email technical support.

Below you can find the complete text of Visualization Library's Professional Edition License agreement in various formats:

  • http://www.visualizationlibrary.com/Licenses/VLPEL-1.0.16.pdf
  • http://www.visualizationlibrary.com/Licenses/VLPEL-1.0.16.html
  • http://www.visualizationlibrary.com/Licenses/VLPEL-1.0.16.txt

If you have any questions please contact sales@visualizationlibrary.com

Visualization Library Venture Program
If you would like to obtain for free or for a reduced price a Professional Edition License you can subscribe to our Visualization Library Venture Program. In order to subscribe to this program you will be asked to develop or to actively participate in the development of a project that will eventually become a standard component of Visualizaton Library.

For more information please send an email to sales@visualizationlibrary.com

Academic Program
Individuals from Universities or Research Institutions can obtain a Professional Edition License with special discounts.

Students using Visualization Library for their BA, MA or Phd theses are encouraged to apply to Visualization Library's Academic or Venture Program.

For more information please send an email to sales@visualizationlibrary.com

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library Reference Documentation

                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    <program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Credits

Visualization Library Reference Documentation

Credits

Third party libraries used by Visualization Library
LIBRARY | WEBSITE
GLEW library | http://glew.sourceforge.net
FreeType library | http://www.freetype.org
zlib library | http://www.zlib.net
IJG's libjpeg | http://www.ijg.org
libpng library | http://www.libpng.org
libtiff library | http://www.libtiff.org
GDCM library | http://sourceforge.net/projects/gdcm

Developers and Contributors
Michele Bosi | Main developer and project lead.
Brent Fulgham | Mac OS X port, Cocoa and MFC bindings.
Colin Plumb | MD5 message-digest algorithm.
Tanguy Fautré | Triangle stripping algorithm.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Loading and Saving Resources Tutorial

Loading and Saving Resources Tutorial

To be done
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: 3D Maths Tutorial

3D Maths Tutorial

To be done
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Geometry Primitives Gallery

Geometry Primitives Gallery

To be done
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Text Rendering and Manipulation Tutorial

Text Rendering and Manipulation Tutorial

To be done
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:06 2009.


Visualization Library: Class List

  • Class List
  • Class Index
  • Class Hierarchy
  • Class Members

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
vl::A3DSLoader | Loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects
vl::A3DSMaterial | Material in a 3DS file
vl::A3DSMaterialFaceMapping | Material/face mapping in a 3DS file
vl::A3DSObject | Object in a 3DS file
vl::A3DSTexture | Texture in a 3DS file
vl::A3DSTriFace | Triangle in a 3DS file
vl::A3DSVertex | Vertex in a 3DS file
vl::AABB | Implements an axis-aligned bounding box using vl::Real precision
vl::Actor | Associates a Renderable object to an Effect and Transform
vl::ActorKdTree | ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree
vl::ActorRenderingCallback | Defines a callback object to be executed just before an Actor is rendered but after the render states are setup
vl::ActorTree | Implements a generic tree whose nodes contain Actor[s]
vl::ActorTreeAbstract | Implements the interface of a generic tree containing Actor[s] in its nodes
vl::AlphaFunc | Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information
vl::Array< vector_type, scalar_type, gl_size, gl_type > | The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject
vl::ArrayAbstract | Defines an abstract interface to conveniently manipulate data stored in a GLBufferObject
vl::BezierPatch | Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class
vl::BezierSurface | Implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch)
vl::Billboard | A Transform that aligns an Actor towards the camera
vl::BlendColor | Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information
vl::BlendEquation | Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information
vl::BlendFunc | Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information
vl::BlitFramebuffer | A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit
vl::Buffer | Implements a buffer whose storage is in local memory
vl::BufferedStream< Element_Type, Chunk_Size > | The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile
vl::Camera | Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered
vl::CatmullRomInterpolator< T > | The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation
vl::CatmullRomInterpolatorDouble | Interpolates double values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec2 | Interpolates vl::dvec2 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec3 | Interpolates vl::dvec3 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec4 | Interpolates vl::dvec4 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFloat | Interpolates float values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec2 | Interpolates vl::fvec2 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec3 | Interpolates vl::fvec3 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec4 | Interpolates vl::fvec4 values using a CatmullRomInterpolator
vl::Clear | Renderable used to clear the whole or a portion of the color, stencil or depth buffer
vl::ClipPlane | Wraps the OpenGL function glClipPlane()
vl::Collection< T > | Reference counted container that encapsulates the base functionalites of an std::vector<>
vl::ColorMask | Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information
vl::CopyTexSubImage | Wrapper class of the OpenGL function glCopyTexSubImage
vl::CopyTexSubImage1D | Wraps glCopyTexSubImage1D, see also CopyTexSubImage
vl::CopyTexSubImage2D | Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures
vl::CopyTexSubImage3D | Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures
vl::CRC32CheckSum | Computes the a CRC32 checksum of a given buffer or VirtualFile
vl::CullFace | Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information
vl::DepthFunc | Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information
vl::DepthMask | Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information
vl::DepthRange | Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information
vl::DepthSortCallback | Sorts the primitives of the Geometry object bound to the Actor in which the callback is installed
vl::DiskDirectory | A VirtualDirectory that operates on reguar disk directories
vl::DiskFile | A VirtualFile that operates on regular disk files
vl::DistanceLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera
vl::DoubleVertexRemover | Removes from a Geometry the vertices with the same attributes
vl::DrawArrays | Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information
vl::DrawElements< index_type, Tgltype, arr_type > | Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information
vl::DrawPixels | Wraps the OpenGL function glDrawPixels()
vl::DrawPixels::Pixels | Represents a bitmap to be drawn on the screen
vl::EdgeExtractor | Extracts the edges from one or more Geometry objects
vl::EdgeExtractor::Edge | A single edge as extracted from the EdgeExtractor class
vl::EdgeRenderer | Implements a special Renderer that automatically extracts and renders the edges of the objects in the scene
vl::EdgeUpdateCallback | Updates at every frame the edges of an Actor for the purpose of edge-enhancement
vl::Effect | Defines the sequence of Shader objects used to render an Actor
vl::EnableSet | A set of enables managed by Shader
vl::Extrusion | Generates a Geometry extruding a silhouette along a path
vl::FBOAttachmentAbstract | Abstract class that represents a framebuffer object attachment, i.e
vl::FBOColorBufferAttachment | A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBODepthBufferAttachment | A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBODepthStencilBufferAttachment | A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBORenderbufferAttachment | Abstract class that represents a framebuffer renderbuffer attachment, i.e
vl::FBORenderTarget | Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension
vl::FBOStencilBufferAttachment | A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture1DAttachment | A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture2DAttachment | A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture3DAttachment | A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTextureAttachment | A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTextureLayerAttachment | A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FileSystem | Manages multiple VirtualDirectory objects
vl::Fog | Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information
vl::Font | A font to be used with a Text renderable
vl::FontManager | Keeps a map associating a font path, size and smoothing flag to a Font object
vl::FrontFace | Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information
vl::Frustum | A set of planes defining a frustum used for culling purposes (frustum culling)
vl::Geometry | Renderable that implements a polygonal mesh made of polygons, lines and points
vl::GeometryLoadCallback | Defines a set of actions to be executed to a Geometry as soon as it is loaded
vl::GhostCameraManipulator | UIEventListener that controls the position and orientation of a Camera
vl::GLBufferObject | Buffer that can upload its data on the GPU memory
vl::GLSLFragmentShader | Wraps a GLSL fragment shader to be bound to a GLSL program
vl::GLSLGeometryShader | Wraps a GLSL geometry shader to be bound to a GLSL program
vl::GLSLProgram | Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders
vl::GLSLShader | Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader
vl::GLSLVertexShader | Wraps a GLSL vertex shader to be bound to a GLSL program
vl::Glyph | The Glyph associated to a character of a given Font
vl::GZipCodec | VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm
vl::Hint | Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information
vl::Image | Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps
vl::Interpolator | Abstract class for all the interpolators
vl::InterpolatorDouble | Abstract class that interpolates double values
vl::InterpolatorDVec2 | Abstract class that interpolates vl::dvec2 values
vl::InterpolatorDVec3 | Abstract class that interpolates vl::dvec3 values
vl::InterpolatorDVec4 | Abstract class that interpolates vl::dvec4 values
vl::InterpolatorFloat | Abstract class that interpolates float values
vl::InterpolatorFVec2 | Abstract class that interpolates vl::fvec2 values
vl::InterpolatorFVec3 | Abstract class that interpolates vl::fvec3 values
vl::InterpolatorFVec4 | Abstract class that interpolates vl::fvec4 values
vl::KeyValues | A set of key/value pairs used to store generic information
vl::Light | Wraps the OpenGL function glLight()
vl::LightModel | Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information
vl::LinearInterpolator< T > | The LinearInterpolator class is a template class that implements linear interpolation
vl::LinearInterpolatorDouble | Interpolates double values using a LinearInterpolator
vl::LinearInterpolatorDVec2 | Interpolates vl::dvec2 values using a LinearInterpolator
vl::LinearInterpolatorDVec3 | Interpolates vl::dvec3 values using a LinearInterpolator
vl::LinearInterpolatorDVec4 | Interpolates vl::dvec4 values using a LinearInterpolator
vl::LinearInterpolatorFloat | Interpolates float values using a LinearInterpolator
vl::LinearInterpolatorFVec2 | Interpolates vl::fvec2 values using a LinearInterpolator
vl::LinearInterpolatorFVec3 | Interpolates vl::fvec3 values using a LinearInterpolator
vl::LinearInterpolatorFVec4 | Interpolates vl::fvec4 values using a LinearInterpolator
vl::LineStipple | Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information
vl::LineWidth | Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information
vl::LoadCallback | Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback
vl::LoadWriter3DS | ResourceLoadWriter capable of reading 3DS files
vl::LoadWriterAC3D | ResourceLoadWriter capable of reading AC3D files
vl::LoadWriterBMP | ResourceLoadWriter capable of reading BMP files
vl::LoadWriterDAT | ResourceLoadWriter capable of reading DAT files
vl::LoadWriterDDS | ResourceLoadWriter capable of reading DDS files
vl::LoadWriterDICOM | ResourceLoadWriter capable of reading DICOM files
vl::LoadWriterJPG | ResourceLoadWriter capable of reading JPG files
vl::LoadWriterManager | Loads and writes resources using the registered ResourceLoadWriter objects
vl::LoadWriterMD2 | ResourceLoadWriter capable of reading MD2 files
vl::LoadWriterOBJ | ResourceLoadWriter capable of reading OBJ files
vl::LoadWriterPLY | ResourceLoadWriter capable of reading PLY files
vl::LoadWriterPNG | ResourceLoadWriter capable of reading PNG files
vl::LoadWriterSTL | ResourceLoadWriter capable of reading STL files
vl::LoadWriterTGA | ResourceLoadWriter capable of reading TGA files
vl::LoadWriterTIFF | ResourceLoadWriter capable of reading TIFF files
vl::LODEvaluator | Abstract class to compute the appropriate LOD of an Actor or Effect
vl::Log | Abstract base class used to generate logging data
vl::LogicOp | Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information
vl::Material | Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information
vl::Matrix2< scalar_type > | The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2
vl::Matrix3< scalar_type > | The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3
vl::Matrix4< scalar_type > | The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4
vl::MD5CheckSum | Computes the MD5 of a given buffer or VirtualFile
vl::MemoryDirectory | A VirtualDirectory to manipulate directories stored in memory
vl::MemoryFile | A VirtualFile to manipulate files stored in memory
vl::MorphingActor | Animates a Geometry by interpolating its position and normal array
vl::MorphingCallback | Used by MorphingActor to implement the morphing animation on the GPU
vl::Object | The base class for all the reference counted objects
vl::ObjLoader | Loads a Wavefront OBJ file
vl::ObjMaterial | Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader
vl::ObjMesh | Represents a Wavefront OBJ mesh. See also ObjLoader
vl::ObjTexture | Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader
vl::OpenGLContext | Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent
vl::OpenGLContextFormat | Encapsulates the settings of an OpenGL rendering context
vl::PixelLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen
vl::PixelTransfer | Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information
vl::Plane | Defines a plane using a normal and an origin
vl::PlyLoader | Loads a PLY file
vl::PlyLoader::PlyElement | Used by PlyLoader
vl::PlyLoader::PlyPropertyAbstract | Used by PlyLoader
vl::PlyLoader::PlyScalar | Used by PlyLoader
vl::PlyLoader::PlyScalarList | Used by PlyLoader
vl::PointParameter | Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information
vl::PointSize | Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information
vl::PolygonMode | Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information
vl::PolygonOffset | Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information
vl::PolygonSimplifier | Reduces the amount of polygons present in a Geometry using a quadric error metric
vl::PolygonSimplifier::QErr | The quadric error metric as defined by PolygonSimplifier
vl::PolygonSimplifier::Triangle | A Triangle as defined by PolygonSimplifier
vl::PolygonSimplifier::Vertex | A Vertex as defined by PolygonSimplifier
vl::PolygonStipple | Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information
vl::Portal | A planar convex polygon used to define the visibility from one Sector to another
vl::Primitives | This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays()
vl::quat | Implements a quaternion using vl::Real precision
vl::Ray | Defines a ray as an origin and direction using Real precision
vl::RayIntersection | The RayIntersection encapsulates all the information relative to a Ray/Actor intersection
vl::RayIntersectionGeometry | The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor
vl::RayIntersector | Used to detect the intersection points between a Ray and a set of Actor[s]
vl::ReadPixels | A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering
vl::Rect< T > | Implements the common functions of RectI and RectF
vl::RectF | 2D rectangular area using float precision
vl::RectI | 2D rectangular area using int precision
vl::ref< T > | The ref<> class is used to reference-count an Object
vl::Renderable | An abstract class that represents all the objects that can be rendered
vl::Renderer | Executes the actual rendering on the given RenderQueue
vl::Rendering | Collects all the information to perform the rendering of a scene
vl::RenderingAbstract | Implements the abstract rendering interface
vl::RenderingCallback | An abstract class used to perform operations at the end or at the beginning of a rendering
vl::RenderingTree | Organizes a set of renderings into a tree-like data structure
vl::RenderQueue | Collects a list of RenderToken objects to be sorted and rendered
vl::RenderQueueSorter | Abstract base class of all the algorithms used to sort a set of RenderToken
vl::RenderQueueSorterAggressive | Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer
vl::RenderQueueSorterBasic | Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer
vl::RenderQueueSorterByRenderable | Sorts the RenderTokens by their Renderable pointer
vl::RenderQueueSorterByShader | Sorts the RenderTokens by their Shader pointer
vl::RenderQueueSorterOcclusion | Implements a RenderQueueSorter to be used with occlusion culling
vl::RenderQueueSorterStandard | Implements the default RenderQueueSorter
vl::RenderState | Base class for most of the OpenGL render state wrapper classes
vl::RenderStateSet | A set of RenderState objects managed by a Shader
vl::RenderTarget | Defines an abstract 'surface' where OpenGL can render into
vl::RenderToken | Internally used by the rendering engine
vl::ResourceDatabase | And manipulates a set of resources
vl::ResourceLoadWriter | Abstract class used to implement read/write support for one or more resource types
vl::SampleCoverage | Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information
vl::Say | A simple String formatting class
vl::SayArg | Used internally by the Say class
vl::SceneManager | Base class for all the scene managers
vl::SceneManagerActorKdTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree
vl::SceneManagerActorTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree
vl::SceneManagerBVH< T > | The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers
vl::SceneManagerPortals | The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes
vl::Scissor | Wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information
vl::Sector | Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s]
vl::Sector::VisibilityCallback | A callback object called each time a Sector becomes visible through a Portal
vl::ShadeModel | Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information
vl::Shader | Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects
vl::ShaderNode | Used to conveniently manage complex hierarchies of Shader[s]
vl::ShaderSequence | A sequence of Shader objects each of which represent a rendering pass
vl::Sphere | Defines a sphere using a center and a radius using vl::Real precision
vl::StandardLog | Outputs the log messages on the stdout device and optionally also on a specified file
vl::StencilFunc | Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information
vl::StencilMask | Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information
vl::StencilOp | Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information
vl::STLLoader | Loads an STL file
vl::String | Implements an advanced UTF16 (Unicode BMP) string manipulation engine
vl::Terrain | Implements a ActorKdTree-based terrain scene manager
vl::Tessellator | Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library
vl::TexEnv | Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information
vl::TexGen | Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information
vl::TexParameter | Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information
vl::Text | A Renderable that renders text with a given Font
vl::TextStream | Can be used to conveniently read or parse utf8-encoded text files
vl::Texture | Wraps an OpenGL texture object
vl::Texture::SetupParams | The SetupParams function wraps all the parameters neede to crate a Texture
vl::TextureMatrix | Uses a 4x4 matrix to transform the texture coordinates of a texture unit
vl::TextureUnit | Associates a Texture object to an OpenGL texture unit
vl::Time | Simple class to be used as a timer and to retrieve the current time and date
vl::TrackballManipulator | This class lets you rotate a Camera or a Transform node using a vitual trackball
vl::Transform | Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor
vl::TriangleStripGenerator | Used to substitute lists of triangles or quads with triangle strips
vl::UIEventListener | Listens to the events emitted by an OpenGLContext
vl::Uniform | Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram
vl::UniformSet | A set of Uniform objects managed by a Shader
vl::Vector2< scalar_type > | The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2
vl::Vector3< scalar_type > | The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3
vl::Vector4< scalar_type > | The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4
vl::VertexAttributeArray | Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry
vl::VertexMapper | Generates a set of new vertices from the old one
vl::Viewport | Implements the viewport and clearing settings associated to a Camera
vl::VirtualDirectory | Abstact class representing a directory of files
vl::VirtualFile | An abstract class representing a file
vl::VisualizationLibrary | Used to initialize/shutdown VisualizationLibrary and to access important global data
vl::WriteCallback | Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback
vl::ZippedDirectory | A VirtualDirectory capable of reading files from a .zip file
vl::ZippedFile | A VirtualFile used to read a file contained in a .zip archive
vl::ZippedFileInfo | Collects the information about a ZippedFile
vlGLUT::GLUTWindow | Implements an OpenGLContext using the GLUT API
vlMFC::MFCWindow | MFC CWnd with the functionalities of a Win32Context
vlMolecule::Atom | Atom to be used with the Molecule class
vlMolecule::AtomInfo | Encapsulates information regarding an atom type
vlMolecule::Bond | Bond to be used with the Molecule class
vlMolecule::Molecule | Used to manage and render 3D molecular structures
vlMolecule::RingExtractor | Traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection
vlQt4::Qt4Widget | Implements an OpenGLContext using the Trolltech's Qt4 API
vlSDL::SDLWindow | Implements an OpenGLContext using the SDL API
vlut::Applet | Utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline
vlVG::SceneManagerVectorGraphics | SceneManager that contains VectorGraphics objects
vlVG::VectorGraphics | Used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics
vlVolume::MarchingCubes | An efficient implementation of the Marching Cubes algorithm
vlVolume::SlicedVolume | An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices
vlVolume::Volume | Defines the volume data to be used with a MarchingCube object
vlVolume::VolumeInfo | Defines the volume parameters to be used with a MarchingCube and Volume object
vlVolume::VolumePlot | Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm
vlVolume::VolumePlot::Function | A function to be used with VolumePlot
vlWin32::Win32Context | Implements an OpenGLContext using the Win32 API
vlWin32::Win32Window | Win32Context that can be used as a top or child window
vlWX::vlWXGLCanvas | Implements a vl::OpenGLContext using the wxWidgets library
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: vl::A3DSLoader Class Reference

  • Class Hierarchy
  • Class Members
vl::A3DSLoader

vl::A3DSLoader Class Reference

The A3DSLoader class loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects. More...

#include <vl3DS.hpp>

List of all members.

Public Member Functions

A3DSLoader ()
bool | parse3DS (VirtualFile *file)

Public Attributes

std::vector< A3DSObject > | mObjects
std::vector< A3DSMaterial > | mMaterials

Protected Member Functions

fvec3 readVec3 ()
fvec3 readColByte3 ()
fvec3 readColFloat3 ()
String readLine ()
float | readWordPercent ()
float | readFloatPercent ()
void | readChunk ()
bool | skipChunk ()
void | read0x3D3D ()
fvec3 readColChunk ()
float | readPercentChunk ()
void | read0xAFFF ()
A3DSTexture readMapChunk ()
void | read0x4000 ()
void | read0x4100 ()

Protected Attributes

VirtualFile * mInputFile
unsigned short | mChunkId
unsigned int | mChunkLen
bool | mCorrupted

Detailed Description

The A3DSLoader class loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects.

Constructor & Destructor Documentation

A3DSLoader::A3DSLoader ( )

Member Function Documentation

bool A3DSLoader::parse3DS ( VirtualFile * file )

fvec3 A3DSLoader::readVec3 ( ) [protected]

fvec3 A3DSLoader::readColByte3 ( ) [protected]

fvec3 A3DSLoader::readColFloat3 ( ) [protected]

String A3DSLoader::readLine ( ) [protected]

float A3DSLoader::readWordPercent ( ) [protected]

float A3DSLoader::readFloatPercent ( ) [protected]

void A3DSLoader::readChunk ( ) [protected]

bool A3DSLoader::skipChunk ( ) [protected]

void A3DSLoader::read0x3D3D ( ) [protected]

fvec3 A3DSLoader::readColChunk ( ) [protected]

float A3DSLoader::readPercentChunk ( ) [protected]

void A3DSLoader::read0xAFFF ( ) [protected]

A3DSTexture A3DSLoader::readMapChunk ( ) [protected]

void A3DSLoader::read0x4000 ( ) [protected]

void A3DSLoader::read0x4100 ( ) [protected]

Member Data Documentation

std::vector<A3DSObject> vl::A3DSLoader::mObjects

std::vector<A3DSMaterial> vl::A3DSLoader::mMaterials

VirtualFile* vl::A3DSLoader::mInputFile [protected]

unsigned short vl::A3DSLoader::mChunkId [protected]

unsigned int vl::A3DSLoader::mChunkLen [protected]

bool vl::A3DSLoader::mCorrupted [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSMaterial Class Reference

vl::A3DSMaterial

vl::A3DSMaterial Class Reference

The A3DSMaterial class represents a material in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Member Functions

A3DSMaterial ()

Public Attributes

String mMaterialName
fvec3 mAmbient
fvec3 mDiffuse
fvec3 mSpecular
float | mShininess
float | mShininessStrength
float | mTransparency
bool | mDoubleSided
A3DSTexture mTexture1
A3DSTexture mTexture2

Detailed Description

The A3DSMaterial class represents a material in a 3DS file.

Constructor & Destructor Documentation

vl::A3DSMaterial::A3DSMaterial ( ) [inline]

Member Data Documentation

String vl::A3DSMaterial::mMaterialName

fvec3 vl::A3DSMaterial::mAmbient

fvec3 vl::A3DSMaterial::mDiffuse

fvec3 vl::A3DSMaterial::mSpecular

float vl::A3DSMaterial::mShininess

float vl::A3DSMaterial::mShininessStrength

float vl::A3DSMaterial::mTransparency

bool vl::A3DSMaterial::mDoubleSided

A3DSTexture vl::A3DSMaterial::mTexture1

A3DSTexture vl::A3DSMaterial::mTexture2

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSMaterialFaceMapping Class Reference

vl::A3DSMaterialFaceMapping

vl::A3DSMaterialFaceMapping Class Reference

The A3DSMaterialFaceMapping class represents the material/face mapping in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Attributes

String mMaterialName
std::vector< unsigned short > mMappedFace

Detailed Description

The A3DSMaterialFaceMapping class represents the material/face mapping in a 3DS file.

Member Data Documentation

String vl::A3DSMaterialFaceMapping::mMaterialName

std::vector<unsigned short> vl::A3DSMaterialFaceMapping::mMappedFace

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSObject Class Reference

vl::A3DSObject

vl::A3DSObject Class Reference

The A3DSObject class represents an object in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Attributes

String mMaterialName
std::vector< A3DSVertex > | mVertices
std::vector< A3DSTriFace > | mFaceList
std::vector
< A3DSMaterialFaceMapping > 		mMatFaceMap
fmat4 mCoordSystem
fvec3 mPivotPoint

Detailed Description

The A3DSObject class represents an object in a 3DS file.

Member Data Documentation

String vl::A3DSObject::mMaterialName

std::vector<A3DSVertex> vl::A3DSObject::mVertices

std::vector<A3DSTriFace> vl::A3DSObject::mFaceList

std::vector<A3DSMaterialFaceMapping> vl::A3DSObject::mMatFaceMap

fmat4 vl::A3DSObject::mCoordSystem

fvec3 vl::A3DSObject::mPivotPoint

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSTexture Class Reference

vl::A3DSTexture

vl::A3DSTexture Class Reference

The A3DSTexture class represents a texture in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Member Functions

A3DSTexture ()

Public Attributes

String mFileName
float | mUScale
float | mVScale
float | mUOffset
float | mVOffset
float | mRotation
bool | mOpt_tile
bool | mOpt_decal
bool | mOpt_mirror
bool | mOpt_negative
bool | mOpt_summed_area
bool | mOpt_use_alpha
bool | mOpt_one_channel_tint
bool | mOpt_ignore_alpha
bool | mOpt_rgb_tint

Detailed Description

The A3DSTexture class represents a texture in a 3DS file.

Constructor & Destructor Documentation

vl::A3DSTexture::A3DSTexture ( ) [inline]

Member Data Documentation

String vl::A3DSTexture::mFileName

float vl::A3DSTexture::mUScale

float vl::A3DSTexture::mVScale

float vl::A3DSTexture::mUOffset

float vl::A3DSTexture::mVOffset

float vl::A3DSTexture::mRotation

bool vl::A3DSTexture::mOpt_tile

bool vl::A3DSTexture::mOpt_decal

bool vl::A3DSTexture::mOpt_mirror

bool vl::A3DSTexture::mOpt_negative

bool vl::A3DSTexture::mOpt_summed_area

bool vl::A3DSTexture::mOpt_use_alpha

bool vl::A3DSTexture::mOpt_one_channel_tint

bool vl::A3DSTexture::mOpt_ignore_alpha

bool vl::A3DSTexture::mOpt_rgb_tint

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSTriFace Class Reference

vl::A3DSTriFace

vl::A3DSTriFace Class Reference

The A3DSTriFace class represents a triangle in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Member Functions

A3DSTriFace ()

Public Attributes

unsigned short | mA
unsigned short | mB
unsigned short | mC
unsigned short | mFlags
unsigned int | mSmoothingGroup
int | mMaterialIndex

Detailed Description

The A3DSTriFace class represents a triangle in a 3DS file.

Constructor & Destructor Documentation

vl::A3DSTriFace::A3DSTriFace ( ) [inline]

Member Data Documentation

unsigned short vl::A3DSTriFace::mA

unsigned short vl::A3DSTriFace::mB

unsigned short vl::A3DSTriFace::mC

unsigned short vl::A3DSTriFace::mFlags

unsigned int vl::A3DSTriFace::mSmoothingGroup

int vl::A3DSTriFace::mMaterialIndex

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::A3DSVertex Class Reference

vl::A3DSVertex

vl::A3DSVertex Class Reference

The A3DSVertex class represents a vertex in a 3DS file. More...

#include <vl3DS.hpp>

List of all members.

Public Member Functions

A3DSVertex ()
bool | operator< (const A3DSVertex &other) const

Public Attributes

fvec3 mPos
fvec2 mUV
unsigned int | mSmoothingGroup
int | mIndex

Detailed Description

The A3DSVertex class represents a vertex in a 3DS file.

Constructor & Destructor Documentation

vl::A3DSVertex::A3DSVertex ( ) [inline]

Member Function Documentation

bool vl::A3DSVertex::operator< ( const A3DSVertex & other ) const [inline]

Member Data Documentation

fvec3 vl::A3DSVertex::mPos

fvec2 vl::A3DSVertex::mUV

unsigned int vl::A3DSVertex::mSmoothingGroup

int vl::A3DSVertex::mIndex

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::AABB Class Reference

vl::AABB

vl::AABB Class Reference

The AABB class implements an axis-aligned bounding box using vl::Real precision. More...

#include <AABB.hpp>

List of all members.

Public Member Functions

AABB ()
AABB (const vec3 &center, Real radius)
AABB (const vec3 &pt1, const vec3 &pt2, Real displace=0)
void | setNull ()
bool | isNull () const
bool | isPoint () const
void | enlarge (Real displace)
void | addPoint (const vec3 &v, Real radius)
bool | intersects (const AABB &bb) const
vec3 | clip (const vec3 &v, bool clipx=true, bool clipy=true, bool clipz=true) const
bool | isInside (const vec3 &v, bool clipx, bool clipy, bool clipz) const
bool | isInside (const vec3 &v) const
Real | height () const
Real | width () const
Real | depth () const
AABB | operator+ (const AABB &aabb) const
const AABB & | operator+= (const AABB &other)
AABB | operator+ (const vec3 &p)
const AABB & | operator+= (const vec3 &p)
vec3 | center () const
Real | area () const
Real | longestSideLength () const
void | addPoint (const vec3 &v)
void | transformed (AABB &aabb, const mat4 &mat) const
AABB | transformed (const mat4 &mat) const
const vec3 & | minCorner () const
const vec3 & | maxCorner () const
void | setMinCorner (Real x, Real y, Real z)
void | setMinCorner (const vec3 &v)
void | setMaxCorner (Real x, Real y, Real z)
void | setMaxCorner (const vec3 &v)
Real | volume () const

Protected Attributes

vec3 mMin
vec3 mMax

Detailed Description

The AABB class implements an axis-aligned bounding box using vl::Real precision.

Constructor & Destructor Documentation

AABB::AABB ( )

AABB::AABB | ( | const vec3 & | center,
 |  | Real | radius
 | ) |  |

AABB::AABB | ( | const vec3 & | pt1,
 |  | const vec3 & | pt2,
 |  | Real | displace = 0
 | ) |  |

Member Function Documentation

void vl::AABB::setNull ( ) [inline]

bool vl::AABB::isNull ( ) const [inline]

bool vl::AABB::isPoint ( ) const [inline]

void AABB::enlarge ( Real displace )

void AABB::addPoint | ( | const vec3 & | v,
 |  | Real | radius
 | ) |  |

bool AABB::intersects ( const AABB & bb ) const

vec3 AABB::clip | ( | const vec3 & | v,
 |  | bool | clipx = true,
 |  | bool | clipy = true,
 |  | bool | clipz = true |
 | ) |  |  | const

bool AABB::isInside | ( | const vec3 & | v,
 |  | bool | clipx,
 |  | bool | clipy,
 |  | bool | clipz |
 | ) |  |  | const

bool AABB::isInside ( const vec3 & v ) const

Real AABB::height ( ) const

Real AABB::width ( ) const

Real AABB::depth ( ) const

AABB AABB::operator+ ( const AABB & aabb ) const

const AABB& vl::AABB::operator+= ( const AABB & other ) [inline]

AABB vl::AABB::operator+ ( const vec3 & p ) [inline]

const AABB& vl::AABB::operator+= ( const vec3 & p ) [inline]

vec3 AABB::center ( ) const

Real vl::AABB::area ( ) const [inline]

Real vl::AABB::longestSideLength ( ) const [inline]

void vl::AABB::addPoint ( const vec3 & v ) [inline]

void vl::AABB::transformed | ( | AABB & | aabb,
 |  | const mat4 & | mat |
 | ) |  |  | const [inline]

AABB vl::AABB::transformed ( const mat4 & mat ) const [inline]

const vec3& vl::AABB::minCorner ( ) const [inline]

const vec3& vl::AABB::maxCorner ( ) const [inline]

void vl::AABB::setMinCorner | ( | Real | x,
 |  | Real | y,
 |  | Real | z |
 | ) |  |  | [inline]

void vl::AABB::setMinCorner ( const vec3 & v ) [inline]

void vl::AABB::setMaxCorner | ( | Real | x,
 |  | Real | y,
 |  | Real | z |
 | ) |  |  | [inline]

void vl::AABB::setMaxCorner ( const vec3 & v ) [inline]

Real vl::AABB::volume ( ) const [inline]

Member Data Documentation

vec3 vl::AABB::mMin [protected]

vec3 vl::AABB::mMax [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: vl::Actor Class Reference

vl::Actor

vl::Actor Class Reference

Associates a Renderable object to an Effect and Transform. More...

#include <Actor.hpp>

Inheritance diagram for vl::Actor:

vl::Object vl::MorphingActor vlVolume::SlicedVolume

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Actor (Renderable *renderable=NULL, Effect *effect=NULL, Transform *transform=NULL, int block=0, int rank=0)
Constructor.
virtual | ~Actor ()
Destructor.
ref< Renderable > & | lod (int lod_index)
Returns the Renderable object representing the LOD level specifed by index.
const ref< Renderable > & | lod (int lod_index) const
Returns the Renderable object representing the LOD level specifed by index.
void | setLODs (Renderable *lod0, Renderable *lod1=NULL, Renderable *lod2=NULL, Renderable *lod3=NULL, Renderable *lod4=NULL, Renderable *lod5=NULL)
Utility function to assign one or more Renderable[s] to one or more LOD levels.
void | setTransform (Transform *transform)
Binds a Transform to an Actor.
Transform * transform ()
Returns the Transform bound tho an Actor.
const Transform * | transform () const
Returns the Transform bound tho an Actor.
void | setEffect (Effect *effect)
Binds an Effect to an Actor.
Effect * effect ()
Returns the Effect bound to an Actor.
const Effect * | effect () const
Returns the Effect bound to an Actor.
const Sphere & | boundingSphere () const
Returns the bounding sphere that contains this Actor taking into consideration also its Transform.
const AABB & | boundingBox () const
Returns the bounding box that contains this Actor taking into consideration also its Transform.
void | computeBounds ()
Computes the bounding box and bounding sphere of an Actor taking into consideration also its Transform.
void | setRenderRank (int rank)
Modifies the rendering rank of an Actor.
void | setRenderBlock (int block)
Modifies the rendering block of an Actor.
int | renderRank () const
Returns the rendering rank of an Actor.
int | renderBlock () const
Returns the rendering block of an Actor.
void | setLODEvaluator (LODEvaluator *lod_evaluator)
Installs the LODEvaluator used to compute the current LOD at rendering time.
LODEvaluator * lodEvaluator ()
Returns the installed LODEvaluator (if any) or NULL.
const LODEvaluator * | lodEvaluator () const
Returns the installed LODEvaluator (if any) or NULL.
int | evaluateLOD (Camera *camera)
virtual void | update (int, Camera *, Real)
Virtual function used to update or animate an Actor during the rendering.
void | setLastUpdateTime (Real time)
For internal use only.
Real | lastUpdateTime () const
For internal use only.
void | setEnableMask (unsigned int mask)
The enable mask of an Actor defines whether the actor should be rendered or not depending on the Rendering::enableMask().
unsigned int | enableMask () const
The enable mask of an Actor defines whether the actor should be rendered or not depending on the Rendering::enableMask().
void | setUniform (Uniform *uniform)
Equivalent to uniformSet()->setUniform(uniform).
const std::vector< ref
< Uniform > > & 		uniforms () const
Equivalent to uniformSet()->uniforms().
void | eraseUniform (const std::string &name)
Equivalent to uniformSet()->eraseUniform(name).
void | eraseUniform (const Uniform *uniform)
Equivalent to uniformSet()->eraseUniform(uniform).
void | eraseAllUniforms ()
Equivalent to uniformSet()->eraseAllUniforms().
Uniform * | gocUniform (const std::string &name)
Equivalent to uniformSet()->getUniform(name, get_mode).
Uniform * | getUniform (const std::string &name)
Equivalent to uniformSet()->getUniform(name, get_mode).
const Uniform * | getUniform (const std::string &name) const
Equivalent to uniformSet()->getUniform(name, get_mode).
void | setUniformSet (UniformSet *uniforms)
Installs a new UniformSet.
UniformSet * | uniformSet () const
Returns the UniformSet installed.
const Collection
< ActorRenderingCallback > * 		renderingCallbacks () const
Returns the list of ActorRenderingCallback bound to an Actor.
Collection
< ActorRenderingCallback > * 		renderingCallbacks ()
Returns the list of ActorRenderingCallback bound to an Actor.
void | executeRenderingCallbacks (const Camera *camera, Renderable *renderable, const Shader *shader, int pass)
Calls all the ActorRenderingCallback installed on this Actor.
void | setScissor (Scissor *scissor)
Sets the Scissor to be used when rendering an Actor.
const Scissor * | scissor () const
Returns the Scissor used when rendering an Actor.
Scissor * scissor ()
Returns the Scissor used when rendering an Actor.
void | setOccludee (bool is_occludee)
If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if occlusion culling is enabled) otherwise the Actor will always be rendered with no occlusion test even when occlusion culling is enabled.
bool | isOccludee () const
If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if occlusion culling is enabled) otherwise the Actor will always be rendered with no occlusion test even when occlusion culling is enabled.
void | createOcclusionQuery ()
For internal use only.
void | deleteOcclusionQuery ()
For internal use only.
GLuint | occlusionQuery () const
For internal use only.
void | setOcclusionQueryTick (unsigned tick)
For internal use only.
unsigned | occlusionQueryTick () const
For internal use only.

Protected Attributes

AABB mAABB
Sphere mSphere
Real mLastUpdateTime
ref< Effect > mEffect
ref< Renderable > | mRenderables [VL_MAX_ACTOR_LOD]
ref< Transform > mTransform
ref< LODEvaluator > mLODEvaluator
ref< UniformSet > mUniformSet
ref< Scissor > mScissor
Collection
< ActorRenderingCallback > 		mRenderingCallbacks
int | mRenderBlock
int | mRenderRank
long long | mTransformUpdateTick
long long | mBoundsUpdateTick
unsigned int | mEnableMask
GLuint | mOcclusionQuery
bool | mIsOccludee
unsigned | mOcclusionQueryTick

Detailed Description

Associates a Renderable object to an Effect and Transform.

An Actor can associate one Renderable for each LOD (level of detail) using the lods() function. The rendering order of an Actor is defined by its rendering rank, and block, see setRenderRank() and setRenderBlock() for the details.

Note:
  • The same Renderable can be bound to more than one Actor at the same time
  • The same Effect can be bound to more than one Actor at the same time
  • The same Transform can be bound to more than one Actor at the same time

Remarks:
An Actor must always have a Renderable and Effect bound. If no Transform is specified the Renderable will be rendered as if it had an identity matrix transformation.
Uniforms
The Uniforms defined in the Actor and the ones defined in the Shader must not overlap, that is, an Actor must not define Uniforms that are also present in the Shader's Uniform and vice versa.

See also:
Transform, Effect, Renderable, Geometry

Constructor & Destructor Documentation

vl::Actor::Actor | ( | Renderable * | renderable = NULL,
 |  | Effect * | effect = NULL,
 |  | Transform * | transform = NULL,
 |  | int | block = 0,
 |  | int | rank = 0 |
 | ) |  |  | [inline]

Constructor.

Parameters:
renderable | A Renderable defining the Actor's LOD level #0
effect | The Effect to be used by the Actor
transform | The Transform to be used by the Actor
block | The rendering block to which the Actor belongs
rank | The rendering rank to which the Actor belongs

Actor::~Actor ( ) [virtual]

Destructor.

Member Function Documentation

virtual const char* vl::Actor::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::MorphingActor.

ref<Renderable>& vl::Actor::lod ( int lod_index ) [inline]

Returns the Renderable object representing the LOD level specifed by index.

const ref<Renderable>& vl::Actor::lod ( int lod_index ) const [inline]

Returns the Renderable object representing the LOD level specifed by index.

void vl::Actor::setLODs | ( | Renderable * | lod0,
 |  | Renderable * | lod1 = NULL,
 |  | Renderable * | lod2 = NULL,
 |  | Renderable * | lod3 = NULL,
 |  | Renderable * | lod4 = NULL,
 |  | Renderable * | lod5 = NULL |
 | ) |  |  | [inline]

Utility function to assign one or more Renderable[s] to one or more LOD levels.

void vl::Actor::setTransform ( Transform * transform ) [inline]

Binds a Transform to an Actor.

Transform* vl::Actor::transform ( ) [inline]

Returns the Transform bound tho an Actor.

const Transform* vl::Actor::transform ( ) const [inline]

Returns the Transform bound tho an Actor.

void vl::Actor::setEffect ( Effect * effect ) [inline]

Binds an Effect to an Actor.

Effect* vl::Actor::effect ( ) [inline]

Returns the Effect bound to an Actor.

Reimplemented in vlVolume::SlicedVolume.

const Effect* vl::Actor::effect ( ) const [inline]

Returns the Effect bound to an Actor.

Reimplemented in vlVolume::SlicedVolume.

const Sphere& vl::Actor::boundingSphere ( ) const [inline]

Returns the bounding sphere that contains this Actor taking into consideration also its Transform.

const AABB& vl::Actor::boundingBox ( ) const [inline]

Returns the bounding box that contains this Actor taking into consideration also its Transform.

void Actor::computeBounds ( )

Computes the bounding box and bounding sphere of an Actor taking into consideration also its Transform.

void vl::Actor::setRenderRank ( int rank ) [inline]

Modifies the rendering rank of an Actor.

The rendering rank affects the order in which an Actor is rendered, the greater the rank the later the Actor is rendered. The default render rank is zero.

To know more about rendering order please see Rendering Order.

See also:
setRenderBlock(), Effect::setRenderRank()

void vl::Actor::setRenderBlock ( int block ) [inline]

Modifies the rendering block of an Actor.

The rendering block affects the order in which an Actor is rendered, the greater the block the later the Actor is rendered. The default render block is zero.

To know more about rendering order please see Rendering Order.

See also:
setRenderRank(), Effect::setRenderRank()

int vl::Actor::renderRank ( ) const [inline]

Returns the rendering rank of an Actor.

int vl::Actor::renderBlock ( ) const [inline]

Returns the rendering block of an Actor.

void vl::Actor::setLODEvaluator ( LODEvaluator * lod_evaluator ) [inline]

Installs the LODEvaluator used to compute the current LOD at rendering time.

LODEvaluator* vl::Actor::lodEvaluator ( ) [inline]

Returns the installed LODEvaluator (if any) or NULL.

const LODEvaluator* vl::Actor::lodEvaluator ( ) const [inline]

Returns the installed LODEvaluator (if any) or NULL.

int Actor::evaluateLOD ( Camera * camera )

virtual void vl::Actor::update | ( | int | ,
 |  | Camera * | ,
 |  | Real |  |
 | ) |  |  | [inline, virtual]

Virtual function used to update or animate an Actor during the rendering.

Parameters:
lod | the LOD (level of detail) currently selected for the rendering.
camera | the camera used for the current rendering.
cur_t | the current animation time.
Note:
  • is called after the actor resulted to be visible
  • is called only once per frame
  • is called before setting up the rendering states
See also:
  • ActorRenderingCallback
  • renderingCallbacks()

Reimplemented in vl::MorphingActor, and vlVolume::SlicedVolume.

void vl::Actor::setLastUpdateTime ( Real time ) [inline]

For internal use only.

Real vl::Actor::lastUpdateTime ( ) const [inline]

For internal use only.

void vl::Actor::setEnableMask ( unsigned int mask ) [inline]

The enable mask of an Actor defines whether the actor should be rendered or not depending on the Rendering::enableMask().

unsigned int vl::Actor::enableMask ( ) const [inline]

The enable mask of an Actor defines whether the actor should be rendered or not depending on the Rendering::enableMask().

void vl::Actor::setUniform ( Uniform * uniform ) [inline]

Equivalent to uniformSet()->setUniform(uniform).

Remarks:
This function performs a 'setUniformSet(new UniformSet)' if uniformSet() is NULL.

const std::vector< ref<Uniform> >& vl::Actor::uniforms ( ) const [inline]

Equivalent to uniformSet()->uniforms().

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

void vl::Actor::eraseUniform ( const std::string & name ) [inline]

Equivalent to uniformSet()->eraseUniform(name).

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

void vl::Actor::eraseUniform ( const Uniform * uniform ) [inline]

Equivalent to uniformSet()->eraseUniform(uniform).

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

void vl::Actor::eraseAllUniforms ( ) [inline]

Equivalent to uniformSet()->eraseAllUniforms().

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

Uniform* vl::Actor::gocUniform ( const std::string & name ) [inline]

Equivalent to uniformSet()->getUniform(name, get_mode).

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

Uniform* vl::Actor::getUniform ( const std::string & name ) [inline]

Equivalent to uniformSet()->getUniform(name, get_mode).

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

const Uniform* vl::Actor::getUniform ( const std::string & name ) const [inline]

Equivalent to uniformSet()->getUniform(name, get_mode).

Remarks:
You must install a UniformSet with setUniformSet() before calling this function.

void vl::Actor::setUniformSet ( UniformSet * uniforms ) [inline]

Installs a new UniformSet.

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

UniformSet* vl::Actor::uniformSet ( ) const [inline]

Returns the UniformSet installed.

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

const Collection<ActorRenderingCallback>* vl::Actor::renderingCallbacks ( ) const [inline]

Returns the list of ActorRenderingCallback bound to an Actor.

Collection<ActorRenderingCallback>* vl::Actor::renderingCallbacks ( ) [inline]

Returns the list of ActorRenderingCallback bound to an Actor.

void vl::Actor::executeRenderingCallbacks | ( | const Camera * | camera,
 |  | Renderable * | renderable,
 |  | const Shader * | shader,
 |  | int | pass |
 | ) |  |  | [inline]

Calls all the ActorRenderingCallback installed on this Actor.

void vl::Actor::setScissor ( Scissor * scissor ) [inline]

Sets the Scissor to be used when rendering an Actor.

Note:
You can also define a Scissor on a per-Shader basis using the function Shader::setScissor(). In case both the Shader's and the Actor's Scissor are defined the Actor's Scissor is used.
See also:
  • Scissor
  • Shader::setScissor()

const Scissor* vl::Actor::scissor ( ) const [inline]

Returns the Scissor used when rendering an Actor.

See also:
  • Scissor
  • Actor::setScissor()
  • Shader::setScissor()

Scissor* vl::Actor::scissor ( ) [inline]

Returns the Scissor used when rendering an Actor.

See also:
  • Scissor
  • Actor::setScissor()
  • Shader::setScissor()

void vl::Actor::setOccludee ( bool is_occludee ) [inline]

If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if occlusion culling is enabled) otherwise the Actor will always be rendered with no occlusion test even when occlusion culling is enabled.

bool vl::Actor::isOccludee ( ) const [inline]

If is_occludee equals true an occlusion test will be performed before the rendering of the Actor (if occlusion culling is enabled) otherwise the Actor will always be rendered with no occlusion test even when occlusion culling is enabled.

void Actor::createOcclusionQuery ( )

For internal use only.

Creates the occlusion query object name bound this Actor using the OpenGL function glGenQueries().

void Actor::deleteOcclusionQuery ( )

For internal use only.

Deletes the occlusion query object name using the OpenGL function glDeleteQueries().

GLuint vl::Actor::occlusionQuery ( ) const [inline]

For internal use only.

Returns the occlusion query object name bound this Actor as by the OpenGL function glGenQueries(). Returns 0 if no query object name has been created yet.

void vl::Actor::setOcclusionQueryTick ( unsigned tick ) [inline]

For internal use only.

unsigned vl::Actor::occlusionQueryTick ( ) const [inline]

For internal use only.

Member Data Documentation

AABB vl::Actor::mAABB [protected]

Sphere vl::Actor::mSphere [protected]

Real vl::Actor::mLastUpdateTime [protected]

ref<Effect> vl::Actor::mEffect [protected]

Reimplemented in vlVolume::SlicedVolume.

ref<Renderable> vl::Actor::mRenderables[VL_MAX_ACTOR_LOD] [protected]

ref<Transform> vl::Actor::mTransform [protected]

ref<LODEvaluator> vl::Actor::mLODEvaluator [protected]

ref<UniformSet> vl::Actor::mUniformSet [protected]

ref<Scissor> vl::Actor::mScissor [protected]

Collection<ActorRenderingCallback> vl::Actor::mRenderingCallbacks [protected]

int vl::Actor::mRenderBlock [protected]

int vl::Actor::mRenderRank [protected]

long long vl::Actor::mTransformUpdateTick [protected]

long long vl::Actor::mBoundsUpdateTick [protected]

unsigned int vl::Actor::mEnableMask [protected]

GLuint vl::Actor::mOcclusionQuery [protected]

bool vl::Actor::mIsOccludee [protected]

unsigned vl::Actor::mOcclusionQueryTick [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ActorKdTree Class Reference

vl::ActorKdTree

vl::ActorKdTree Class Reference

ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree. More...

#include <ActorKdTree.hpp>

Inheritance diagram for vl::ActorKdTree:

vl::ActorTreeAbstract vl::Object

List of all members.

Public Member Functions

ActorKdTree ()
virtual const char * | className ()
Returns the name of the class.
virtual int | childrenCount () const
Returns the number of child nodes of an ActorTreeAbstract node.
virtual ActorTreeAbstract * | child (int i)
Returns the i-th child node of an ActorTreeAbstract node.
virtual const ActorTreeAbstract * | child (int i) const
Returns the i-th child node of an ActorTreeAbstract node.
void | compileKdTree (ActorCollection &actors, int max_depth=100, float minimum_volume=0)
Builds a ActorKdTree with the given list of Actor[s].
void | compileKdTree (int max_depth=100, float minimum_volume=0)
Builds a ActorKdTree with the Actor[s] contained in the tree.
const Plane & | plane () const
Returns the splitting plane used to divide its two child nodes.
ActorKdTree * childN ()
Returns the child node that lies in the negative space defined by the splitting plane.
const ActorKdTree * | childN () const
Returns the child node that lies in the negative space defined by the splitting plane.
ActorKdTree * childP ()
Returns the child node that lies in the positive space defined by the splitting plane.
const ActorKdTree * | childP () const
Returns the child node that lies in the positive space defined by the splitting plane.
ActorKdTree * | insertActor (Actor *actor)
Inserts an Actor in the ActorKdTree node hierarchy.
ref< ActorKdTree > | kdtreeFromNonLeafyActors (int max_depth=100, float minimum_volume=0)
Removes the Actor[s] in the internal nodes of the ActorKdTree and uses them to create a new ActorKdTree.
void | harvestNonLeafActors (ActorCollection &actors)
Removes the Actor[s] in the internal nodes of the ActorKdTree and appends them in the given ActorCollection.

Protected Attributes

Plane mPlane
ref< ActorKdTree > mChildN
ref< ActorKdTree > mChildP

Detailed Description

ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree.

Note:
When building the Kd-Tree, Visualization Library considers the Actors' LOD level 0.
See also:
  • ActorTree
  • SceneManager
  • SceneManagerActorKdTree
  • SceneManagerActorTree
  • Actor

Constructor & Destructor Documentation

vl::ActorKdTree::ActorKdTree ( ) [inline]

Member Function Documentation

virtual const char* vl::ActorKdTree::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ActorTreeAbstract.

int ActorKdTree::childrenCount ( ) const [virtual]

Returns the number of child nodes of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

ActorTreeAbstract * ActorKdTree::child ( int i ) [virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

const ActorTreeAbstract * ActorKdTree::child ( int i ) const [virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

void vl::ActorKdTree::compileKdTree | ( | ActorCollection & | actors,
 |  | int | max_depth = 100,
 |  | float | minimum_volume = 0
 | ) |  |

Builds a ActorKdTree with the given list of Actor[s].

The ActorKdTree generation routine will try to minimize the ActorKdTree depth. Note that this function is relatively quick, but is not for free. Consider that using a Core 2 Duo .0GHz you can process around 22.000 objects/sec.

Note:
This method calls prepareActors() before computing the KdTree.

void ActorKdTree::compileKdTree | ( | int | max_depth = 100,
 |  | float | minimum_volume = 0
 | ) |  |

Builds a ActorKdTree with the Actor[s] contained in the tree.

Note:
This method calls prepareActors() before computing the KdTree.

const Plane& vl::ActorKdTree::plane ( ) const [inline]

Returns the splitting plane used to divide its two child nodes.

ActorKdTree* vl::ActorKdTree::childN ( ) [inline]

Returns the child node that lies in the negative space defined by the splitting plane.

const ActorKdTree* vl::ActorKdTree::childN ( ) const [inline]

Returns the child node that lies in the negative space defined by the splitting plane.

ActorKdTree* vl::ActorKdTree::childP ( ) [inline]

Returns the child node that lies in the positive space defined by the splitting plane.

const ActorKdTree* vl::ActorKdTree::childP ( ) const [inline]

Returns the child node that lies in the positive space defined by the splitting plane.

ActorKdTree * ActorKdTree::insertActor ( Actor * actor )

Inserts an Actor in the ActorKdTree node hierarchy.

Note that the Actor is likely to be inserted in a node whose bounding volume does not surround the Actor's bounding volume. For this reason after you inserted one or more Actor[s] in the ActorKdTree you should call computeAABB() on the root node of the ActorKdTree. Inserting and removing Actor[s] is an expensive operation and produces a ActorKdTree that is less balanced than the one you would get by recompiling the whole ActorKdTree from scratch.

Returns:
The ActorKdTree node in which the Actor has been inserted.
See also:
ActorTree::eraseActor()

ref< ActorKdTree > ActorKdTree::kdtreeFromNonLeafyActors | ( | int | max_depth = 100,
 |  | float | minimum_volume = 0
 | ) |  |

Removes the Actor[s] in the internal nodes of the ActorKdTree and uses them to create a new ActorKdTree.

void vl::ActorKdTree::harvestNonLeafActors ( ActorCollection & actors )

Removes the Actor[s] in the internal nodes of the ActorKdTree and appends them in the given ActorCollection.

Member Data Documentation

Plane vl::ActorKdTree::mPlane [protected]

ref<ActorKdTree> vl::ActorKdTree::mChildN [protected]

ref<ActorKdTree> vl::ActorKdTree::mChildP [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ActorRenderingCallback Class Reference

vl::ActorRenderingCallback

vl::ActorRenderingCallback Class Reference

The ActorRenderingCallback class defines a callback object to be executed just before an Actor is rendered but after the render states are setup. More...

#include <Actor.hpp>

Inheritance diagram for vl::ActorRenderingCallback:

vl::Object vl::DepthSortCallback vl::EdgeUpdateCallback vl::MorphingCallback

List of all members.

Public Member Functions

virtual void operator() (const Camera *cam, Actor *actor, Renderable *renderable, const Shader *shader, int pass)=0
Called upon callback execution.

Detailed Description

The ActorRenderingCallback class defines a callback object to be executed just before an Actor is rendered but after the render states are setup.

Usually an ActorRenderingCallback is used to perform a per-Actor operation like changing some attributes of the Actor itself or of the associated Renderable/Geometry before the rendering takes place. For example you can use an ActorRenderingCallback to setup uniforms, query and save uniform binding locations, setup appropriate vertex attributes in a Geometry etc. For example the MorphingCallback class is used to aid the rendering of a MorphingActor, while the DepthSortCallback class is used to perform per-Actor polygon sorting.

Note:
An ActorRenderingCallback is called once for every rendering pass, ie. if an Actor's Effect specifies three rendering passes the Actor callbacks will be called three times, once for each rendering pass.

This function is called once for each pass, after the render states are setup, before the Actor is rendered.

If you want to update the state of a Uniform variable from here you can simply call glUniform* since the GLSLProgram (if any) has been already activated by the time this function is called. You can test whether the shader has a GLSLProgram bound to it or not by simply testing shader->glslProgram() != NULL. If you update a uniform you must ensure that all the Actor[s] using the same GLSLProgram appropriately setup such uniform.

See also:
  • Actor::renderingCallbacks()
  • Actor::update()

Member Function Documentation

virtual void vl::ActorRenderingCallback::operator() | ( | const Camera * | cam,
 |  | Actor * | actor,
 |  | Renderable * | renderable,
 |  | const Shader * | shader,
 |  | int | pass |
 | ) |  |  | [pure virtual]

Called upon callback execution.

Parameters:
cam | The camera used for the current rendering.
actor | The Actor bound to this rendering callback.
renderable | The currently selected Actor LOD.
shader | The currently active Shader.
pass | The current Actor[s] rendering pass.

Implemented in vl::DepthSortCallback, vl::EdgeUpdateCallback, and vl::MorphingCallback.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: vl::ActorTree Class Reference

vl::ActorTree

vl::ActorTree Class Reference

The ActorTree class implements a generic tree whose nodes contain Actor[s]. More...

#include <ActorTree.hpp>

Inheritance diagram for vl::ActorTree:

vl::ActorTreeAbstract vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ActorTree ()
virtual int | childrenCount () const
Returns the number of child nodes of an ActorTreeAbstract node.
virtual ActorTreeAbstract * | child (int i)
Returns the i-th child node of an ActorTreeAbstract node.
virtual const ActorTreeAbstract * | child (int i) const
Returns the i-th child node of an ActorTreeAbstract node.
void | addChild (ActorTreeAbstract *node)
void | setChild (int i, ActorTreeAbstract *node)
void | eraseChild (int i, int count=1)
void | eraseAllChildren ()

Public Attributes

std::vector< ref
< ActorTreeAbstract > > 		mChildren

Detailed Description

The ActorTree class implements a generic tree whose nodes contain Actor[s].

Each node of the tree can have any number of children.

Use this class when you want to have direct control over how the Actor[s] are grouped together or to implement specific space partitioning schemes like BSP trees, Quadtrees, Octrees etc. For example you can use the ActorTree class to build a quadtree by assigning 4 children per node and filling them appropriately. Of course you can also use an ActorTree to group a set of Actor[s] based on any other principle. For example animated Actor[s] are usually kept in separate "flat" trees (for example all in a single node) as the computational cost of rebuilding every frame the BSP tree, Quadtree, Octree etc. might be to high.

Note that for performance reasons the ActorKdTree class derives from the ActorTreeAbstract and implements a space partitioning scheme (based on a binary tree) where the splitting planes are in turn choosen so that they are aligned to the world space x, y and z axes.

See also:
  • ActorKdTree
  • SceneManager
  • SceneManagerActorKdTree
  • SceneManagerActorTree
  • Actor

Constructor & Destructor Documentation

vl::ActorTree::ActorTree ( ) [inline]

Member Function Documentation

virtual const char* vl::ActorTree::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ActorTreeAbstract.

virtual int vl::ActorTree::childrenCount ( ) const [inline, virtual]

Returns the number of child nodes of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

virtual ActorTreeAbstract* vl::ActorTree::child ( int i ) [inline, virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

virtual const ActorTreeAbstract* vl::ActorTree::child ( int i ) const [inline, virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implements vl::ActorTreeAbstract.

void ActorTree::addChild ( ActorTreeAbstract * node )

void ActorTree::setChild | ( | int | i,
 |  | ActorTreeAbstract * | node
 | ) |  |

void ActorTree::eraseChild | ( | int | i,
 |  | int | count = 1
 | ) |  |

void ActorTree::eraseAllChildren ( )

Member Data Documentation

std::vector< ref<ActorTreeAbstract> > vl::ActorTree::mChildren

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ActorTreeAbstract Class Reference

vl::ActorTreeAbstract

vl::ActorTreeAbstract Class Reference

The ActorTreeAbstract class implements the interface of a generic tree containing Actor[s] in its nodes. More...

#include <ActorTreeAbstract.hpp>

Inheritance diagram for vl::ActorTreeAbstract:

vl::Object vl::ActorKdTree vl::ActorTree

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ActorTreeAbstract ()
virtual int | childrenCount () const =0
Returns the number of child nodes of an ActorTreeAbstract node.
virtual ActorTreeAbstract * | child (int i)=0
Returns the i-th child node of an ActorTreeAbstract node.
virtual const ActorTreeAbstract * | child (int i) const =0
Returns the i-th child node of an ActorTreeAbstract node.
const ActorTreeAbstract * | parent () const
Returns the parent of a node.
ActorTreeAbstract * parent ()
Returns the parent of a node.
const ActorCollection * | actors () const
Returns the actors contained in a ActorTree node.
ActorCollection * actors ()
Returns the actors contained in a ActorTree node.
const AABB & | aabb () const
Returns the bounding box of a node. Such bounding box contains both the bounding boxes of the node's Actor[s] and of the child nodes.
void | computeAABB ()
Recursively computes the bounding box of a node so that it includes the bounding boxes of the node's Actor[s] and of the child nodes.
void | appendActors (ActorCollection &list)
Extracts all the Actor[s] contained in th ActorTree hierarchy and appends them to the given ActorCollection.
void | appendVisibleActors (ActorCollection &list, const Camera *camera, unsigned enable_mask=0xFFFFFFFF)
Extracts the enabled and visible Actor[s] contained in th ActorTree hierarchy and appends them to the given ActorCollection.
ActorTreeAbstract * | eraseActor (Actor *actor)
Removes the given Actor from the ActorTreeAbstract.
Actor * | addActor (Renderable *renderable, Effect *eff, Transform *tr=NULL)
Utility function that adds an Actor and binds it to the given Renderable, Effect and Transform.
Actor * | addActor (Actor *actor)
Utility function equivalent to 'actors()->push_back(actor)'.
void | setParent (ActorTreeAbstract *p)
For internal use only.

Static Public Member Functions

static void | prepareActors (ActorCollection &actors)
Updates the Transform and the bounds of the given Actor[s].

Protected Attributes

ActorTreeAbstract * mParent
ActorCollection mActors
AABB mAABB

Detailed Description

The ActorTreeAbstract class implements the interface of a generic tree containing Actor[s] in its nodes.

The interface of ActorTreeAbstract allows you to:

  • Modify the Actor[s] contained in each node
  • Traverse the tree and visit its nodes
  • Compute the AABB of a single node or of the whole tree

Does not allow you to:

  • Add new nodes to the tree

See also:
  • ActorKdTree
  • ActorTree

Constructor & Destructor Documentation

ActorTreeAbstract::ActorTreeAbstract ( )

Member Function Documentation

virtual const char* vl::ActorTreeAbstract::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::ActorKdTree, and vl::ActorTree.

virtual int vl::ActorTreeAbstract::childrenCount ( ) const [pure virtual]

Returns the number of child nodes of an ActorTreeAbstract node.

Implemented in vl::ActorKdTree, and vl::ActorTree.

virtual ActorTreeAbstract* vl::ActorTreeAbstract::child ( int i ) [pure virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implemented in vl::ActorKdTree, and vl::ActorTree.

virtual const ActorTreeAbstract* vl::ActorTreeAbstract::child ( int i ) const [pure virtual]

Returns the i-th child node of an ActorTreeAbstract node.

Implemented in vl::ActorKdTree, and vl::ActorTree.

const ActorTreeAbstract* vl::ActorTreeAbstract::parent ( ) const [inline]

Returns the parent of a node.

ActorTreeAbstract* vl::ActorTreeAbstract::parent ( ) [inline]

Returns the parent of a node.

const ActorCollection* vl::ActorTreeAbstract::actors ( ) const [inline]

Returns the actors contained in a ActorTree node.

ActorCollection* vl::ActorTreeAbstract::actors ( ) [inline]

Returns the actors contained in a ActorTree node.

const AABB& vl::ActorTreeAbstract::aabb ( ) const [inline]

Returns the bounding box of a node. Such bounding box contains both the bounding boxes of the node's Actor[s] and of the child nodes.

void ActorTreeAbstract::computeAABB ( )

Recursively computes the bounding box of a node so that it includes the bounding boxes of the node's Actor[s] and of the child nodes.

void ActorTreeAbstract::appendActors ( ActorCollection & list )

Extracts all the Actor[s] contained in th ActorTree hierarchy and appends them to the given ActorCollection.

void ActorTreeAbstract::appendVisibleActors | ( | ActorCollection & | list,
 |  | const Camera * | camera,
 |  | unsigned | enable_mask = 0xFFFFFFFF
 | ) |  |

Extracts the enabled and visible Actor[s] contained in th ActorTree hierarchy and appends them to the given ActorCollection.

This function implements a hierarchycal frustum culling algorithm that culls the nodes of the bounding box tree first and then the single Actor[s] contained in the nodes that could not be culled. See also Actor::enableMask()

ActorTreeAbstract * ActorTreeAbstract::eraseActor ( Actor * actor )

Removes the given Actor from the ActorTreeAbstract.

Actor * ActorTreeAbstract::addActor | ( | Renderable * | renderable,
 |  | Effect * | eff,
 |  | Transform * | tr = NULL
 | ) |  |

Utility function that adds an Actor and binds it to the given Renderable, Effect and Transform.

Actor * ActorTreeAbstract::addActor ( Actor * actor )

Utility function equivalent to 'actors()->push_back(actor)'.

void ActorTreeAbstract::prepareActors ( ActorCollection & actors ) [static]

Updates the Transform and the bounds of the given Actor[s].

Before you create a bounding box tree or a kd-tree of Actor[s] you have to make sure that their Transform and bounding volumes are up-to-date. This is an utility function that lets you do that in a simple an quick way.

void vl::ActorTreeAbstract::setParent ( ActorTreeAbstract * p ) [inline]

For internal use only.

Member Data Documentation

ActorTreeAbstract* vl::ActorTreeAbstract::mParent [protected]

ActorCollection vl::ActorTreeAbstract::mActors [protected]

AABB vl::ActorTreeAbstract::mAABB [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::AlphaFunc Class Reference

vl::AlphaFunc

vl::AlphaFunc Class Reference

Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::AlphaFunc:

vl::RenderState vl::Object

List of all members.

Public Member Functions

AlphaFunc (EFunction alphafunc=FU_ALWAYS, float refvalue=0)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EFunction alphafunc, float ref_value)
EFunction | alphaFunc () const
float | refValue () const

Protected Attributes

float | mRefValue
EFunction mAlphaFunc

Detailed Description

Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_ALPHA_TEST

Constructor & Destructor Documentation

vl::AlphaFunc::AlphaFunc | ( | EFunction | alphafunc = FU_ALWAYS,
 |  | float | refvalue = 0 |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::AlphaFunc::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::AlphaFunc::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void AlphaFunc::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::AlphaFunc::set | ( | EFunction | alphafunc,
 |  | float | ref_value |
 | ) |  |  | [inline]

EFunction vl::AlphaFunc::alphaFunc ( ) const [inline]

float vl::AlphaFunc::refValue ( ) const [inline]

Member Data Documentation

float vl::AlphaFunc::mRefValue [protected]

EFunction vl::AlphaFunc::mAlphaFunc [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Array< vector_type, scalar_type, gl_size, gl_type > Class Template Reference

vl::Array

vl::Array< vector_type, scalar_type, gl_size, gl_type > Class Template Reference

The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject. More...

#include <Array.hpp>

Inheritance diagram for vl::Array< vector_type, scalar_type, gl_size, gl_type >:

vl::ArrayAbstract vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
virtual int | glSize () const
Returns the number of scalar components for the array, ie 3 for ArrayFVec3, 1 for ArrayUInt etc.
virtual int | glType () const
Returns the OpenGL type for the array, ie GL_FLOAT for ArrayFVec3, GL_UNSIGNED_INT for ArrayUInt etc.
virtual ref< ArrayAbstract > | clone () const
void | clear ()
void | resize (int dim)
int | size () const
Returns the number of elements of an array.
int | sizeGPU () const
int | scalarCount () const
int | scalarCountGPU () const
const vector_type * | begin () const
vector_type * | begin ()
const vector_type * | end () const
vector_type * | end ()
vector_type & | at (int i)
const vector_type & | at (int i) const
vector_type & | operator[] (int i)
const vector_type & | operator[] (int i) const
virtual int | bytesPerVector () const
Sphere | computeBoundingSphere () const
Computes the bounding sphere enclosing the vectors contained in the buffer.
AABB | computeBoundingBox () const
Computes the axis aligned bounding box enclosing the vectors contained in the buffer.
void | transform (const mat4 &m)
Transforms the vectors contained in the buffer.
void | normalize ()
Normalizes the vectors contained in the buffer.
vec4 | vectorAsVec4 (int vector_index) const
Returns a vector from the buffer as a vec4 value.
int | compare (int a, int b) const
Compares two vectors.
void | operator= (const std::vector< vector_type > &vector)

Detailed Description

template<typename vector_type, typename scalar_type, int gl_size, GLenum gl_type>
class vl::Array< vector_type, scalar_type, gl_size, gl_type >

The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject.

See also:
  • ArrayAbstract
  • vl::ArrayFloat, vl::ArrayFVec2, vl::ArrayFVec3, vl::ArrayFVec4
  • vl::ArrayDouble, vl::ArrayDVec2, vl::ArrayDVec3, vl::ArrayDVec4
  • vl::ArrayInt, vl::ArrayIVec2, vl::ArrayIVec3, vl::ArrayIVec4
  • vl::ArrayUInt, vl::ArrayUVec2, vl::ArrayUVec3, vl::ArrayUVec4
  • vl::ArrayByte, vl::ArrayBVec2, vl::ArrayBVec3, vl::ArrayBVec4
  • vl::ArrayUByte, vl::ArrayUBVec2, vl::ArrayUBVec3, vl::ArrayUBVec4
  • vl::ArrayShort, vl::ArraySVec2, vl::ArraySVec3, vl::ArraySVec4
  • vl::ArrayUShort, vl::ArrayUSVec2, vl::ArrayUSVec3, vl::ArrayUSVec4

Member Function Documentation

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
virtual const char* vl::Array< vector_type, scalar_type, gl_size, gl_type >::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
virtual int vl::Array< vector_type, scalar_type, gl_size, gl_type >::glSize ( ) const [inline, virtual]

Returns the number of scalar components for the array, ie 3 for ArrayFVec3, 1 for ArrayUInt etc.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
virtual int vl::Array< vector_type, scalar_type, gl_size, gl_type >::glType ( ) const [inline, virtual]

Returns the OpenGL type for the array, ie GL_FLOAT for ArrayFVec3, GL_UNSIGNED_INT for ArrayUInt etc.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
virtual ref<ArrayAbstract> vl::Array< vector_type, scalar_type, gl_size, gl_type >::clone ( ) const [inline, virtual]

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
void vl::Array< vector_type, scalar_type, gl_size, gl_type >::clear ( ) [inline]

Reimplemented from vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
void vl::Array< vector_type, scalar_type, gl_size, gl_type >::resize ( int dim ) [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
int vl::Array< vector_type, scalar_type, gl_size, gl_type >::size ( ) const [inline, virtual]

Returns the number of elements of an array.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
int vl::Array< vector_type, scalar_type, gl_size, gl_type >::sizeGPU ( ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
int vl::Array< vector_type, scalar_type, gl_size, gl_type >::scalarCount ( ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
int vl::Array< vector_type, scalar_type, gl_size, gl_type >::scalarCountGPU ( ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
const vector_type* vl::Array< vector_type, scalar_type, gl_size, gl_type >::begin ( ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
vector_type* vl::Array< vector_type, scalar_type, gl_size, gl_type >::begin ( ) [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
const vector_type* vl::Array< vector_type, scalar_type, gl_size, gl_type >::end ( ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
vector_type* vl::Array< vector_type, scalar_type, gl_size, gl_type >::end ( ) [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
vector_type& vl::Array< vector_type, scalar_type, gl_size, gl_type >::at ( int i ) [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
const vector_type& vl::Array< vector_type, scalar_type, gl_size, gl_type >::at ( int i ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
vector_type& vl::Array< vector_type, scalar_type, gl_size, gl_type >::operator[] ( int i ) [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
const vector_type& vl::Array< vector_type, scalar_type, gl_size, gl_type >::operator[] ( int i ) const [inline]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
virtual int vl::Array< vector_type, scalar_type, gl_size, gl_type >::bytesPerVector ( ) const [inline, virtual]

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
Sphere vl::Array< vector_type, scalar_type, gl_size, gl_type >::computeBoundingSphere ( ) const [inline, virtual]

Computes the bounding sphere enclosing the vectors contained in the buffer.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
AABB vl::Array< vector_type, scalar_type, gl_size, gl_type >::computeBoundingBox ( ) const [inline, virtual]

Computes the axis aligned bounding box enclosing the vectors contained in the buffer.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
void vl::Array< vector_type, scalar_type, gl_size, gl_type >::transform ( const mat4 & m ) [inline, virtual]

Transforms the vectors contained in the buffer.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
void vl::Array< vector_type, scalar_type, gl_size, gl_type >::normalize ( ) [inline, virtual]

Normalizes the vectors contained in the buffer.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
vec4 vl::Array< vector_type, scalar_type, gl_size, gl_type >::vectorAsVec4 ( int vector_index ) const [inline, virtual]

Returns a vector from the buffer as a vec4 value.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
int vl::Array< vector_type, scalar_type, gl_size, gl_type >::compare | ( | int | a,
 |  | int | b |
 | ) |  |  | const [inline, virtual]

Compares two vectors.

Implements vl::ArrayAbstract.

template<typename vector_type , typename scalar_type , int gl_size, GLenum gl_type>
void vl::Array< vector_type, scalar_type, gl_size, gl_type >::operator= ( const std::vector< vector_type > & vector ) [inline]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Array.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ArrayAbstract Class Reference

vl::ArrayAbstract

vl::ArrayAbstract Class Reference

The ArrayAbstract class defines an abstract interface to conveniently manipulate data stored in a GLBufferObject. More...

#include <Array.hpp>

Inheritance diagram for vl::ArrayAbstract:

vl::Object vl::Array< vector_type, scalar_type, gl_size, gl_type >

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ArrayAbstract ()
Default constructor.
ArrayAbstract (const ArrayAbstract &other)
Copies only the local data and not the VBO related fields.
void | operator= (const ArrayAbstract &other)
Copies only the local data and not the VBO related fields.
virtual ref< ArrayAbstract > | clone () const =0
const GLBufferObject * | gpuBuffer () const
GLBufferObject * gpuBuffer ()
void | clear ()
const unsigned char * | ptr () const
Returns the pointer to the first element of the local buffer. Equivalent to gpuBuffer()->ptr().
unsigned char * | ptr ()
Returns the pointer to the first element of the local buffer. Equivalent to gpuBuffer()->ptr().
virtual int | bytesUsed () const
Returns the amount of memory in bytes used by an array. Equivalent to gpuBuffer()->bytesUsed().
virtual int | glSize () const =0
Returns the number of scalar components for the array, ie 3 for ArrayFVec3, 1 for ArrayUInt etc.
virtual int | glType () const =0
Returns the OpenGL type for the array, ie GL_FLOAT for ArrayFVec3, GL_UNSIGNED_INT for ArrayUInt etc.
virtual int | size () const =0
Returns the number of elements of an array.
virtual Sphere | computeBoundingSphere () const =0
Computes the bounding sphere enclosing the vectors contained in the buffer.
virtual AABB | computeBoundingBox () const =0
Computes the axis aligned bounding box enclosing the vectors contained in the buffer.
virtual void | transform (const mat4 &m)=0
Transforms the vectors contained in the buffer.
virtual void | normalize ()=0
Normalizes the vectors contained in the buffer.
virtual vec4 | vectorAsVec4 (int vector_index) const =0
Returns a vector from the buffer as a vec4 value.
virtual int | compare (int a, int b) const =0
Compares two vectors.
bool | vboDirty () const
true by default
void | setVBODirty (bool dirty)
true by default
EGLBufferUsage | usage () const
GBU_STATIC_DRAW by default.
void | setUsage (EGLBufferUsage usage)
GBU_STATIC_DRAW by default.
void | updateVBO (bool discard_local_storage=false)

Protected Attributes

ref< GLBufferObject > mBufferGPU
EGLBufferUsage mVBOUsage
bool | mVBODirty

Detailed Description

The ArrayAbstract class defines an abstract interface to conveniently manipulate data stored in a GLBufferObject.

See also:
  • vl::Array
  • vl::ArrayFloat, vl::ArrayFVec2, vl::ArrayFVec3, vl::ArrayFVec4
  • vl::ArrayDouble, vl::ArrayDVec2, vl::ArrayDVec3, vl::ArrayDVec4
  • vl::ArrayInt, vl::ArrayIVec2, vl::ArrayIVec3, vl::ArrayIVec4
  • vl::ArrayUInt, vl::ArrayUVec2, vl::ArrayUVec3, vl::ArrayUVec4
  • vl::ArrayByte, vl::ArrayBVec2, vl::ArrayBVec3, vl::ArrayBVec4
  • vl::ArrayUByte, vl::ArrayUBVec2, vl::ArrayUBVec3, vl::ArrayUBVec4
  • vl::ArrayShort, vl::ArraySVec2, vl::ArraySVec3, vl::ArraySVec4
  • vl::ArrayUShort, vl::ArrayUSVec2, vl::ArrayUSVec3, vl::ArrayUSVec4

Constructor & Destructor Documentation

vl::ArrayAbstract::ArrayAbstract ( ) [inline]

Default constructor.

vl::ArrayAbstract::ArrayAbstract ( const ArrayAbstract & other ) [inline]

Copies only the local data and not the VBO related fields.

Member Function Documentation

virtual const char* vl::ArrayAbstract::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

void vl::ArrayAbstract::operator= ( const ArrayAbstract & other ) [inline]

Copies only the local data and not the VBO related fields.

virtual ref<ArrayAbstract> vl::ArrayAbstract::clone ( ) const [pure virtual]

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

const GLBufferObject* vl::ArrayAbstract::gpuBuffer ( ) const [inline]

GLBufferObject* vl::ArrayAbstract::gpuBuffer ( ) [inline]

void vl::ArrayAbstract::clear ( ) [inline]

Reimplemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

const unsigned char* vl::ArrayAbstract::ptr ( ) const [inline]

Returns the pointer to the first element of the local buffer. Equivalent to gpuBuffer()->ptr().

unsigned char* vl::ArrayAbstract::ptr ( ) [inline]

Returns the pointer to the first element of the local buffer. Equivalent to gpuBuffer()->ptr().

virtual int vl::ArrayAbstract::bytesUsed ( ) const [inline, virtual]

Returns the amount of memory in bytes used by an array. Equivalent to gpuBuffer()->bytesUsed().

virtual int vl::ArrayAbstract::glSize ( ) const [pure virtual]

Returns the number of scalar components for the array, ie 3 for ArrayFVec3, 1 for ArrayUInt etc.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual int vl::ArrayAbstract::glType ( ) const [pure virtual]

Returns the OpenGL type for the array, ie GL_FLOAT for ArrayFVec3, GL_UNSIGNED_INT for ArrayUInt etc.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual int vl::ArrayAbstract::size ( ) const [pure virtual]

Returns the number of elements of an array.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual Sphere vl::ArrayAbstract::computeBoundingSphere ( ) const [pure virtual]

Computes the bounding sphere enclosing the vectors contained in the buffer.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual AABB vl::ArrayAbstract::computeBoundingBox ( ) const [pure virtual]

Computes the axis aligned bounding box enclosing the vectors contained in the buffer.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual void vl::ArrayAbstract::transform ( const mat4 & m ) [pure virtual]

Transforms the vectors contained in the buffer.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual void vl::ArrayAbstract::normalize ( ) [pure virtual]

Normalizes the vectors contained in the buffer.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual vec4 vl::ArrayAbstract::vectorAsVec4 ( int vector_index ) const [pure virtual]

Returns a vector from the buffer as a vec4 value.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

virtual int vl::ArrayAbstract::compare | ( | int | a,
 |  | int | b |
 | ) |  |  | const [pure virtual]

Compares two vectors.

Implemented in vl::Array< vector_type, scalar_type, gl_size, gl_type >.

bool vl::ArrayAbstract::vboDirty ( ) const [inline]

true by default

void vl::ArrayAbstract::setVBODirty ( bool dirty ) [inline]

true by default

EGLBufferUsage vl::ArrayAbstract::usage ( ) const [inline]

GBU_STATIC_DRAW by default.

void vl::ArrayAbstract::setUsage ( EGLBufferUsage usage ) [inline]

GBU_STATIC_DRAW by default.

void vl::ArrayAbstract::updateVBO ( bool discard_local_storage = false ) [inline]

Member Data Documentation

ref<GLBufferObject> vl::ArrayAbstract::mBufferGPU [protected]

EGLBufferUsage vl::ArrayAbstract::mVBOUsage [protected]

bool vl::ArrayAbstract::mVBODirty [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Array.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::BezierPatch Class Reference

vl::BezierPatch

vl::BezierPatch Class Reference

Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class. More...

#include <BezierSurface.hpp>

Inheritance diagram for vl::BezierPatch:

vl::Object

List of all members.

Public Types

typedef std::vector
< std::vector< dvec3 > > 		Points
The control points grid defining the bicubic Bézier patch(es).

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
BezierPatch ()
Constructor.
BezierPatch (int x, int y)
Constructor.
void | resize (int x, int y)
Defines the x and y dimensions of the control point grid defining the patch.
int | x () const
Returns the x dimension of the patch as specified by resize().
int | y () const
Returns the y dimension of the patch as specified by resize().
Points & points ()
The control points grid defining the bicubic Bézier patch(es).
const Points & | points () const
The control points grid defining the bicubic Bézier patch(es).

Protected Attributes

Points mControlPoints
int | mX
int | mY

Detailed Description

Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class.

See also:

  • Bézier Patches and Surfaces Tutorial for a practical example on how to use the BezierSurface class.
  • BezierSurface

Member Typedef Documentation

typedef std::vector< std::vector<dvec3> > vl::BezierPatch::Points

The control points grid defining the bicubic Bézier patch(es).

Constructor & Destructor Documentation

vl::BezierPatch::BezierPatch ( ) [inline]

Constructor.

vl::BezierPatch::BezierPatch | ( | int | x,
 |  | int | y |
 | ) |  |  | [inline]

Constructor.

Member Function Documentation

virtual const char* vl::BezierPatch::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void BezierPatch::resize | ( | int | x,
 |  | int | y
 | ) |  |

Defines the x and y dimensions of the control point grid defining the patch.

The x and y parameters must be of the form 3*n+1 with n integer positive, i.e 4 (n=1), 7 (n=2), 10 (n=3) and so on.

- The simplest bicubic Bézier patch requires 4x4 = 16 control points: A, B, C, D, E, F, G, H, I, L, M, N, O, P, Q, R
- The Bézier surface is guaranteed to touch only the 4 corner control points A, D, O and R.

A---B---C---D
|   |   |   |
E---F---G---H
|   |   |   |
I---L---M---N
|   |   |   |
O---P---Q---R

In this case we would call "resize(4,4)"

- You can concatenate two bicubic Bézier patches to form a larger suface by sharing their control points like this:

   patch 1     patch 2
A---+---+---B---+---+---G
|   |   |   |   |   |   |
+---+---+---C---+---+---+
|   |   |   |   |   |   |
+---+---+---D---+---+---+
|   |   |   |   |   |   |
F---+---+---E---+---+---H

In this case we would call "resize(7,4)"

- In this case the two patches share the control points B, C, D and E.
- As we can see the total control points needed are 28 = (2 (patches along x) * 3 + 1) * (1 (patches along y) * 3 + 1)
- Also in this case the Bézier surface is guaranteed to touch only the 6 corner control points A, B, E, F, G and H.

int vl::BezierPatch::x ( ) const [inline]

Returns the x dimension of the patch as specified by resize().

int vl::BezierPatch::y ( ) const [inline]

Returns the y dimension of the patch as specified by resize().

Points& vl::BezierPatch::points ( ) [inline]

The control points grid defining the bicubic Bézier patch(es).

const Points& vl::BezierPatch::points ( ) const [inline]

The control points grid defining the bicubic Bézier patch(es).

Member Data Documentation

Points vl::BezierPatch::mControlPoints [protected]

int vl::BezierPatch::mX [protected]

int vl::BezierPatch::mY [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::BezierSurface Class Reference

vl::BezierSurface

vl::BezierSurface Class Reference

The BezierSurface class implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch). More...

#include <BezierSurface.hpp>

Inheritance diagram for vl::BezierSurface:

vl::Geometry vl::Renderable vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
BezierSurface ()
Constructor.
std::vector< ref< BezierPatch > > & | patches ()
Returns the Bézier patches that are part of this Bézier surface.
const std::vector< ref
< BezierPatch > > & 		patches () const
Returns the Bézier patches that are part of this Bézier surface.
void | setDetail (unsigned i)
The sampling level of the patch, must not be less than 2. The higher the sampling level, the more detailed the patch will be.
unsigned | detail () const
The sampling level of the patch, must not be less than 2. The higher the sampling level, the more detailed the patch will be.
void | updateBezierSurface (bool gen_tex_coords=true)
Generates the Bézier surface geometry based on the current patches and detail.

Protected Attributes

std::vector< ref< BezierPatch > > | mPatches
unsigned | mDetail

Detailed Description

The BezierSurface class implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch).

From Wikipedia [http://en.wikipedia.org/wiki/Bézier_surface]:

"Bézier surfaces are a species of mathematical spline used in computer graphics, computer-aided design, and finite element modelling. As with the Bézier curve, a Bézier surface is defined by a set of control points. Similar to interpolation in many respects, a key difference is that the surface does not, in general, pass through the central control points; rather, it is "stretched" toward them as though each were an attractive force. They are visually intuitive, and for many applications, mathematically convenient."

"Bézier surfaces were first described in 1972 by the French engineer Pierre Bézier who used them to design automobile bodies. Bézier surfaces can be of any degree, but bicubic Bézier surfaces generally provide enough degrees of freedom for most applications."

See also:

  • Bézier Patches and Surfaces Tutorial for a practical example on how to use the BezierSurface class.
  • BezierPatch

Constructor & Destructor Documentation

vl::BezierSurface::BezierSurface ( ) [inline]

Constructor.

Member Function Documentation

virtual const char* vl::BezierSurface::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Geometry.

std::vector< ref<BezierPatch> >& vl::BezierSurface::patches ( ) [inline]

Returns the Bézier patches that are part of this Bézier surface.

const std::vector< ref<BezierPatch> >& vl::BezierSurface::patches ( ) const [inline]

Returns the Bézier patches that are part of this Bézier surface.

void vl::BezierSurface::setDetail ( unsigned i ) [inline]

The sampling level of the patch, must not be less than 2. The higher the sampling level, the more detailed the patch will be.

unsigned vl::BezierSurface::detail ( ) const [inline]

The sampling level of the patch, must not be less than 2. The higher the sampling level, the more detailed the patch will be.

void BezierSurface::updateBezierSurface ( bool gen_tex_coords = true )

Generates the Bézier surface geometry based on the current patches and detail.

Note that this method does not recompte the normals of the mesh, this means that if you are using the OpenGL lighting or other techniques requiring vertex normals you should call computeNormals() right after calling this function.

Parameters:
gen_tex_coords If set to true the function will also generate normalized (0..1) texture coordinates.

Member Data Documentation

std::vector< ref<BezierPatch> > vl::BezierSurface::mPatches [protected]

unsigned vl::BezierSurface::mDetail [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Billboard Class Reference

vl::Billboard

vl::Billboard Class Reference

A Transform that aligns an Actor towards the camera. More...

#include <Billboard.hpp>

Inheritance diagram for vl::Billboard:

vl::Transform vl::Object

List of all members.

Public Member Functions

Billboard ()
virtual const char * | className ()
Returns the name of the class.
void | setPosition (const vec3 &pos)
The billboard position and rotation center.
void | setPosition (Real x, Real y, Real z)
The billboard position and rotation center.
vec3 position ()
The billboard position and rotation center.
void | setAxis (const vec3 &axis)
The rotation axis in world coordinates. Used only for axis aligned billboards.
const vec3 & | axis () const
The rotation axis in world coordinates. Used only for axis aligned billboards.
void | setNormal (const vec3 &normal)
Used only for axis aligned billboards.
const vec3 & | normal () const
Used only for axis aligned billboards.
virtual void | computeWorldMatrix (Camera *camera=NULL)
EBillboardType | type () const
The type of the billboard.
void | setType (EBillboardType type)
The type of the billboard.

Protected Attributes

vec3 mAxis
vec3 mNormal
EBillboardType mType

Detailed Description

A Transform that aligns an Actor towards the camera.

Constructor & Destructor Documentation

Billboard::Billboard ( )

Member Function Documentation

virtual const char* vl::Billboard::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Transform.

void Billboard::setPosition ( const vec3 & pos )

The billboard position and rotation center.

void vl::Billboard::setPosition | ( | Real | x,
 |  | Real | y,
 |  | Real | z |
 | ) |  |  | [inline]

The billboard position and rotation center.

vec3 Billboard::position ( )

The billboard position and rotation center.

void vl::Billboard::setAxis ( const vec3 & axis ) [inline]

The rotation axis in world coordinates. Used only for axis aligned billboards.

const vec3& vl::Billboard::axis ( ) const [inline]

The rotation axis in world coordinates. Used only for axis aligned billboards.

void vl::Billboard::setNormal ( const vec3 & normal ) [inline]

Used only for axis aligned billboards.

const vec3& vl::Billboard::normal ( ) const [inline]

Used only for axis aligned billboards.

void Billboard::computeWorldMatrix ( Camera * camera = NULL ) [virtual]

Reimplemented from vl::Transform.

EBillboardType vl::Billboard::type ( ) const [inline]

The type of the billboard.

void vl::Billboard::setType ( EBillboardType type ) [inline]

The type of the billboard.

Member Data Documentation

vec3 vl::Billboard::mAxis [protected]

vec3 vl::Billboard::mNormal [protected]

EBillboardType vl::Billboard::mType [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::BlendColor Class Reference

vl::BlendColor

vl::BlendColor Class Reference

Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::BlendColor:

vl::RenderState vl::Object

List of all members.

Public Member Functions

BlendColor (fvec4 blendcolor=fvec4(0, 0, 0, 0))
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (fvec4 blendcolor)
fvec4 | blendColor () const

Protected Attributes

fvec4 mBlendColor

Detailed Description

Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::BlendColor::BlendColor ( fvec4 blendcolor = fvec4(0,0,0,0) ) [inline]

Member Function Documentation

virtual const char* vl::BlendColor::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::BlendColor::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void BlendColor::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::BlendColor::set ( fvec4 blendcolor ) [inline]

fvec4 vl::BlendColor::blendColor ( ) const [inline]

Member Data Documentation

fvec4 vl::BlendColor::mBlendColor [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::BlendEquation Class Reference

vl::BlendEquation

vl::BlendEquation Class Reference

Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::BlendEquation:

vl::RenderState vl::Object

List of all members.

Public Member Functions

BlendEquation (EBlendEquation mode_rgb=BE_FUNC_ADD, EBlendEquation mode_alpha=BE_FUNC_ADD)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EBlendEquation mode_rgba)
void | set (EBlendEquation mode_rgb, EBlendEquation mode_alpha)
EBlendEquation | modeRGB () const
EBlendEquation | modeAlpha () const

Protected Attributes

EBlendEquation mModeRGB
EBlendEquation mModeAlpha

Detailed Description

Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::BlendEquation::BlendEquation | ( | EBlendEquation | mode_rgb = BE_FUNC_ADD,
 |  | EBlendEquation | mode_alpha = BE_FUNC_ADD |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::BlendEquation::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::BlendEquation::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void BlendEquation::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::BlendEquation::set ( EBlendEquation mode_rgba ) [inline]

void vl::BlendEquation::set | ( | EBlendEquation | mode_rgb,
 |  | EBlendEquation | mode_alpha |
 | ) |  |  | [inline]

EBlendEquation vl::BlendEquation::modeRGB ( ) const [inline]

EBlendEquation vl::BlendEquation::modeAlpha ( ) const [inline]

Member Data Documentation

EBlendEquation vl::BlendEquation::mModeRGB [protected]

EBlendEquation vl::BlendEquation::mModeAlpha [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::BlendFunc Class Reference

vl::BlendFunc

vl::BlendFunc Class Reference

Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::BlendFunc:

vl::RenderState vl::Object

List of all members.

Public Member Functions

BlendFunc (EBlendFactor src_rgb=BF_SRC_ALPHA, EBlendFactor dst_rgb=BF_ONE_MINUS_SRC_ALPHA, EBlendFactor src_alpha=BF_SRC_ALPHA, EBlendFactor dst_alpha=BF_ONE_MINUS_SRC_ALPHA)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EBlendFactor src_rgb, EBlendFactor dst_rgb, EBlendFactor src_alpha, EBlendFactor dst_alpha)
void | set (EBlendFactor src_rgba, EBlendFactor dst_rgba)
void | setSrcRGB (EBlendFactor factor)
void | setDstRGB (EBlendFactor factor)
void | setSrcAlpha (EBlendFactor factor)
void | setDstAlpha (EBlendFactor factor)
EBlendFactor | srcRGB () const
EBlendFactor | dstRGB () const
EBlendFactor | srcAlpha () const
EBlendFactor | dstAlpha () const

Protected Attributes

EBlendFactor mSrcRGB
EBlendFactor mDstRGB
EBlendFactor mSrcAlpha
EBlendFactor mDstAlpha

Detailed Description

Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_BLEND

Constructor & Destructor Documentation

vl::BlendFunc::BlendFunc | ( | EBlendFactor | src_rgb = BF_SRC_ALPHA,
 |  | EBlendFactor | dst_rgb = BF_ONE_MINUS_SRC_ALPHA,
 |  | EBlendFactor | src_alpha = BF_SRC_ALPHA,
 |  | EBlendFactor | dst_alpha = BF_ONE_MINUS_SRC_ALPHA |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::BlendFunc::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::BlendFunc::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void BlendFunc::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::BlendFunc::set | ( | EBlendFactor | src_rgb,
 |  | EBlendFactor | dst_rgb,
 |  | EBlendFactor | src_alpha,
 |  | EBlendFactor | dst_alpha |
 | ) |  |  | [inline]

void vl::BlendFunc::set | ( | EBlendFactor | src_rgba,
 |  | EBlendFactor | dst_rgba |
 | ) |  |  | [inline]

void vl::BlendFunc::setSrcRGB ( EBlendFactor factor ) [inline]

void vl::BlendFunc::setDstRGB ( EBlendFactor factor ) [inline]

void vl::BlendFunc::setSrcAlpha ( EBlendFactor factor ) [inline]

void vl::BlendFunc::setDstAlpha ( EBlendFactor factor ) [inline]

EBlendFactor vl::BlendFunc::srcRGB ( ) const [inline]

EBlendFactor vl::BlendFunc::dstRGB ( ) const [inline]

EBlendFactor vl::BlendFunc::srcAlpha ( ) const [inline]

EBlendFactor vl::BlendFunc::dstAlpha ( ) const [inline]

Member Data Documentation

EBlendFactor vl::BlendFunc::mSrcRGB [protected]

EBlendFactor vl::BlendFunc::mDstRGB [protected]

EBlendFactor vl::BlendFunc::mSrcAlpha [protected]

EBlendFactor vl::BlendFunc::mDstAlpha [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::BlitFramebuffer Class Reference

vl::BlitFramebuffer

vl::BlitFramebuffer Class Reference

A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit. More...

#include <BlitFramebuffer.hpp>

Inheritance diagram for vl::BlitFramebuffer:

vl::RenderingCallback vl::Object

List of all members.

Public Member Functions

BlitFramebuffer ()
virtual const char * | className ()
Returns the name of the class.
void | copyPixels ()
Performs the actual pixel copy from the read framebuffer to the draw framebuffer.
virtual bool | renderingCallback (const RenderingAbstract *, ERenderingCallback reason)
Implements the actual code to be executed upon callback activation.
void | setReadFramebuffer (FBORenderTarget *fbo)
FBORenderTarget * | readFramebuffer () const
void | setDrawFramebuffer (FBORenderTarget *fbo)
FBORenderTarget * | drawFramebuffer () const
void | setSrcRect (int x0, int y0, int x1, int y1)
void | setDstRect (int x0, int y0, int x1, int y1)
const int * | srcRect () const
const int * | dstRect () const
void | setBufferMask (int buffer_mask)
takes a bitmask combination of EBufferBits
int | bufferMask () const
void | setLinearFilteringEnabled (bool enable_linear_filtering)
bool | linearFilteringEnabled () const

Protected Attributes

ref< FBORenderTarget > mReadFramebuffer
ref< FBORenderTarget > mDrawFramebuffer
int | mSrcRect [4]
int | mDstRect [4]
int | mBufferMask
bool | mLinearFilteringEnabled

Detailed Description

A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit.

Constructor & Destructor Documentation

vl::BlitFramebuffer::BlitFramebuffer ( ) [inline]

Member Function Documentation

virtual const char* vl::BlitFramebuffer::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderingCallback.

void vl::BlitFramebuffer::copyPixels ( ) [inline]

Performs the actual pixel copy from the read framebuffer to the draw framebuffer.

virtual bool vl::BlitFramebuffer::renderingCallback | ( | const RenderingAbstract * | rendering,
 |  | ERenderingCallback | reason |
 | ) |  |  | [inline, virtual]

Implements the actual code to be executed upon callback activation.

Returns:
true if the callback reacted to the given reason

Implements vl::RenderingCallback.

void vl::BlitFramebuffer::setReadFramebuffer ( FBORenderTarget * fbo ) [inline]

FBORenderTarget* vl::BlitFramebuffer::readFramebuffer ( ) const [inline]

void vl::BlitFramebuffer::setDrawFramebuffer ( FBORenderTarget * fbo ) [inline]

FBORenderTarget* vl::BlitFramebuffer::drawFramebuffer ( ) const [inline]

void vl::BlitFramebuffer::setSrcRect | ( | int | x0,
 |  | int | y0,
 |  | int | x1,
 |  | int | y1 |
 | ) |  |  | [inline]

void vl::BlitFramebuffer::setDstRect | ( | int | x0,
 |  | int | y0,
 |  | int | x1,
 |  | int | y1 |
 | ) |  |  | [inline]

const int* vl::BlitFramebuffer::srcRect ( ) const [inline]

const int* vl::BlitFramebuffer::dstRect ( ) const [inline]

void vl::BlitFramebuffer::setBufferMask ( int buffer_mask ) [inline]

takes a bitmask combination of EBufferBits

int vl::BlitFramebuffer::bufferMask ( ) const [inline]

void vl::BlitFramebuffer::setLinearFilteringEnabled ( bool enable_linear_filtering ) [inline]

bool vl::BlitFramebuffer::linearFilteringEnabled ( ) const [inline]

Member Data Documentation

ref<FBORenderTarget> vl::BlitFramebuffer::mReadFramebuffer [protected]

ref<FBORenderTarget> vl::BlitFramebuffer::mDrawFramebuffer [protected]

int vl::BlitFramebuffer::mSrcRect[4] [protected]

int vl::BlitFramebuffer::mDstRect[4] [protected]

int vl::BlitFramebuffer::mBufferMask [protected]

bool vl::BlitFramebuffer::mLinearFilteringEnabled [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BlitFramebuffer.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Buffer Class Reference

vl::Buffer

vl::Buffer Class Reference

Implements a buffer whose storage is in local memory. More...

#include <Buffer.hpp>

Inheritance diagram for vl::Buffer:

vl::Object vl::GLBufferObject

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Buffer ()
Buffer (const Buffer &other)
Buffer & | operator= (const Buffer &other)
void | swap (Buffer &other)
~Buffer ()
void | clear ()
void | resize (int byte_count, int alignment=0)
int | bytesUsed () const
bool | empty () const
unsigned char * | ptr ()
const unsigned char * | ptr () const
int | alignment () const

Static Public Member Functions

static void * | alignedMalloc (int bytes, int alignment)
static void | alignedFree (void *ptr)

Protected Attributes

unsigned char * | mPtr
int | mByteCount
int | mAlignment

Detailed Description

Implements a buffer whose storage is in local memory.

Constructor & Destructor Documentation

vl::Buffer::Buffer ( ) [inline]

vl::Buffer::Buffer ( const Buffer & other ) [inline]

vl::Buffer::~Buffer ( ) [inline]

Member Function Documentation

virtual const char* vl::Buffer::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::GLBufferObject.

Buffer& vl::Buffer::operator= ( const Buffer & other ) [inline]

void vl::Buffer::swap ( Buffer & other ) [inline]

void vl::Buffer::clear ( ) [inline]

void vl::Buffer::resize | ( | int | byte_count,
 |  | int | alignment = 0 |
 | ) |  |  | [inline]

int vl::Buffer::bytesUsed ( ) const [inline]

bool vl::Buffer::empty ( ) const [inline]

unsigned char* vl::Buffer::ptr ( ) [inline]

const unsigned char* vl::Buffer::ptr ( ) const [inline]

int vl::Buffer::alignment ( ) const [inline]

static void* vl::Buffer::alignedMalloc | ( | int | bytes,
 |  | int | alignment |
 | ) |  |  | [inline, static]

static void vl::Buffer::alignedFree ( void * ptr ) [inline, static]

Member Data Documentation

unsigned char* vl::Buffer::mPtr [protected]

int vl::Buffer::mByteCount [protected]

int vl::Buffer::mAlignment [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Buffer.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::BufferedStream< Element_Type, Chunk_Size > Class Template Reference

vl::BufferedStream

vl::BufferedStream< Element_Type, Chunk_Size > Class Template Reference

The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile. More...

#include <BufferedStream.hpp>

Inheritance diagram for vl::BufferedStream< Element_Type, Chunk_Size >:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
BufferedStream ()
void | seek (long long pos)
bool | readToken (Element_Type *token)
bool | bufferEmpty ()
int | fillBuffer ()
void | setInputFile (VirtualFile *file)
VirtualFile * | inputFile () const
void | ungetToken (const Element_Type &token)

Protected Attributes

ref< VirtualFile > mInputFile
std::vector< Element_Type > | mUngetBuffer
std::vector< Element_Type > | mBuffer
int | mPtr
int | mSize

Detailed Description

template<class Element_Type, int Chunk_Size>
class vl::BufferedStream< Element_Type, Chunk_Size >

The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile.

Constructor & Destructor Documentation

template<class Element_Type, int Chunk_Size>
vl::BufferedStream< Element_Type, Chunk_Size >::BufferedStream ( ) [inline]

Member Function Documentation

template<class Element_Type, int Chunk_Size>
virtual const char* vl::BufferedStream< Element_Type, Chunk_Size >::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::TextStream.

template<class Element_Type, int Chunk_Size>
void vl::BufferedStream< Element_Type, Chunk_Size >::seek ( long long pos ) [inline]

template<class Element_Type, int Chunk_Size>
bool vl::BufferedStream< Element_Type, Chunk_Size >::readToken ( Element_Type * token ) [inline]

template<class Element_Type, int Chunk_Size>
bool vl::BufferedStream< Element_Type, Chunk_Size >::bufferEmpty ( ) [inline]

template<class Element_Type, int Chunk_Size>
int vl::BufferedStream< Element_Type, Chunk_Size >::fillBuffer ( ) [inline]

template<class Element_Type, int Chunk_Size>
void vl::BufferedStream< Element_Type, Chunk_Size >::setInputFile ( VirtualFile * file ) [inline]

template<class Element_Type, int Chunk_Size>
VirtualFile* vl::BufferedStream< Element_Type, Chunk_Size >::inputFile ( ) const [inline]

template<class Element_Type, int Chunk_Size>
void vl::BufferedStream< Element_Type, Chunk_Size >::ungetToken ( const Element_Type & token ) [inline]

Member Data Documentation

template<class Element_Type, int Chunk_Size>
ref<VirtualFile> vl::BufferedStream< Element_Type, Chunk_Size >::mInputFile [protected]

template<class Element_Type, int Chunk_Size>
std::vector<Element_Type> vl::BufferedStream< Element_Type, Chunk_Size >::mUngetBuffer [protected]

template<class Element_Type, int Chunk_Size>
std::vector<Element_Type> vl::BufferedStream< Element_Type, Chunk_Size >::mBuffer [protected]

template<class Element_Type, int Chunk_Size>
int vl::BufferedStream< Element_Type, Chunk_Size >::mPtr [protected]

template<class Element_Type, int Chunk_Size>
int vl::BufferedStream< Element_Type, Chunk_Size >::mSize [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BufferedStream.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Camera Class Reference

vl::Camera

vl::Camera Class Reference

Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered. More...

#include <Camera.hpp>

Inheritance diagram for vl::Camera:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Camera (const std::string &name="Camera")
Constructor.
void | activate ()
Initializes the GL_PROJECTION and GL_MODELVIEW matrices according to the Camera's projection and view matrix and computes the frustum planes.
void | computeFrustumPlanes ()
Computes the Camera's frustum planes in world space.
void | applyModelViewMatrix (const mat4 &model_matrix) const
Loads the GL_MODELVIEW matrix with the Camera's view matrix multiplied by the specified model matrix.
void | applyViewMatrix () const
Loads the GL_MODELVIEW matrix with the Camera's view matrix.
void | setActive (bool active)
bool | active () const
void | setFOV (Real fov)
Real | fov () const
Real | aspectRatio () const
Returns the aspect ratio computed as viewport()->width()/viewport()->height().
void | setNearPlane (Real nearplane)
Real | nearPlane () const
void | setFarPlane (Real farplane)
Real | farPlane () const
void | setFrustum (const Frustum &frustum)
const Frustum & | frustum () const
void | setViewport (Viewport *viewport)
Viewport * viewport ()
const Viewport * | viewport () const
void | followTransform (Transform *transform)
const Transform * | followedTransform () const
Transform * followedTransform ()
void | setViewMatrix (const mat4 &mat)
Sets the Camera's view matrix.
const mat4 & | viewMatrix () const
The Camera's view matrix.
void | setInverseViewMatrix (const mat4 &mat)
The camera's reference frame matrix, the inverse of the view matrix.
const mat4 & | inverseViewMatrix () const
The camera's reference frame matrix, the inverse of the view matrix.
void | setProjectionMatrix (const mat4 &mat)
The camera's projection matrix.
const mat4 & | projectionMatrix () const
The camera's projection matrix.
void | setProjectionAsPerspective ()
Builds a perspective projection matrix for the Camera based on the Camera's and Viewport's settings.
void | setProjectionAsPerspective (Real fov, Real near, Real far)
Builds a perspective projection matrix for the Camera based on the Camera's and Viewport's settings.
void | setProjectionAsFrustum (Real left, Real right, Real bottom, Real top, Real near, Real far)
Builds a perspective projection matrix for the Camera based on the give frustum.
void | setProjectionAsOrtho (Real offset=-0.5f)
Builds an orthographic projection matrix for the Camera based on the Camera's near/far planes and its Viewport's settings.
void | setProjectionAsOrtho2D (Real offset=-0.5f)
Builds an orthographic projection matrix for the Camera based on its Viewport's settings.
void | setViewMatrixAsLookAt (const vec3 &eye, const vec3 &center, const vec3 &up)
void | getViewMatrixAsLookAt (vec3 &eye, vec3 &look, vec3 &up, vec3 &right) const
bool | project (const vec4 &in, vec4 &out) const
bool | unproject (const vec3 &win, vec4 &out) const
Unprojects a vector from window coordinates to world coordinates.
bool | unproject (std::vector< vec3 > &points) const
Unprojects a set of points. See unproject(const vec3& win, vec4& out) for more information.
Ray | computeRay (int winx, int winy)
Computes the ray passing through the point <winx,winy>.
Frustum | computeRayFrustum (int winx, int winy)
Computes a frustum suitable to cull object during ray intersection detection.
void | setNearFarClippingPlanesOptimized (bool enable)
Enables the optimization of the near and far clipping planes.
bool | nearFarClippingPlanesOptimized () const
Set to true if the optimization of the near and far clipping planes is enabled.
void | setSceneBoundingSphere (const Sphere &sphere)
The bounding sphere of the scene used to optimize the near and far clipping planes.
const Sphere & | sceneBoundingSphere () const
The bounding sphere of the scene used to optimize the near and far clipping planes.
void | adjustView (const AABB &aabb, const vec3 &dir, const vec3 &up, Real bias=1.0f)
Adjusts the camera position so that the given aabb can be properly viewed.

Protected Attributes

mat4 mViewMatrix
mat4 mInverseViewMatrix
mat4 mProjectionMatrix
ref< Viewport > mViewport
Frustum mFrustum
ref< Transform > mFollowTransform
Real mFOV
Real mNearPlane
Real mFarPlane
Sphere mSceneBoundingSphere
bool | mActive
bool | mNearFarClippingPlanesOptimized

Detailed Description

Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered.

Constructor & Destructor Documentation

Camera::Camera ( const std::string & name = "Camera" )

Constructor.

Member Function Documentation

virtual const char* vl::Camera::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void Camera::activate ( )

Initializes the GL_PROJECTION and GL_MODELVIEW matrices according to the Camera's projection and view matrix and computes the frustum planes.

void Camera::computeFrustumPlanes ( )

Computes the Camera's frustum planes in world space.

If nearFarClippingPlanesOptimized() == true the near and far culling planes distances are respectively set to nearPlane() and farPlane()

void Camera::applyModelViewMatrix ( const mat4 & model_matrix ) const

Loads the GL_MODELVIEW matrix with the Camera's view matrix multiplied by the specified model matrix.

void Camera::applyViewMatrix ( ) const

Loads the GL_MODELVIEW matrix with the Camera's view matrix.

void vl::Camera::setActive ( bool active ) [inline]

bool vl::Camera::active ( ) const [inline]

void vl::Camera::setFOV ( Real fov ) [inline]

Real vl::Camera::fov ( ) const [inline]

Real vl::Camera::aspectRatio ( ) const [inline]

Returns the aspect ratio computed as viewport()->width()/viewport()->height().

If viewport() == NULL the function returns 0.

void vl::Camera::setNearPlane ( Real nearplane ) [inline]

Real vl::Camera::nearPlane ( ) const [inline]

void vl::Camera::setFarPlane ( Real farplane ) [inline]

Real vl::Camera::farPlane ( ) const [inline]

void vl::Camera::setFrustum ( const Frustum & frustum ) [inline]

const Frustum& vl::Camera::frustum ( ) const [inline]

void vl::Camera::setViewport ( Viewport * viewport ) [inline]

Viewport* vl::Camera::viewport ( ) [inline]

const Viewport* vl::Camera::viewport ( ) const [inline]

void vl::Camera::followTransform ( Transform * transform ) [inline]

const Transform* vl::Camera::followedTransform ( ) const [inline]

Transform* vl::Camera::followedTransform ( ) [inline]

void vl::Camera::setViewMatrix ( const mat4 & mat ) [inline]

Sets the Camera's view matrix.

const mat4& vl::Camera::viewMatrix ( ) const [inline]

The Camera's view matrix.

This is what you would pass to OpenGL with "glMatrixMode(GL_MODELVIEW);glLoadMatrix(camera.viewMatrix().ptr());"

void vl::Camera::setInverseViewMatrix ( const mat4 & mat ) [inline]

The camera's reference frame matrix, the inverse of the view matrix.

const mat4& vl::Camera::inverseViewMatrix ( ) const [inline]

The camera's reference frame matrix, the inverse of the view matrix.

void vl::Camera::setProjectionMatrix ( const mat4 & mat ) [inline]

The camera's projection matrix.

const mat4& vl::Camera::projectionMatrix ( ) const [inline]

The camera's projection matrix.

void Camera::setProjectionAsPerspective ( )

Builds a perspective projection matrix for the Camera based on the Camera's and Viewport's settings.

See also http://www.opengl.org/sdk/docs/man/xhtml/gluPerspective.xml for more information.

void Camera::setProjectionAsPerspective | ( | Real | fov,
 |  | Real | near,
 |  | Real | far
 | ) |  |

Builds a perspective projection matrix for the Camera based on the Camera's and Viewport's settings.

See also http://www.opengl.org/sdk/docs/man/xhtml/gluPerspective.xml for more information.

void Camera::setProjectionAsFrustum | ( | Real | left,
 |  | Real | right,
 |  | Real | bottom,
 |  | Real | top,
 |  | Real | near,
 |  | Real | far
 | ) |  |

Builds a perspective projection matrix for the Camera based on the give frustum.

See also http://www.opengl.org/sdk/docs/man/xhtml/glFrustum.xml for more information.

Note:
This method sets fov() to -1.

void Camera::setProjectionAsOrtho ( Real offset = -0.5f )

Builds an orthographic projection matrix for the Camera based on the Camera's near/far planes and its Viewport's settings.

See also http://www.opengl.org/sdk/docs/man/xhtml/glOrtho.xml for more information. Equivalent to:

 setProjectionMatrix(
   mat4::ortho(
     offset, (Real)mViewport->width()  + offset,
     offset, (Real)mViewport->height() + offset,
     nearPlane(), farPlane())
 );

void Camera::setProjectionAsOrtho2D ( Real offset = -0.5f )

Builds an orthographic projection matrix for the Camera based on its Viewport's settings.

See also http://www.opengl.org/sdk/docs/man/xhtml/glOrtho2D.xml for more information.

Equivalent to:

 setProjectionMatrix(
   mat4::ortho(
     offset, viewport()->width()  + offset,
     offset, viewport()->height() + offset,
     -1, +1)
 );

void Camera::setViewMatrixAsLookAt | ( | const vec3 & | eye,
 |  | const vec3 & | center,
 |  | const vec3 & | up
 | ) |  |

void Camera::getViewMatrixAsLookAt | ( | vec3 & | eye,
 |  | vec3 & | look,
 |  | vec3 & | up,
 |  | vec3 & | right |
 | ) |  |  | const

bool Camera::project | ( | const vec4 & | in,
 |  | vec4 & | out |
 | ) |  |  | const

bool Camera::unproject | ( | const vec3 & | win,
 |  | vec4 & | out |
 | ) |  |  | const

Unprojects a vector from window coordinates to world coordinates.

Parameters:
win | The window coordinates point to be projected. Note that, in accordance to OpenGL conventions, the window coordinates have the Y axis pointing upwards and origin at the bottom left corner of the window.
out | The world coordinates of the projected point.
Note:
The w coordinate of win determines the position of the projected point along the ray passing through win. If w equals 0 then out will lay on the near clipping plane, if equals 1 then out will lay on the far clipping plane.

bool Camera::unproject ( std::vector< vec3 > & points ) const

Unprojects a set of points. See unproject(const vec3& win, vec4& out) for more information.

Ray Camera::computeRay | ( | int | winx,
 |  | int | winy
 | ) |  |

Computes the ray passing through the point <winx,winy>.

Parameters:
winx | The x position of the point defining the ray
winy | The y position of the point defining the ray
Note:
<winx,winy> is considered to be point in widows coordinate. In accordance to the OpenGL conventions the windows coordinates have origin on the bottom left corner of the window, with the Y axis pointing upwards. Most GUI libraries define the the orgin at the top left corner of the window and Y axis pointing downwards. You can convert such coordinates to OpenGL ones using the following simple formula: "opengl_y = window_height - coord_y".

Frustum Camera::computeRayFrustum | ( | int | winx,
 |  | int | winy
 | ) |  |

Computes a frustum suitable to cull object during ray intersection detection.

void vl::Camera::setNearFarClippingPlanesOptimized ( bool enable ) [inline]

Enables the optimization of the near and far clipping planes.

If the optimization is enabled the near and far clipping planes are adjusted to fit the sphere returned by sceneBoundingSphere(). Optimizing the near and far clipping planes results in an optimized usage of the z-buffer with the consequence of minimizing possible z-fighting artifacts and enhancing the rendering quality.

See also:
setSceneBoundingSphere()
Note:
Optimizing the near and far clipping planes can slightly slow down the rendering performances.

At the moment the near and far clipping planes optimization is available only when using a perspective projection matrix and not for orthographic projection matrices.

bool vl::Camera::nearFarClippingPlanesOptimized ( ) const [inline]

Set to true if the optimization of the near and far clipping planes is enabled.

If the optimization is enabled the near and far clipping planes are adjusted to fit the sphere returned by sceneBoundingSphere(). Optimizing the near and far clipping planes results in an optimized usage of the z-buffer with the consequence of minimizing possible z-fighting artifacts and enhancing the rendering quality.

See also:
setSceneBoundingSphere()
Note:
Optimizing the near and far clipping planes might slightly slow down the rendering performances if the scene contains several thousands of objects.

At the moment the near and far clipping planes optimization is available only when using a perspective projection matrix set up by setProjectionAsPerspective().

void vl::Camera::setSceneBoundingSphere ( const Sphere & sphere ) [inline]

The bounding sphere of the scene used to optimize the near and far clipping planes.

See also:
setNearFarClippingPlanesOptimized()

const Sphere& vl::Camera::sceneBoundingSphere ( ) const [inline]

The bounding sphere of the scene used to optimize the near and far clipping planes.

See also:
setNearFarClippingPlanesOptimized()

void Camera::adjustView | ( | const AABB & | aabb,
 |  | const vec3 & | dir,
 |  | const vec3 & | up,
 |  | Real | bias = 1.0f
 | ) |  |

Adjusts the camera position so that the given aabb can be properly viewed.

Parameters:
aabb | The AABB (in world coords) that should be visible from the newly computed camera position.
dir | The direction (in world coords) along which the camera should be displaced to view the given AABB.
up | The vector that defines the up direction (in world coords). Used to properly compute the new camera matrix.
bias | A bias factor used to adjust the computed camera distance from the given AABB. Values between 0 and 1 make the camera closer to the AABB center, values greater than 1 position the camera further away.

Member Data Documentation

mat4 vl::Camera::mViewMatrix [protected]

mat4 vl::Camera::mInverseViewMatrix [protected]

mat4 vl::Camera::mProjectionMatrix [protected]

ref<Viewport> vl::Camera::mViewport [protected]

Frustum vl::Camera::mFrustum [protected]

ref<Transform> vl::Camera::mFollowTransform [protected]

Real vl::Camera::mFOV [protected]

Real vl::Camera::mNearPlane [protected]

Real vl::Camera::mFarPlane [protected]

Sphere vl::Camera::mSceneBoundingSphere [protected]

bool vl::Camera::mActive [protected]

bool vl::Camera::mNearFarClippingPlanesOptimized [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolator< T > Class Template Reference

vl::CatmullRomInterpolator

vl::CatmullRomInterpolator< T > Class Template Reference

The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolator< T >:

vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolator ()
CatmullRomInterpolator (const std::vector< T > &path)
void | setupEndPoints (bool is_loop)
Call this function after having specified the control points if you want to automatically generate the start/end control points.
T | computePoint (float t) const
Samples the Catmull-Rom spline at the given point. The t parameter must be in the range 0.0 ... 1.0 included.
void | setPath (const std::vector< T > &path)
The control points defining the Catmull-Rom spline.
const std::vector< T > & | path () const
The control points defining the Catmull-Rom spline.
std::vector< T > & | path ()
The control points defining the Catmull-Rom spline.

Protected Attributes

std::vector< T > | mPath
std::vector< T > | mCatmullRomSpline

Detailed Description

template<typename T>
class vl::CatmullRomInterpolator< T >

The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation.

Catmull-Rom spline interpolation allows smoother interpolations than simple linear interpolation, is thus indicated for example when you want to smoothly interpolate from one position to another or from one color to another.

See also:
LinearInterpolator, Interpolator and the Interpolators Tutorial page.

Constructor & Destructor Documentation

template<typename T >
vl::CatmullRomInterpolator< T >::CatmullRomInterpolator ( ) [inline]

template<typename T >
vl::CatmullRomInterpolator< T >::CatmullRomInterpolator ( const std::vector< T > & path ) [inline]

Member Function Documentation

template<typename T >
void vl::CatmullRomInterpolator< T >::setupEndPoints ( bool is_loop ) [inline]

Call this function after having specified the control points if you want to automatically generate the start/end control points.

template<typename T >
T vl::CatmullRomInterpolator< T >::computePoint ( float t ) const [inline]

Samples the Catmull-Rom spline at the given point. The t parameter must be in the range 0.0 ... 1.0 included.

template<typename T >
void vl::CatmullRomInterpolator< T >::setPath ( const std::vector< T > & path ) [inline]

The control points defining the Catmull-Rom spline.

Because of the Catmull-Rom formula the interpolated path must start and end with an extra control point (one on each side) and cannot have less than 4 control points. You can also automatically generate such extra control points by calling the setupEndPoints() method.

template<typename T >
const std::vector<T>& vl::CatmullRomInterpolator< T >::path ( ) const [inline]

The control points defining the Catmull-Rom spline.

template<typename T >
std::vector<T>& vl::CatmullRomInterpolator< T >::path ( ) [inline]

The control points defining the Catmull-Rom spline.

Member Data Documentation

template<typename T >
std::vector<T> vl::CatmullRomInterpolator< T >::mPath [protected]

template<typename T >
std::vector<T> vl::CatmullRomInterpolator< T >::mCatmullRomSpline [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorDouble Class Reference

vl::CatmullRomInterpolatorDouble

vl::CatmullRomInterpolatorDouble Class Reference

Interpolates double values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorDouble:

vl::InterpolatorDouble vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorDouble ()
CatmullRomInterpolatorDouble (const std::vector< double > &path)
double | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorDouble_T * interpolator ()
const
CatmullRomInterpolatorDouble_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorDouble_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorDouble_T > 		mInterpolator

Detailed Description

Interpolates double values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorDouble::CatmullRomInterpolatorDouble ( ) [inline]

vl::CatmullRomInterpolatorDouble::CatmullRomInterpolatorDouble ( const std::vector< double > & path ) [inline]

Member Function Documentation

double vl::CatmullRomInterpolatorDouble::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDouble.

CatmullRomInterpolatorDouble_T* vl::CatmullRomInterpolatorDouble::interpolator ( ) [inline]

const CatmullRomInterpolatorDouble_T* vl::CatmullRomInterpolatorDouble::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorDouble::setInterpolator ( CatmullRomInterpolatorDouble_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorDouble_T> vl::CatmullRomInterpolatorDouble::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorDVec2 Class Reference

vl::CatmullRomInterpolatorDVec2

vl::CatmullRomInterpolatorDVec2 Class Reference

Interpolates vl::dvec2 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorDVec2:

vl::InterpolatorDVec2 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorDVec2 ()
CatmullRomInterpolatorDVec2 (const std::vector< vl::dvec2 > &path)
vl::dvec2 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorDVec2_T * interpolator ()
const
CatmullRomInterpolatorDVec2_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorDVec2_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorDVec2_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec2 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorDVec2::CatmullRomInterpolatorDVec2 ( ) [inline]

vl::CatmullRomInterpolatorDVec2::CatmullRomInterpolatorDVec2 ( const std::vector< vl::dvec2 > & path ) [inline]

Member Function Documentation

vl::dvec2 vl::CatmullRomInterpolatorDVec2::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec2.

CatmullRomInterpolatorDVec2_T* vl::CatmullRomInterpolatorDVec2::interpolator ( ) [inline]

const CatmullRomInterpolatorDVec2_T* vl::CatmullRomInterpolatorDVec2::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorDVec2::setInterpolator ( CatmullRomInterpolatorDVec2_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorDVec2_T> vl::CatmullRomInterpolatorDVec2::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorDVec3 Class Reference

vl::CatmullRomInterpolatorDVec3

vl::CatmullRomInterpolatorDVec3 Class Reference

Interpolates vl::dvec3 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorDVec3:

vl::InterpolatorDVec3 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorDVec3 ()
CatmullRomInterpolatorDVec3 (const std::vector< vl::dvec3 > &path)
vl::dvec3 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorDVec3_T * interpolator ()
const
CatmullRomInterpolatorDVec3_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorDVec3_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorDVec3_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec3 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorDVec3::CatmullRomInterpolatorDVec3 ( ) [inline]

vl::CatmullRomInterpolatorDVec3::CatmullRomInterpolatorDVec3 ( const std::vector< vl::dvec3 > & path ) [inline]

Member Function Documentation

vl::dvec3 vl::CatmullRomInterpolatorDVec3::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec3.

CatmullRomInterpolatorDVec3_T* vl::CatmullRomInterpolatorDVec3::interpolator ( ) [inline]

const CatmullRomInterpolatorDVec3_T* vl::CatmullRomInterpolatorDVec3::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorDVec3::setInterpolator ( CatmullRomInterpolatorDVec3_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorDVec3_T> vl::CatmullRomInterpolatorDVec3::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorDVec4 Class Reference

vl::CatmullRomInterpolatorDVec4

vl::CatmullRomInterpolatorDVec4 Class Reference

Interpolates vl::dvec4 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorDVec4:

vl::InterpolatorDVec4 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorDVec4 ()
CatmullRomInterpolatorDVec4 (const std::vector< vl::dvec4 > &path)
vl::dvec4 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorDVec4_T * interpolator ()
const
CatmullRomInterpolatorDVec4_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorDVec4_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorDVec4_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec4 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorDVec4::CatmullRomInterpolatorDVec4 ( ) [inline]

vl::CatmullRomInterpolatorDVec4::CatmullRomInterpolatorDVec4 ( const std::vector< vl::dvec4 > & path ) [inline]

Member Function Documentation

vl::dvec4 vl::CatmullRomInterpolatorDVec4::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec4.

CatmullRomInterpolatorDVec4_T* vl::CatmullRomInterpolatorDVec4::interpolator ( ) [inline]

const CatmullRomInterpolatorDVec4_T* vl::CatmullRomInterpolatorDVec4::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorDVec4::setInterpolator ( CatmullRomInterpolatorDVec4_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorDVec4_T> vl::CatmullRomInterpolatorDVec4::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorFloat Class Reference

vl::CatmullRomInterpolatorFloat

vl::CatmullRomInterpolatorFloat Class Reference

Interpolates float values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorFloat:

vl::InterpolatorFloat vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorFloat ()
CatmullRomInterpolatorFloat (const std::vector< float > &path)
float | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorFloat_T * interpolator ()
const
CatmullRomInterpolatorFloat_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorFloat_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorFloat_T > 		mInterpolator

Detailed Description

Interpolates float values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorFloat::CatmullRomInterpolatorFloat ( ) [inline]

vl::CatmullRomInterpolatorFloat::CatmullRomInterpolatorFloat ( const std::vector< float > & path ) [inline]

Member Function Documentation

float vl::CatmullRomInterpolatorFloat::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFloat.

CatmullRomInterpolatorFloat_T* vl::CatmullRomInterpolatorFloat::interpolator ( ) [inline]

const CatmullRomInterpolatorFloat_T* vl::CatmullRomInterpolatorFloat::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorFloat::setInterpolator ( CatmullRomInterpolatorFloat_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorFloat_T> vl::CatmullRomInterpolatorFloat::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorFVec2 Class Reference

vl::CatmullRomInterpolatorFVec2

vl::CatmullRomInterpolatorFVec2 Class Reference

Interpolates vl::fvec2 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorFVec2:

vl::InterpolatorFVec2 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorFVec2 ()
CatmullRomInterpolatorFVec2 (const std::vector< vl::fvec2 > &path)
vl::fvec2 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorFVec2_T * interpolator ()
const
CatmullRomInterpolatorFVec2_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorFVec2_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorFVec2_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec2 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorFVec2::CatmullRomInterpolatorFVec2 ( ) [inline]

vl::CatmullRomInterpolatorFVec2::CatmullRomInterpolatorFVec2 ( const std::vector< vl::fvec2 > & path ) [inline]

Member Function Documentation

vl::fvec2 vl::CatmullRomInterpolatorFVec2::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec2.

CatmullRomInterpolatorFVec2_T* vl::CatmullRomInterpolatorFVec2::interpolator ( ) [inline]

const CatmullRomInterpolatorFVec2_T* vl::CatmullRomInterpolatorFVec2::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorFVec2::setInterpolator ( CatmullRomInterpolatorFVec2_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorFVec2_T> vl::CatmullRomInterpolatorFVec2::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorFVec3 Class Reference

vl::CatmullRomInterpolatorFVec3

vl::CatmullRomInterpolatorFVec3 Class Reference

Interpolates vl::fvec3 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorFVec3:

vl::InterpolatorFVec3 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorFVec3 ()
CatmullRomInterpolatorFVec3 (const std::vector< vl::fvec3 > &path)
vl::fvec3 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorFVec3_T * interpolator ()
const
CatmullRomInterpolatorFVec3_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorFVec3_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorFVec3_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec3 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorFVec3::CatmullRomInterpolatorFVec3 ( ) [inline]

vl::CatmullRomInterpolatorFVec3::CatmullRomInterpolatorFVec3 ( const std::vector< vl::fvec3 > & path ) [inline]

Member Function Documentation

vl::fvec3 vl::CatmullRomInterpolatorFVec3::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec3.

CatmullRomInterpolatorFVec3_T* vl::CatmullRomInterpolatorFVec3::interpolator ( ) [inline]

const CatmullRomInterpolatorFVec3_T* vl::CatmullRomInterpolatorFVec3::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorFVec3::setInterpolator ( CatmullRomInterpolatorFVec3_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorFVec3_T> vl::CatmullRomInterpolatorFVec3::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CatmullRomInterpolatorFVec4 Class Reference

vl::CatmullRomInterpolatorFVec4

vl::CatmullRomInterpolatorFVec4 Class Reference

Interpolates vl::fvec4 values using a CatmullRomInterpolator. More...

#include <CatmullRomInterpolator.hpp>

Inheritance diagram for vl::CatmullRomInterpolatorFVec4:

vl::InterpolatorFVec4 vl::Interpolator vl::Object

List of all members.

Public Member Functions

CatmullRomInterpolatorFVec4 ()
CatmullRomInterpolatorFVec4 (const std::vector< vl::fvec4 > &path)
vl::fvec4 | computePoint (float t) const
Samples the interpolator at the given point.
CatmullRomInterpolatorFVec4_T * interpolator ()
const
CatmullRomInterpolatorFVec4_T * 		interpolator () const
void | setInterpolator (CatmullRomInterpolatorFVec4_T *interpolator)

Protected Attributes

vl::ref
< CatmullRomInterpolatorFVec4_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec4 values using a CatmullRomInterpolator.

Constructor & Destructor Documentation

vl::CatmullRomInterpolatorFVec4::CatmullRomInterpolatorFVec4 ( ) [inline]

vl::CatmullRomInterpolatorFVec4::CatmullRomInterpolatorFVec4 ( const std::vector< vl::fvec4 > & path ) [inline]

Member Function Documentation

vl::fvec4 vl::CatmullRomInterpolatorFVec4::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec4.

CatmullRomInterpolatorFVec4_T* vl::CatmullRomInterpolatorFVec4::interpolator ( ) [inline]

const CatmullRomInterpolatorFVec4_T* vl::CatmullRomInterpolatorFVec4::interpolator ( ) const [inline]

void vl::CatmullRomInterpolatorFVec4::setInterpolator ( CatmullRomInterpolatorFVec4_T * interpolator ) [inline]

Member Data Documentation

vl::ref<CatmullRomInterpolatorFVec4_T> vl::CatmullRomInterpolatorFVec4::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Clear Class Reference

vl::Clear

vl::Clear Class Reference

The Clear class is a Renderable used to clear the whole or a portion of the color, stencil or depth buffer. More...

#include <Clear.hpp>

Inheritance diagram for vl::Clear:

vl::Renderable vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Clear ()
virtual void | render (const Actor *, const OpenGLContext *, const Camera *) const
Renders the Renderable.
void | setClearColorBuffer (bool clear)
void | setClearDepthBuffer (bool clear)
void | setClearStencilBuffer (bool clear)
void | setClearColorValue (const fvec4 &clear_val)
void | setClearColorValueInt (const ivec4 &clear_val)
void | setClearColorValueUInt (const uvec4 &clear_val)
void | setClearDepthValue (float clear_val)
void | setClearStencilValue (int clear_val)
void | setClearColorMode (EClearColorMode mode)
EClearColorMode | clearColorMode () const
void | setScissorBox (int x, int y, int w, int h)
Defines which portion of the rendering buffers should be cleared.
void | getScissorBox (int &x, int &y, int &w, int &h)

Protected Member Functions

virtual void | computeBounds_Implementation ()

Protected Attributes

fvec4 mClearColorValue
ivec4 mClearColorValueInt
uvec4 mClearColorValueUInt
int | mScissorBox [4]
EClearColorMode mClearColorMode
float | mClearDepthValue
int | mClearStencilValue
bool | mClearColorBuffer
bool | mClearDepthBuffer
bool | mClearStencilBuffer

Detailed Description

The Clear class is a Renderable used to clear the whole or a portion of the color, stencil or depth buffer.

The Clear class is a special Renderable that wraps the functionalities of the following OpenGL functions:

  • glClear() - http://www.opengl.org/sdk/docs/man/xhtml/glClear.xml
  • glClearColor() - http://www.opengl.org/sdk/docs/man/xhtml/glClearColor.xml
  • glClearDepth() - http://www.opengl.org/sdk/docs/man/xhtml/glClearDepth.xml
  • glClearStencil() - http://www.opengl.org/sdk/docs/man/xhtml/glClearStencil.xml
  • glScissor() - http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml

Usually the color, depth and stencil buffers are cleared at the beginning of a rendering when the Viewport is initialized. To handle less common cases the Clear class allows you to perform a clear operation also in the middle of a rendering. Just bind it to an an Actor and setup the appropriate clearing options.

Note:
  • Binding a Transform to the same Actor will not affect the clearing operation in any way.
  • You still need to bind an Effect to the same Actor infact the Effect's renderRank() and blending state enabled/disabled might affect the rendering order of the Actor bound to your Clear object, i.e. the moment at which your buffers are cleared. In other words the usual rules to determine the rendering order of an Actor apply also when a Clear object is bound to it. For this reason in order to define the exact point at which the buffers are cleared you should pay special attention to your Actor's and Effect's renderRank() and Actor's renderBlock().
  • The following render states also affect the clearing process: ColorMask, StencilMask, DepthMask.

Constructor & Destructor Documentation

vl::Clear::Clear ( ) [inline]

Member Function Documentation

virtual const char* vl::Clear::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Renderable.

virtual void vl::Clear::render | ( | const Actor * | actor,
 |  | const OpenGLContext * | ,
 |  | const Camera * | camera |
 | ) |  |  | const [inline, virtual]

Renders the Renderable.

Implements vl::Renderable.

void vl::Clear::setClearColorBuffer ( bool clear ) [inline]

void vl::Clear::setClearDepthBuffer ( bool clear ) [inline]

void vl::Clear::setClearStencilBuffer ( bool clear ) [inline]

void vl::Clear::setClearColorValue ( const fvec4 & clear_val ) [inline]

void vl::Clear::setClearColorValueInt ( const ivec4 & clear_val ) [inline]

void vl::Clear::setClearColorValueUInt ( const uvec4 & clear_val ) [inline]

void vl::Clear::setClearDepthValue ( float clear_val ) [inline]

void vl::Clear::setClearStencilValue ( int clear_val ) [inline]

void vl::Clear::setClearColorMode ( EClearColorMode mode ) [inline]

EClearColorMode vl::Clear::clearColorMode ( ) const [inline]

void vl::Clear::setScissorBox | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h |
 | ) |  |  | [inline]

Defines which portion of the rendering buffers should be cleared.

The parameters 'x', 'y', 'z', 'w' specify a rectangular area in viewport coordinates. Such area is also clipped against the viewport borders. If 'w' or 'h' are set to -1 then the whole viewport is cleared.

void vl::Clear::getScissorBox | ( | int & | x,
 |  | int & | y,
 |  | int & | w,
 |  | int & | h |
 | ) |  |  | [inline]

virtual void vl::Clear::computeBounds_Implementation ( ) [inline, protected, virtual]

Implements vl::Renderable.

Member Data Documentation

fvec4 vl::Clear::mClearColorValue [protected]

ivec4 vl::Clear::mClearColorValueInt [protected]

uvec4 vl::Clear::mClearColorValueUInt [protected]

int vl::Clear::mScissorBox[4] [protected]

EClearColorMode vl::Clear::mClearColorMode [protected]

float vl::Clear::mClearDepthValue [protected]

int vl::Clear::mClearStencilValue [protected]

bool vl::Clear::mClearColorBuffer [protected]

bool vl::Clear::mClearDepthBuffer [protected]

bool vl::Clear::mClearStencilBuffer [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Clear.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ClipPlane Class Reference

vl::ClipPlane

vl::ClipPlane Class Reference

Wraps the OpenGL function glClipPlane(). More...

#include <ClipPlane.hpp>

Inheritance diagram for vl::ClipPlane:

vl::RenderState vl::Object

List of all members.

Public Member Functions

ClipPlane (int plane_index, Real o=0.0f, vec3 n=vec3(0, 0, 0))
ClipPlane (int plane_index, const vec3 &o, const vec3 &n)
virtual const char * | className ()
Returns the name of the class.
virtual void | disable () const
virtual void | enable () const
virtual ERenderState | type () const
virtual void | apply (const Camera *camera) const
void | followTransform (Transform *transform)
Transform * followedTransform ()
const Transform * | followedTransform () const
void | setPlaneIndex (int plane_index)
int | planeIndex () const
const Plane & | plane () const
void | setPlane (const Plane &plane)

Protected Attributes

int | mPlaneIndex
ref< Transform > mFollowedTransform
Plane mPlane

Detailed Description

Wraps the OpenGL function glClipPlane().

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::ClipPlane::ClipPlane | ( | int | plane_index,
 |  | Real | o = 0.0f,
 |  | vec3 | n = vec3(0,0,0) |
 | ) |  |  | [inline]

vl::ClipPlane::ClipPlane | ( | int | plane_index,
 |  | const vec3 & | o,
 |  | const vec3 & | n |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::ClipPlane::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual void vl::ClipPlane::disable ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

virtual void vl::ClipPlane::enable ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

virtual ERenderState vl::ClipPlane::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

virtual void vl::ClipPlane::apply ( const Camera * camera ) const [inline, virtual]

Implements vl::RenderState.

void vl::ClipPlane::followTransform ( Transform * transform ) [inline]

Transform* vl::ClipPlane::followedTransform ( ) [inline]

const Transform* vl::ClipPlane::followedTransform ( ) const [inline]

void vl::ClipPlane::setPlaneIndex ( int plane_index ) [inline]

int vl::ClipPlane::planeIndex ( ) const [inline]

const Plane& vl::ClipPlane::plane ( ) const [inline]

void vl::ClipPlane::setPlane ( const Plane & plane ) [inline]

Member Data Documentation

int vl::ClipPlane::mPlaneIndex [protected]

ref<Transform> vl::ClipPlane::mFollowedTransform [protected]

Plane vl::ClipPlane::mPlane [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ClipPlane.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Collection< T > Class Template Reference

vl::Collection

vl::Collection< T > Class Template Reference

Reference counted container that encapsulates the base functionalites of an std::vector<>. More...

#include <Collection.hpp>

Inheritance diagram for vl::Collection< T >:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Collection (const std::vector< ref< T > > &vector)
Collection ()
Collection & | operator= (const std::vector< ref< T > > &vector)
operator std::vector< ref< T > > () const
void | push_back (T *data)
void | pop_back ()
void | resize (int size)
int | size () const
bool | empty () const
void | clear ()
const T * | back () const
T * | back ()
void | reserve (int capacity)
int | capacity () const
const ref< T > & | operator[] (int i) const
ref< T > & | operator[] (int i)
const T * | at (int i) const
T * | at (int i)
void | swap (Collection &other)
void | sort ()
int | find (T *obj) const
void | shrink ()
void | push_back (const Collection< T > &objs)
void | insert (int start, const Collection< T > &objs)
void | set (const Collection< T > &objs)
void | erase (int start, int count)
void | set (int index, T *obj)
void | insert (int index, T *obj)
void | erase (const T *data)
void | eraseAt (int index)
const std::vector< ref< T > > & | vector () const
std::vector< ref< T > > & | vector ()

Static Protected Member Functions

static bool | less (const ref< T > &a, const ref< T > &b)

Protected Attributes

std::vector< ref< T > > | mVector

Detailed Description

template<typename T>
class vl::Collection< T >

Reference counted container that encapsulates the base functionalites of an std::vector<>.

This container can be used only with objects whose classes derive from Object.

Constructor & Destructor Documentation

template<typename T>
vl::Collection< T >::Collection ( const std::vector< ref< T > > & vector ) [inline]

template<typename T>
vl::Collection< T >::Collection ( ) [inline]

Member Function Documentation

template<typename T>
virtual const char* vl::Collection< T >::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::ShaderSequence.

template<typename T>
Collection& vl::Collection< T >::operator= ( const std::vector< ref< T > > & vector ) [inline]

template<typename T>
vl::Collection< T >::operator std::vector< ref< T > > ( ) const [inline]

template<typename T>
void vl::Collection< T >::push_back ( T * data ) [inline]

template<typename T>
void vl::Collection< T >::pop_back ( ) [inline]

template<typename T>
void vl::Collection< T >::resize ( int size ) [inline]

template<typename T>
int vl::Collection< T >::size ( ) const [inline]

template<typename T>
bool vl::Collection< T >::empty ( ) const [inline]

template<typename T>
void vl::Collection< T >::clear ( ) [inline]

template<typename T>
const T* vl::Collection< T >::back ( ) const [inline]

template<typename T>
T* vl::Collection< T >::back ( ) [inline]

template<typename T>
void vl::Collection< T >::reserve ( int capacity ) [inline]

template<typename T>
int vl::Collection< T >::capacity ( ) const [inline]

template<typename T>
const ref<T>& vl::Collection< T >::operator[] ( int i ) const [inline]

template<typename T>
ref<T>& vl::Collection< T >::operator[] ( int i ) [inline]

template<typename T>
const T* vl::Collection< T >::at ( int i ) const [inline]

template<typename T>
T* vl::Collection< T >::at ( int i ) [inline]

template<typename T>
void vl::Collection< T >::swap ( Collection< T > & other ) [inline]

template<typename T>
void vl::Collection< T >::sort ( ) [inline]

template<typename T>
int vl::Collection< T >::find ( T * obj ) const [inline]

template<typename T>
void vl::Collection< T >::shrink ( ) [inline]

template<typename T>
void vl::Collection< T >::push_back ( const Collection< T > & objs ) [inline]

template<typename T>
void vl::Collection< T >::insert | ( | int | start,
 |  | const Collection< T > & | objs |
 | ) |  |  | [inline]

template<typename T>
void vl::Collection< T >::set ( const Collection< T > & objs ) [inline]

template<typename T>
void vl::Collection< T >::erase | ( | int | start,
 |  | int | count |
 | ) |  |  | [inline]

template<typename T>
void vl::Collection< T >::set | ( | int | index,
 |  | T * | obj |
 | ) |  |  | [inline]

template<typename T>
void vl::Collection< T >::insert | ( | int | index,
 |  | T * | obj |
 | ) |  |  | [inline]

template<typename T>
void vl::Collection< T >::erase ( const T * data ) [inline]

template<typename T>
void vl::Collection< T >::eraseAt ( int index ) [inline]

template<typename T>
const std::vector< ref<T> >& vl::Collection< T >::vector ( ) const [inline]

template<typename T>
std::vector< ref<T> >& vl::Collection< T >::vector ( ) [inline]

template<typename T>
static bool vl::Collection< T >::less | ( | const ref< T > & | a,
 |  | const ref< T > & | b |
 | ) |  |  | [inline, static, protected]

Member Data Documentation

template<typename T>
std::vector< ref<T> > vl::Collection< T >::mVector [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Collection.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::ColorMask Class Reference

vl::ColorMask

vl::ColorMask Class Reference

Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::ColorMask:

vl::RenderState vl::Object

List of all members.

Public Member Functions

ColorMask (bool red=true, bool green=true, bool blue=true, bool alpha=true)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (bool red, bool green, bool blue, bool alpha)
void | setRed (bool red)
void | setGreen (bool green)
void | setBlue (bool blue)
void | setAlpha (bool alpha)
bool | red () const
bool | green () const
bool | blue () const
bool | alpha () const

Protected Attributes

bool | mRed
bool | mGreen
bool | mBlue
bool | mAlpha

Detailed Description

Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::ColorMask::ColorMask | ( | bool | red = true,
 |  | bool | green = true,
 |  | bool | blue = true,
 |  | bool | alpha = true |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::ColorMask::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::ColorMask::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void ColorMask::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::ColorMask::set | ( | bool | red,
 |  | bool | green,
 |  | bool | blue,
 |  | bool | alpha |
 | ) |  |  | [inline]

void vl::ColorMask::setRed ( bool red ) [inline]

void vl::ColorMask::setGreen ( bool green ) [inline]

void vl::ColorMask::setBlue ( bool blue ) [inline]

void vl::ColorMask::setAlpha ( bool alpha ) [inline]

bool vl::ColorMask::red ( ) const [inline]

bool vl::ColorMask::green ( ) const [inline]

bool vl::ColorMask::blue ( ) const [inline]

bool vl::ColorMask::alpha ( ) const [inline]

Member Data Documentation

bool vl::ColorMask::mRed [protected]

bool vl::ColorMask::mGreen [protected]

bool vl::ColorMask::mBlue [protected]

bool vl::ColorMask::mAlpha [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::CopyTexSubImage Class Reference

vl::CopyTexSubImage

vl::CopyTexSubImage Class Reference

Wrapper class of the OpenGL function glCopyTexSubImage. More...

#include <CopyTexSubImage.hpp>

Inheritance diagram for vl::CopyTexSubImage:

vl::RenderingCallback vl::Object vl::CopyTexSubImage1D vl::CopyTexSubImage2D vl::CopyTexSubImage3D

List of all members.

Public Member Functions

CopyTexSubImage ()
EReadDrawBuffer | readBuffer () const
void | setReadBuffer (EReadDrawBuffer render_buffer)
virtual bool | renderingCallback (const RenderingAbstract *, ERenderingCallback reason)
Implements the actual code to be executed upon callback activation.
virtual void | copyPixels ()=0
Copies the pixels from the specified read buffer to the specified texture.

Protected Attributes

EReadDrawBuffer mReadBuffer

Detailed Description

Wrapper class of the OpenGL function glCopyTexSubImage.

Is the base class of CopyTexSubImage1D, CopyTexSubImage2D, CopyTexSubImage3D. Copies a rectangular pixels area from the specified read buffer to the specified portion of the texture. Can be bound to a Rendering as a RenderingCallback in order to automatically copy the result of a rendering into a texture, see Rendering.

Note:
This class supports Frame-Buffer-Objects, 3D textures, cubemaps.
See also:
FBORenderTarget, FBOAttachmentAbstract, Rendering, RenderingCallback, CopyTexSubImage1D, CopyTexSubImage2D, CopyTexSubImage3D

Constructor & Destructor Documentation

vl::CopyTexSubImage::CopyTexSubImage ( ) [inline]

Member Function Documentation

EReadDrawBuffer vl::CopyTexSubImage::readBuffer ( ) const [inline]

void vl::CopyTexSubImage::setReadBuffer ( EReadDrawBuffer render_buffer ) [inline]

virtual bool vl::CopyTexSubImage::renderingCallback | ( | const RenderingAbstract * | rendering,
 |  | ERenderingCallback | reason |
 | ) |  |  | [inline, virtual]

Implements the actual code to be executed upon callback activation.

Returns:
true if the callback reacted to the given reason

Implements vl::RenderingCallback.

virtual void vl::CopyTexSubImage::copyPixels ( ) [pure virtual]

Copies the pixels from the specified read buffer to the specified texture.

Implemented in vl::CopyTexSubImage1D, vl::CopyTexSubImage2D, and vl::CopyTexSubImage3D.

Member Data Documentation

EReadDrawBuffer vl::CopyTexSubImage::mReadBuffer [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CopyTexSubImage1D Class Reference

vl::CopyTexSubImage1D

vl::CopyTexSubImage1D Class Reference

Wraps glCopyTexSubImage1D, see also CopyTexSubImage. More...

#include <CopyTexSubImage.hpp>

Inheritance diagram for vl::CopyTexSubImage1D:

vl::CopyTexSubImage vl::RenderingCallback vl::Object

List of all members.

Public Member Functions

CopyTexSubImage1D (int level, int xoffset, int x, int y, int width, Texture *texture=NULL, EReadDrawBuffer read_buffer=RDB_BACK_LEFT)
virtual const char * | className ()
Returns the name of the class.
void | setTexture (Texture *tex)
void | setLevel (int level)
void | setXOffset (int xoffset)
void | setX (int x)
void | setY (int y)
void | setWidth (int width)
Texture * texture ()
const Texture * | texture () const
int | level () const
int | xoffset () const
int | x () const
int | y () const
int | width () const
virtual void | copyPixels ()
Copies the pixels from the specified read buffer to the specified texture.

Protected Attributes

ref< Texture > mTexture
int | mLevel
int | mXOffset
int | mX
int | mY
int | mWidth

Detailed Description

Wraps glCopyTexSubImage1D, see also CopyTexSubImage.

Constructor & Destructor Documentation

vl::CopyTexSubImage1D::CopyTexSubImage1D | ( | int | level,
 |  | int | xoffset,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | Texture * | texture = NULL,
 |  | EReadDrawBuffer | read_buffer = RDB_BACK_LEFT |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::CopyTexSubImage1D::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderingCallback.

void vl::CopyTexSubImage1D::setTexture ( Texture * tex ) [inline]

void vl::CopyTexSubImage1D::setLevel ( int level ) [inline]

void vl::CopyTexSubImage1D::setXOffset ( int xoffset ) [inline]

void vl::CopyTexSubImage1D::setX ( int x ) [inline]

void vl::CopyTexSubImage1D::setY ( int y ) [inline]

void vl::CopyTexSubImage1D::setWidth ( int width ) [inline]

Texture* vl::CopyTexSubImage1D::texture ( ) [inline]

const Texture* vl::CopyTexSubImage1D::texture ( ) const [inline]

int vl::CopyTexSubImage1D::level ( ) const [inline]

int vl::CopyTexSubImage1D::xoffset ( ) const [inline]

int vl::CopyTexSubImage1D::x ( ) const [inline]

int vl::CopyTexSubImage1D::y ( ) const [inline]

int vl::CopyTexSubImage1D::width ( ) const [inline]

virtual void vl::CopyTexSubImage1D::copyPixels ( ) [inline, virtual]

Copies the pixels from the specified read buffer to the specified texture.

Implements vl::CopyTexSubImage.

Member Data Documentation

ref<Texture> vl::CopyTexSubImage1D::mTexture [protected]

int vl::CopyTexSubImage1D::mLevel [protected]

int vl::CopyTexSubImage1D::mXOffset [protected]

int vl::CopyTexSubImage1D::mX [protected]

int vl::CopyTexSubImage1D::mY [protected]

int vl::CopyTexSubImage1D::mWidth [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CopyTexSubImage2D Class Reference

vl::CopyTexSubImage2D

vl::CopyTexSubImage2D Class Reference

Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures. More...

#include <CopyTexSubImage.hpp>

Inheritance diagram for vl::CopyTexSubImage2D:

vl::CopyTexSubImage vl::RenderingCallback vl::Object

List of all members.

Public Member Functions

CopyTexSubImage2D (int level, int xoffset, int yoffset, int x, int y, int width, int height, Texture *texture=NULL, ETex2DTarget target=T2DT_TEXTURE_2D, EReadDrawBuffer read_buffer=RDB_BACK_LEFT)
virtual const char * | className ()
Returns the name of the class.
void | setTexture (Texture *tex)
void | setLevel (int level)
void | setXOffset (int xoffset)
void | setYOffset (int yoffset)
void | setX (int x)
void | setY (int y)
void | setWidth (int width)
void | setHeight (int height)
void | setTarget (ETex2DTarget target)
Texture * texture ()
const Texture * | texture () const
int | level () const
int | xoffset () const
int | yoffset () const
int | x () const
int | y () const
int | width () const
int | height () const
ETex2DTarget | target () const
virtual void | copyPixels ()
Copies the pixels from the specified read buffer to the specified texture.

Protected Attributes

ref< Texture > mTexture
int | mLevel
int | mXOffset
int | mYOffset
int | mX
int | mY
int | mWidth
int | mHeight
ETex2DTarget mTarget

Detailed Description

Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures.

Constructor & Destructor Documentation

vl::CopyTexSubImage2D::CopyTexSubImage2D | ( | int | level,
 |  | int | xoffset,
 |  | int | yoffset,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height,
 |  | Texture * | texture = NULL,
 |  | ETex2DTarget | target = T2DT_TEXTURE_2D,
 |  | EReadDrawBuffer | read_buffer = RDB_BACK_LEFT |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::CopyTexSubImage2D::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderingCallback.

void vl::CopyTexSubImage2D::setTexture ( Texture * tex ) [inline]

void vl::CopyTexSubImage2D::setLevel ( int level ) [inline]

void vl::CopyTexSubImage2D::setXOffset ( int xoffset ) [inline]

void vl::CopyTexSubImage2D::setYOffset ( int yoffset ) [inline]

void vl::CopyTexSubImage2D::setX ( int x ) [inline]

void vl::CopyTexSubImage2D::setY ( int y ) [inline]

void vl::CopyTexSubImage2D::setWidth ( int width ) [inline]

void vl::CopyTexSubImage2D::setHeight ( int height ) [inline]

void vl::CopyTexSubImage2D::setTarget ( ETex2DTarget target ) [inline]

Texture* vl::CopyTexSubImage2D::texture ( ) [inline]

const Texture* vl::CopyTexSubImage2D::texture ( ) const [inline]

int vl::CopyTexSubImage2D::level ( ) const [inline]

int vl::CopyTexSubImage2D::xoffset ( ) const [inline]

int vl::CopyTexSubImage2D::yoffset ( ) const [inline]

int vl::CopyTexSubImage2D::x ( ) const [inline]

int vl::CopyTexSubImage2D::y ( ) const [inline]

int vl::CopyTexSubImage2D::width ( ) const [inline]

int vl::CopyTexSubImage2D::height ( ) const [inline]

ETex2DTarget vl::CopyTexSubImage2D::target ( ) const [inline]

virtual void vl::CopyTexSubImage2D::copyPixels ( ) [inline, virtual]

Copies the pixels from the specified read buffer to the specified texture.

Implements vl::CopyTexSubImage.

Member Data Documentation

ref<Texture> vl::CopyTexSubImage2D::mTexture [protected]

int vl::CopyTexSubImage2D::mLevel [protected]

int vl::CopyTexSubImage2D::mXOffset [protected]

int vl::CopyTexSubImage2D::mYOffset [protected]

int vl::CopyTexSubImage2D::mX [protected]

int vl::CopyTexSubImage2D::mY [protected]

int vl::CopyTexSubImage2D::mWidth [protected]

int vl::CopyTexSubImage2D::mHeight [protected]

ETex2DTarget vl::CopyTexSubImage2D::mTarget [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CopyTexSubImage3D Class Reference

vl::CopyTexSubImage3D

vl::CopyTexSubImage3D Class Reference

Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures. More...

#include <CopyTexSubImage.hpp>

Inheritance diagram for vl::CopyTexSubImage3D:

vl::CopyTexSubImage vl::RenderingCallback vl::Object

List of all members.

Public Member Functions

CopyTexSubImage3D (int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height, Texture *texture, EReadDrawBuffer read_buffer=RDB_BACK_LEFT)
virtual const char * | className ()
Returns the name of the class.
void | setTexture (Texture *tex)
void | setLevel (int level)
void | setXOffset (int xoffset)
void | setYOffset (int yoffset)
void | setZOffset (int zoffset)
void | setX (int x)
void | setY (int y)
void | setWidth (int width)
void | setHeight (int height)
Texture * texture ()
const Texture * | texture () const
int | level () const
int | xoffset () const
int | yoffset () const
int | zoffset () const
int | x () const
int | y () const
int | width () const
int | height () const
virtual void | copyPixels ()
Copies the pixels from the specified read buffer to the specified texture.

Protected Attributes

ref< Texture > mTexture
int | mLevel
int | mXOffset
int | mYOffset
int | mZOffset
int | mX
int | mY
int | mWidth
int | mHeight

Detailed Description

Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures.

Constructor & Destructor Documentation

vl::CopyTexSubImage3D::CopyTexSubImage3D | ( | int | level,
 |  | int | xoffset,
 |  | int | yoffset,
 |  | int | zoffset,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height,
 |  | Texture * | texture,
 |  | EReadDrawBuffer | read_buffer = RDB_BACK_LEFT |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::CopyTexSubImage3D::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderingCallback.

void vl::CopyTexSubImage3D::setTexture ( Texture * tex ) [inline]

void vl::CopyTexSubImage3D::setLevel ( int level ) [inline]

void vl::CopyTexSubImage3D::setXOffset ( int xoffset ) [inline]

void vl::CopyTexSubImage3D::setYOffset ( int yoffset ) [inline]

void vl::CopyTexSubImage3D::setZOffset ( int zoffset ) [inline]

void vl::CopyTexSubImage3D::setX ( int x ) [inline]

void vl::CopyTexSubImage3D::setY ( int y ) [inline]

void vl::CopyTexSubImage3D::setWidth ( int width ) [inline]

void vl::CopyTexSubImage3D::setHeight ( int height ) [inline]

Texture* vl::CopyTexSubImage3D::texture ( ) [inline]

const Texture* vl::CopyTexSubImage3D::texture ( ) const [inline]

int vl::CopyTexSubImage3D::level ( ) const [inline]

int vl::CopyTexSubImage3D::xoffset ( ) const [inline]

int vl::CopyTexSubImage3D::yoffset ( ) const [inline]

int vl::CopyTexSubImage3D::zoffset ( ) const [inline]

int vl::CopyTexSubImage3D::x ( ) const [inline]

int vl::CopyTexSubImage3D::y ( ) const [inline]

int vl::CopyTexSubImage3D::width ( ) const [inline]

int vl::CopyTexSubImage3D::height ( ) const [inline]

virtual void vl::CopyTexSubImage3D::copyPixels ( ) [inline, virtual]

Copies the pixels from the specified read buffer to the specified texture.

Implements vl::CopyTexSubImage.

Member Data Documentation

ref<Texture> vl::CopyTexSubImage3D::mTexture [protected]

int vl::CopyTexSubImage3D::mLevel [protected]

int vl::CopyTexSubImage3D::mXOffset [protected]

int vl::CopyTexSubImage3D::mYOffset [protected]

int vl::CopyTexSubImage3D::mZOffset [protected]

int vl::CopyTexSubImage3D::mX [protected]

int vl::CopyTexSubImage3D::mY [protected]

int vl::CopyTexSubImage3D::mWidth [protected]

int vl::CopyTexSubImage3D::mHeight [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CRC32CheckSum Class Reference

vl::CRC32CheckSum

vl::CRC32CheckSum Class Reference

Computes the a CRC32 checksum of a given buffer or VirtualFile. More...

#include <CRC32CheckSum.hpp>

List of all members.

Public Member Functions

CRC32CheckSum ()
Constructor.
unsigned int | compute (const void *buf, int length)
unsigned int | compute (VirtualFile *stream)
void | startCRC32 ()
unsigned int | finalizeCRC32 ()
void | continueCRC32 (unsigned char *ptr, int length)

Protected Member Functions

void | crc32_init ()
unsigned int | reflect (unsigned int val, char ch)

Protected Attributes

unsigned int | mCRC32
unsigned int | crc32_table [256]

Detailed Description

Computes the a CRC32 checksum of a given buffer or VirtualFile.

Constructor & Destructor Documentation

vl::CRC32CheckSum::CRC32CheckSum ( ) [inline]

Constructor.

Member Function Documentation

unsigned int vl::CRC32CheckSum::compute | ( | const void * | buf,
 |  | int | length |
 | ) |  |  | [inline]

unsigned int vl::CRC32CheckSum::compute ( VirtualFile * stream ) [inline]

void vl::CRC32CheckSum::startCRC32 ( ) [inline]

unsigned int vl::CRC32CheckSum::finalizeCRC32 ( ) [inline]

void vl::CRC32CheckSum::continueCRC32 | ( | unsigned char * | ptr,
 |  | int | length |
 | ) |  |  | [inline]

void vl::CRC32CheckSum::crc32_init ( ) [inline, protected]

unsigned int vl::CRC32CheckSum::reflect | ( | unsigned int | val,
 |  | char | ch |
 | ) |  |  | [inline, protected]

Member Data Documentation

unsigned int vl::CRC32CheckSum::mCRC32 [protected]

unsigned int vl::CRC32CheckSum::crc32_table[256] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CRC32CheckSum.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::CullFace Class Reference

vl::CullFace

vl::CullFace Class Reference

Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::CullFace:

vl::RenderState vl::Object

List of all members.

Public Member Functions

CullFace (EPolygonFace cullface=PF_BACK)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EPolygonFace facemode)
EPolygonFace | faceMode () const

Protected Attributes

EPolygonFace mFaceMode

Detailed Description

Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_CULL_FACE

Constructor & Destructor Documentation

vl::CullFace::CullFace ( EPolygonFace cullface = PF_BACK ) [inline]

Member Function Documentation

virtual const char* vl::CullFace::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::CullFace::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void CullFace::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::CullFace::set ( EPolygonFace facemode ) [inline]

EPolygonFace vl::CullFace::faceMode ( ) const [inline]

Member Data Documentation

EPolygonFace vl::CullFace::mFaceMode [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::DepthFunc Class Reference

vl::DepthFunc

vl::DepthFunc Class Reference

Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::DepthFunc:

vl::RenderState vl::Object

List of all members.

Public Member Functions

DepthFunc (EFunction depthfunc=FU_LESS)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EFunction depthfunc)
EFunction | depthFunc () const

Protected Attributes

EFunction mDepthFunc

Detailed Description

Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_DEPTH_TEST

Constructor & Destructor Documentation

vl::DepthFunc::DepthFunc ( EFunction depthfunc = FU_LESS ) [inline]

Member Function Documentation

virtual const char* vl::DepthFunc::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::DepthFunc::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void DepthFunc::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::DepthFunc::set ( EFunction depthfunc ) [inline]

EFunction vl::DepthFunc::depthFunc ( ) const [inline]

Member Data Documentation

EFunction vl::DepthFunc::mDepthFunc [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::DepthMask Class Reference

vl::DepthMask

vl::DepthMask Class Reference

Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::DepthMask:

vl::RenderState vl::Object

List of all members.

Public Member Functions

DepthMask (bool depthmask=true)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (bool depthmask)
bool | depthMask () const

Protected Attributes

bool | mDepthMask

Detailed Description

Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::DepthMask::DepthMask ( bool depthmask = true ) [inline]

Member Function Documentation

virtual const char* vl::DepthMask::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::DepthMask::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void DepthMask::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::DepthMask::set ( bool depthmask ) [inline]

bool vl::DepthMask::depthMask ( ) const [inline]

Member Data Documentation

bool vl::DepthMask::mDepthMask [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::DepthRange Class Reference

vl::DepthRange

vl::DepthRange Class Reference

Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::DepthRange:

vl::RenderState vl::Object

List of all members.

Public Member Functions

DepthRange ()
DepthRange (float znear, float zfar)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (float znear, float zfar)
void | setZNear (float znear)
void | setZFar (float zfar)
float | zNear () const
float | zFar () const

Protected Attributes

float | mZNear
float | mZFar

Detailed Description

Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_DEPTH_TEST

Constructor & Destructor Documentation

vl::DepthRange::DepthRange ( ) [inline]

vl::DepthRange::DepthRange | ( | float | znear,
 |  | float | zfar |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::DepthRange::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::DepthRange::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void DepthRange::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::DepthRange::set | ( | float | znear,
 |  | float | zfar |
 | ) |  |  | [inline]

void vl::DepthRange::setZNear ( float znear ) [inline]

void vl::DepthRange::setZFar ( float zfar ) [inline]

float vl::DepthRange::zNear ( ) const [inline]

float vl::DepthRange::zFar ( ) const [inline]

Member Data Documentation

float vl::DepthRange::mZNear [protected]

float vl::DepthRange::mZFar [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::DepthSortCallback Class Reference

vl::DepthSortCallback

vl::DepthSortCallback Class Reference

The DepthSortCallback class sorts the primitives of the Geometry object bound to the Actor in which the callback is installed. More...

#include <DepthSortCallback.hpp>

Inheritance diagram for vl::DepthSortCallback:

vl::ActorRenderingCallback vl::Object

List of all members.

Classes

class | Line
class | Point
class | PrimitiveZ
class | Quad
class | Sorter_Back_To_Front
class | Sorter_Front_To_Back
class | Triangle

Public Member Functions

DepthSortCallback ()
virtual const char * | className ()
Returns the name of the class.
virtual void | operator() (const Camera *cam, Actor *actor, Renderable *renderable, const Shader *, int pass)
Performs the actual sorting.
template<typename T , typename deT >
void | sort (deT *polys, std::vector< Point< T > > &sorted_points, std::vector< Line< T > > &sorted_lines, std::vector< Triangle< T > > &sorted_triangles, std::vector< Quad< T > > &sorted_quads)
ESortMode | sortMode () const
void | setSortMode (ESortMode sort_mode)
void | invalidateCache ()
Forces sorting at the next rendering.

Protected Attributes

ref< ArrayFVec3 > mEyeSpaceVerts
std::vector< PrimitiveZ > | mPrimitiveZ
std::vector< PointUInt > | mSortedPointsUInt
std::vector< LineUInt > | mSortedLinesUInt
std::vector< TriangleUInt > | mSortedTrianglesUInt
std::vector< QuadUInt > | mSortedQuadsUInt
std::vector< PointUShort > | mSortedPointsUShort
std::vector< LineUShort > | mSortedLinesUShort
std::vector< TriangleUShort > | mSortedTrianglesUShort
std::vector< QuadUShort > | mSortedQuadsUShort
std::vector< PointUByte > | mSortedPointsUByte
std::vector< LineUByte > | mSortedLinesUByte
std::vector< TriangleUByte > | mSortedTrianglesUByte
std::vector< QuadUByte > | mSortedQuadsUByte
vl::mat4 mCacheMatrix
ESortMode mSortMode

Detailed Description

The DepthSortCallback class sorts the primitives of the Geometry object bound to the Actor in which the callback is installed.

This callback in order to work requires the following conditions:

  • The Actor must be bound to a Geometry
  • The bound Geometry must have a Geometry::vertexArray() of type ArrayFVec3
  • Sorts only DrawElementsUInt/UShort/UByte objects with primitive type: PT_POINTS, PT_LINES, PT_TRIANGLES, PT_QUADS

Despite the fact that the condition list seems to be quite limiting it actually covers the most common usage cases. Furthermore the use of DrawElements* and the primitive types PT_POINTS, PT_LINES, PT_TRIANGLES, PT_QUADS grant the maximum flexibility.

Note:
  • This callback works well with different LODs.
  • This callback works well with multipassing, the sorting is done only once.

Remarks:
  • The sorting is based on the position of the vertices as specified by Geometry::vertexArray() and for obvious reasons cannot take into consideration transformations made in the vertex shader or in the geometry shader.
  • The sorting is performed on a per Primitives basis. For example, if a Geometry has 2 Primitives A and B bound to it, then the polygons, lines or points of A will alway be rendered before the ones specified by B.

See also:
Transparency and Polygon Depth Sorting Tutorial

Constructor & Destructor Documentation

vl::DepthSortCallback::DepthSortCallback ( ) [inline]

Member Function Documentation

virtual const char* vl::DepthSortCallback::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

virtual void vl::DepthSortCallback::operator() | ( | const Camera * | cam,
 |  | Actor * | actor,
 |  | Renderable * | renderable,
 |  | const Shader * | ,
 |  | int | pass |
 | ) |  |  | [inline, virtual]

Performs the actual sorting.

Implements vl::ActorRenderingCallback.

template<typename T , typename deT >
void vl::DepthSortCallback::sort | ( | deT * | polys,
 |  | std::vector< Point< T > > & | sorted_points,
 |  | std::vector< Line< T > > & | sorted_lines,
 |  | std::vector< Triangle< T > > & | sorted_triangles,
 |  | std::vector< Quad< T > > & | sorted_quads |
 | ) |  |  | [inline]

ESortMode vl::DepthSortCallback::sortMode ( ) const [inline]

void vl::DepthSortCallback::setSortMode ( ESortMode sort_mode ) [inline]

void vl::DepthSortCallback::invalidateCache ( ) [inline]

Forces sorting at the next rendering.

Member Data Documentation

ref<ArrayFVec3> vl::DepthSortCallback::mEyeSpaceVerts [protected]

std::vector<PrimitiveZ> vl::DepthSortCallback::mPrimitiveZ [protected]

std::vector<PointUInt> vl::DepthSortCallback::mSortedPointsUInt [protected]

std::vector<LineUInt> vl::DepthSortCallback::mSortedLinesUInt [protected]

std::vector<TriangleUInt> vl::DepthSortCallback::mSortedTrianglesUInt [protected]

std::vector<QuadUInt> vl::DepthSortCallback::mSortedQuadsUInt [protected]

std::vector<PointUShort> vl::DepthSortCallback::mSortedPointsUShort [protected]

std::vector<LineUShort> vl::DepthSortCallback::mSortedLinesUShort [protected]

std::vector<TriangleUShort> vl::DepthSortCallback::mSortedTrianglesUShort [protected]

std::vector<QuadUShort> vl::DepthSortCallback::mSortedQuadsUShort [protected]

std::vector<PointUByte> vl::DepthSortCallback::mSortedPointsUByte [protected]

std::vector<LineUByte> vl::DepthSortCallback::mSortedLinesUByte [protected]

std::vector<TriangleUByte> vl::DepthSortCallback::mSortedTrianglesUByte [protected]

std::vector<QuadUByte> vl::DepthSortCallback::mSortedQuadsUByte [protected]

vl::mat4 vl::DepthSortCallback::mCacheMatrix [protected]

ESortMode vl::DepthSortCallback::mSortMode [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DepthSortCallback.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DiskDirectory Class Reference

vl::DiskDirectory

vl::DiskDirectory Class Reference

A VirtualDirectory that operates on reguar disk directories. More...

#include <DiskDirectory.hpp>

Inheritance diagram for vl::DiskDirectory:

vl::VirtualDirectory vl::Object

List of all members.

Public Member Functions

DiskDirectory ()
DiskDirectory (const String &path)
virtual const char * | className ()
Returns the name of the class.
void | listFilesRecursive (std::vector< String > &file_list) const
Use carefully this function, since this search the whole given file system tree.
void | listFiles (std::vector< String > &file_list, bool append=false) const
void | listFiles (std::vector< ref< DiskFile > > &file_list, bool append=false) const
void | listSubDirs (std::vector< String > &dirs, bool append=false) const
ref< DiskDirectory > | diskSubDir (const String &subdir_name) const
ref< VirtualDirectory > | subDir (const String &subdir_name) const
virtual ref< VirtualFile > | file (const String &name) const
Returns the VirtualFile with the given name if any, NULL otherwise.
virtual ref< DiskFile > | diskFile (const String &name) const
bool | exists () const

Protected Member Functions

void | listFilesRecursive_internal (std::vector< String > &file_list) const

Detailed Description

A VirtualDirectory that operates on reguar disk directories.

See also:
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

DiskDirectory::DiskDirectory ( )

DiskDirectory::DiskDirectory ( const String & path )

Member Function Documentation

virtual const char* vl::DiskDirectory::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualDirectory.

void DiskDirectory::listFilesRecursive ( std::vector< String > & file_list ) const [virtual]

Use carefully this function, since this search the whole given file system tree.

Implements vl::VirtualDirectory.

void vl::DiskDirectory::listFiles | ( | std::vector< String > & | file_list,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

void vl::DiskDirectory::listFiles | ( | std::vector< ref< DiskFile > > & | file_list,
 |  | bool | append = false |
 | ) |  |  | const

void vl::DiskDirectory::listSubDirs | ( | std::vector< String > & | dirs,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

ref< DiskDirectory > DiskDirectory::diskSubDir ( const String & subdir_name ) const

ref<VirtualDirectory> vl::DiskDirectory::subDir ( const String & subdir_name ) const [inline, virtual]

Implements vl::VirtualDirectory.

virtual ref<VirtualFile> vl::DiskDirectory::file ( const String & name ) const [virtual]

Returns the VirtualFile with the given name if any, NULL otherwise.

Implements vl::VirtualDirectory.

virtual ref<DiskFile> vl::DiskDirectory::diskFile ( const String & name ) const [virtual]

bool DiskDirectory::exists ( ) const

void vl::DiskDirectory::listFilesRecursive_internal ( std::vector< String > & file_list ) const [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DiskFile Class Reference

vl::DiskFile

vl::DiskFile Class Reference

A VirtualFile that operates on regular disk files. More...

#include <DiskFile.hpp>

Inheritance diagram for vl::DiskFile:

vl::VirtualFile vl::Object

List of all members.

Public Member Functions

DiskFile (const String &path=String())
~DiskFile ()
virtual const char * | className ()
Returns the name of the class.
bool | open (const String &path, EOpenMode mode)
The specified path is relative to the parent directory. See setPhysicalPath().
virtual bool | open (EOpenMode mode)
virtual bool | isOpen () const
virtual void | close ()
virtual long long | size () const
Returns the file size in bytes or -1 on error.
virtual bool | exists () const
DiskFile & | operator= (const DiskFile &other)
virtual ref< VirtualFile > | clone () const

Protected Member Functions

DiskFile (const DiskFile &other)
virtual long long | read_Implementation (void *buffer, long long byte_count)
virtual long long | write_Implementation (const void *buffer, long long byte_count)
virtual long long | position_Implementation () const
virtual bool | seekSet_Implementation (long long offset)
ref< DiskDirectory > | parentDir () const

Protected Attributes

FILE * | mHandle

Friends

class | DiskDirectory

Detailed Description

A VirtualFile that operates on regular disk files.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

vl::DiskFile::DiskFile ( const DiskFile & other ) [inline, protected]

DiskFile::DiskFile ( const String & path = String() )

DiskFile::~DiskFile ( )

Member Function Documentation

virtual const char* vl::DiskFile::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualFile.

bool DiskFile::open | ( | const String & | path,
 |  | EOpenMode | mode
 | ) |  |

The specified path is relative to the parent directory. See setPhysicalPath().

bool DiskFile::open ( EOpenMode mode ) [virtual]

Implements vl::VirtualFile.

bool DiskFile::isOpen ( ) const [virtual]

Implements vl::VirtualFile.

void DiskFile::close ( ) [virtual]

Implements vl::VirtualFile.

long long DiskFile::size ( ) const [virtual]

Returns the file size in bytes or -1 on error.

Implements vl::VirtualFile.

bool DiskFile::exists ( ) const [virtual]

Implements vl::VirtualFile.

DiskFile& vl::DiskFile::operator= ( const DiskFile & other ) [inline]

ref< VirtualFile > DiskFile::clone ( ) const [virtual]

Implements vl::VirtualFile.

long long DiskFile::read_Implementation | ( | void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

long long DiskFile::write_Implementation | ( | const void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

long long DiskFile::position_Implementation ( ) const [protected, virtual]

Implements vl::VirtualFile.

bool DiskFile::seekSet_Implementation ( long long offset ) [protected, virtual]

Implements vl::VirtualFile.

ref<DiskDirectory> vl::DiskFile::parentDir ( ) const [protected]

Friends And Related Function Documentation

friend class DiskDirectory [friend]

Member Data Documentation

FILE* vl::DiskFile::mHandle [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DistanceLODEvaluator Class Reference

vl::DistanceLODEvaluator

vl::DistanceLODEvaluator Class Reference

A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera. More...

#include <DistanceLODEvaluator.hpp>

Inheritance diagram for vl::DistanceLODEvaluator:

vl::LODEvaluator vl::Object

List of all members.

Public Member Functions

DistanceLODEvaluator ()
virtual const char * | className ()
Returns the name of the class.
virtual int | evaluate (Actor *actor, Camera *camera)
const std::vector< double > & | distanceRangeSet ()
void | clearDistanceRangeSet ()
int | distanceRangeCount () const
double | distanceRange (int index) const
void | setDistanceRangeSet (const std::vector< double > &distance_set)
void | addDistanceRange (double distance)
void | setDistanceRange (int index, double distance)

Protected Attributes

std::vector< double > | mDistanceRangeSet

Detailed Description

A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera.

See also:
  • LODEvaluator
  • PixelLODEvaluator

Constructor & Destructor Documentation

vl::DistanceLODEvaluator::DistanceLODEvaluator ( ) [inline]

Member Function Documentation

virtual const char* vl::DistanceLODEvaluator::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::LODEvaluator.

virtual int vl::DistanceLODEvaluator::evaluate | ( | Actor * | actor,
 |  | Camera * | camera |
 | ) |  |  | [inline, virtual]

Implements vl::LODEvaluator.

const std::vector<double>& vl::DistanceLODEvaluator::distanceRangeSet ( ) [inline]

void vl::DistanceLODEvaluator::clearDistanceRangeSet ( ) [inline]

int vl::DistanceLODEvaluator::distanceRangeCount ( ) const [inline]

double vl::DistanceLODEvaluator::distanceRange ( int index ) const [inline]

void vl::DistanceLODEvaluator::setDistanceRangeSet ( const std::vector< double > & distance_set ) [inline]

void vl::DistanceLODEvaluator::addDistanceRange ( double distance ) [inline]

void vl::DistanceLODEvaluator::setDistanceRange | ( | int | index,
 |  | double | distance |
 | ) |  |  | [inline]

Member Data Documentation

std::vector<double> vl::DistanceLODEvaluator::mDistanceRangeSet [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DistanceLODEvaluator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DoubleVertexRemover Class Reference

vl::DoubleVertexRemover

vl::DoubleVertexRemover Class Reference

Removes from a Geometry the vertices with the same attributes. More...

#include <DoubleVertexRemover.hpp>

Inheritance diagram for vl::DoubleVertexRemover:

vl::VertexMapper vl::Object

List of all members.

Classes

class | CompareVertex

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
DoubleVertexRemover ()
void | removeDoubles (Geometry *geom)
const std::vector< unsigned int > & | mapNewToOld () const
const std::vector< unsigned int > & | mapOldToNew () const

Protected Attributes

std::vector< unsigned int > | mMapNewToOld
std::vector< unsigned int > | mMapOldToNew

Detailed Description

Removes from a Geometry the vertices with the same attributes.

As a result also all the DrawArrays prensent in the Geometry are substituted with DrawElements.

Constructor & Destructor Documentation

vl::DoubleVertexRemover::DoubleVertexRemover ( ) [inline]

Member Function Documentation

virtual const char* vl::DoubleVertexRemover::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VertexMapper.

void DoubleVertexRemover::removeDoubles ( Geometry * geom )

const std::vector<unsigned int>& vl::DoubleVertexRemover::mapNewToOld ( ) const [inline]

const std::vector<unsigned int>& vl::DoubleVertexRemover::mapOldToNew ( ) const [inline]

Member Data Documentation

std::vector<unsigned int> vl::DoubleVertexRemover::mMapNewToOld [protected]

std::vector<unsigned int> vl::DoubleVertexRemover::mMapOldToNew [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DrawArrays Class Reference

vl::DrawArrays

vl::DrawArrays Class Reference

Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information. More...

#include <DrawArrays.hpp>

Inheritance diagram for vl::DrawArrays:

vl::Primitives vl::Object

List of all members.

Public Member Functions

DrawArrays ()
DrawArrays (EPrimitiveType primitive, int start, int count, int instances=1)
virtual const char * | className ()
Returns the name of the class.
virtual ref< Primitives > | clone () const
virtual void | deleteVBOs ()
virtual void | updateVBOs (bool)
virtual unsigned int | handle () const
virtual unsigned int | indexCount () const
virtual unsigned int | index (int i) const
int | triangleCount () const
int | lineCount () const
int | pointCount () const
virtual void | render (bool) const
void | setStart (int start)
sets the starting vertex for the rendering.
int | start () const
returns the starting vertex for the rendering.
void | setCount (int count)
sets the number of vertices to be rendered.
int | count () const
returns the number of vertices to be rendered.

Protected Attributes

int | mStart
int | mCount

Detailed Description

Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information.

DrawArrays and DrawElements are used by Geometry to define a set of primitives to be rendered (Geometry::primitives()). DrawArrays and DrawElements supports all the OpenGL primitive types. Geometry multi instancing is also supported, see the functions setInstances() and instances().

Constructor & Destructor Documentation

vl::DrawArrays::DrawArrays ( ) [inline]

vl::DrawArrays::DrawArrays | ( | EPrimitiveType | primitive,
 |  | int | start,
 |  | int | count,
 |  | int | instances = 1 |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::DrawArrays::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Primitives.

virtual ref<Primitives> vl::DrawArrays::clone ( ) const [inline, virtual]

Implements vl::Primitives.

virtual void vl::DrawArrays::deleteVBOs ( ) [inline, virtual]

Implements vl::Primitives.

virtual void vl::DrawArrays::updateVBOs ( bool ) [inline, virtual]

Implements vl::Primitives.

virtual unsigned int vl::DrawArrays::handle ( ) const [inline, virtual]

Implements vl::Primitives.

virtual unsigned int vl::DrawArrays::indexCount ( ) const [inline, virtual]

Implements vl::Primitives.

virtual unsigned int vl::DrawArrays::index ( int i ) const [inline, virtual]

Implements vl::Primitives.

int vl::DrawArrays::triangleCount ( ) const [inline, virtual]

Implements vl::Primitives.

int vl::DrawArrays::lineCount ( ) const [inline, virtual]

Implements vl::Primitives.

int vl::DrawArrays::pointCount ( ) const [inline, virtual]

Implements vl::Primitives.

virtual void vl::DrawArrays::render ( bool ) const [inline, virtual]

Implements vl::Primitives.

void vl::DrawArrays::setStart ( int start ) [inline]

sets the starting vertex for the rendering.

int vl::DrawArrays::start ( ) const [inline]

returns the starting vertex for the rendering.

void vl::DrawArrays::setCount ( int count ) [inline]

sets the number of vertices to be rendered.

int vl::DrawArrays::count ( ) const [inline]

returns the number of vertices to be rendered.

Member Data Documentation

int vl::DrawArrays::mStart [protected]

int vl::DrawArrays::mCount [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawArrays.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DrawElements< index_type, Tgltype, arr_type > Class Template Reference

vl::DrawElements

vl::DrawElements< index_type, Tgltype, arr_type > Class Template Reference

Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information. More...

#include <DrawElements.hpp>

Inheritance diagram for vl::DrawElements< index_type, Tgltype, arr_type >:

vl::Primitives vl::Object

List of all members.

Classes

class | Triangle

Public Member Functions

DrawElements (EPrimitiveType primitive=PT_TRIANGLES, int instances=1)
virtual const char * | className ()
Returns the name of the class.
virtual ref< Primitives > | clone () const
virtual unsigned int | handle () const
void | setPrimitiveType (EPrimitiveType type)
EPrimitiveType | primitiveType () const
virtual unsigned int | indexCount () const
virtual unsigned int | indexCountGPU () const
virtual unsigned int | index (int i) const
arr_type * | indices ()
const arr_type * | indices () const
virtual void | updateVBOs (bool discard_local_data=false)
virtual void | deleteVBOs ()
virtual void | clearLocalBuffer ()
int | triangleCount () const
int | lineCount () const
int | pointCount () const
virtual void | sortTriangles ()
Supported only by DrawElements.
virtual void | render (bool use_vbo) const

Protected Attributes

ref< arr_type > | mIndexBuffer

Detailed Description

template<typename index_type, GLenum Tgltype, class arr_type>
class vl::DrawElements< index_type, Tgltype, arr_type >

Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information.

DrawElements is the template base of vl::DrawElementsUInt, vl::DrawElementsUShort, vl::DrawElementsUByte. DrawArrays and DrawElements are used by Geometry to define a set of primitives to be rendered (Geometry::primitives()). DrawArrays and DrawElements supports all the OpenGL primitive types. Geometry multi instancing is also supported, see the functions setInstances() and instances(). The indices of a DrawElement are stored in a GLBufferObject and thus can be stored locally or on the GPU. To gain direct access to the GLBufferObject use the indices() function.

See also:
DrawElementsUInt, DrawElementsUShort, DrawElementsUByte, DrawArrays, Geometry, Actor

Constructor & Destructor Documentation

template<typename index_type , GLenum Tgltype, class arr_type >
vl::DrawElements< index_type, Tgltype, arr_type >::DrawElements | ( | EPrimitiveType | primitive = PT_TRIANGLES,
 |  | int | instances = 1 |
 | ) |  |  | [inline]

Member Function Documentation

template<typename index_type , GLenum Tgltype, class arr_type >
virtual const char* vl::DrawElements< index_type, Tgltype, arr_type >::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual ref<Primitives> vl::DrawElements< index_type, Tgltype, arr_type >::clone ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual unsigned int vl::DrawElements< index_type, Tgltype, arr_type >::handle ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
void vl::DrawElements< index_type, Tgltype, arr_type >::setPrimitiveType ( EPrimitiveType type ) [inline]

Reimplemented from vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
EPrimitiveType vl::DrawElements< index_type, Tgltype, arr_type >::primitiveType ( ) const [inline]

Reimplemented from vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual unsigned int vl::DrawElements< index_type, Tgltype, arr_type >::indexCount ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual unsigned int vl::DrawElements< index_type, Tgltype, arr_type >::indexCountGPU ( ) const [inline, virtual]

template<typename index_type , GLenum Tgltype, class arr_type >
virtual unsigned int vl::DrawElements< index_type, Tgltype, arr_type >::index ( int i ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
arr_type* vl::DrawElements< index_type, Tgltype, arr_type >::indices ( ) [inline]

template<typename index_type , GLenum Tgltype, class arr_type >
const arr_type* vl::DrawElements< index_type, Tgltype, arr_type >::indices ( ) const [inline]

template<typename index_type , GLenum Tgltype, class arr_type >
virtual void vl::DrawElements< index_type, Tgltype, arr_type >::updateVBOs ( bool discard_local_data = false ) [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual void vl::DrawElements< index_type, Tgltype, arr_type >::deleteVBOs ( ) [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual void vl::DrawElements< index_type, Tgltype, arr_type >::clearLocalBuffer ( ) [inline, virtual]

template<typename index_type , GLenum Tgltype, class arr_type >
int vl::DrawElements< index_type, Tgltype, arr_type >::triangleCount ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
int vl::DrawElements< index_type, Tgltype, arr_type >::lineCount ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
int vl::DrawElements< index_type, Tgltype, arr_type >::pointCount ( ) const [inline, virtual]

Implements vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual void vl::DrawElements< index_type, Tgltype, arr_type >::sortTriangles ( ) [inline, virtual]

Supported only by DrawElements.

Reimplemented from vl::Primitives.

template<typename index_type , GLenum Tgltype, class arr_type >
virtual void vl::DrawElements< index_type, Tgltype, arr_type >::render ( bool use_vbo ) const [inline, virtual]

Implements vl::Primitives.

Member Data Documentation

template<typename index_type , GLenum Tgltype, class arr_type >
ref< arr_type > vl::DrawElements< index_type, Tgltype, arr_type >::mIndexBuffer [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawElements.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::DrawPixels Class Reference

vl::DrawPixels

vl::DrawPixels Class Reference

Wraps the OpenGL function glDrawPixels(). More...

#include <DrawPixels.hpp>

Inheritance diagram for vl::DrawPixels:

vl::Renderable vl::Object

List of all members.

Classes

class | Pixels
Represents a bitmap to be drawn on the screen. More...

Public Member Functions

DrawPixels ()
virtual const char * | className ()
Returns the name of the class.
void | computeBounds_Implementation ()
void | render (const Actor *actor, const OpenGLContext *, const Camera *camera) const
Renders the bitamps.
const Collection< Pixels > * | draws () const
Collection< Pixels > * draws ()
void | deletePixelBufferObjects ()
deallocate PBOs
void | releaseImages ()
Iterates on the Pixels objects and sets their Image references to NULL.
bool | generatePixelBufferObjects (EGLBufferUsage usage, bool discard_local_storage)
generates PBOs only for Pixels objects without a PBO handle
void | setUsePixelBufferObject (bool use_pbo)
bool | usePixelBufferObject () const

Protected Attributes

Collection< Pixels > mDraws
bool | mUsePixelBufferObject

Detailed Description

Wraps the OpenGL function glDrawPixels().

Bind it to an Actor in order to render one or more bitmaps on the screen. DrawPixels supports multiple bitmaps, can draw a subsection of a bitmap, and supports also PBOs (GL_EXT_pixel_buffer_object). See also DrawPixels::Pixels.

Note:
If the given Actor has an associated transform the bitmap position will follow it.
Remarks:
Be aware that depth test, stencil test, alpha test, clipping planes etc. can affect the rendering of the bitmap. Since this function uses the glRasterPos OpenGL function lighting, texturing and the current color might affect the rendering. For more information look at the glRasterPos documentation.

Constructor & Destructor Documentation

DrawPixels::DrawPixels ( )

Member Function Documentation

virtual const char* vl::DrawPixels::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Renderable.

void vl::DrawPixels::computeBounds_Implementation ( ) [inline, virtual]

Implements vl::Renderable.

void DrawPixels::render | ( | const Actor * | actor,
 |  | const OpenGLContext * | ,
 |  | const Camera * | camera |
 | ) |  |  | const [virtual]

Renders the bitamps.

If camera != NULL and actor != NULL and actor->transform() != NULL then the bitmaps position will follow the Actor's Transform. The renderer parameter is ignored.

Implements vl::Renderable.

const Collection<Pixels>* vl::DrawPixels::draws ( ) const [inline]

Collection<Pixels>* vl::DrawPixels::draws ( ) [inline]

void DrawPixels::deletePixelBufferObjects ( )

deallocate PBOs

void DrawPixels::releaseImages ( )

Iterates on the Pixels objects and sets their Image references to NULL.

bool DrawPixels::generatePixelBufferObjects | ( | EGLBufferUsage | usage,
 |  | bool | discard_local_storage
 | ) |  |

generates PBOs only for Pixels objects without a PBO handle

void DrawPixels::setUsePixelBufferObject ( bool use_pbo )

bool vl::DrawPixels::usePixelBufferObject ( ) const [inline]

Member Data Documentation

Collection<Pixels> vl::DrawPixels::mDraws [protected]

bool vl::DrawPixels::mUsePixelBufferObject [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::DrawPixels::Pixels Class Reference

vl::DrawPixels::Pixels

vl::DrawPixels::Pixels Class Reference

Represents a bitmap to be drawn on the screen. More...

#include <DrawPixels.hpp>

Inheritance diagram for vl::DrawPixels::Pixels:

vl::Object

List of all members.

Public Member Functions

Pixels ()
Pixels (Image *img, int scrx, int scry, int startx=0, int starty=0, int width=-1, int height=-1, int alignment=AlignBottom|AlignLeft)
Constructor.
Pixels (const Pixels &other)
Pixels & | operator= (const Pixels &other)
~Pixels ()
const ivec2 & | position () const
const ivec2 & | start () const
const ivec2 & | size () const
void | setPosition (const ivec2 &position)
void | setStart (const ivec2 &start)
void | setSize (const ivec2 &size)
Image * image ()
const Image * | image () const
int | align () const
void | setAlign (int align)
bool | generatePixelBufferObject (EGLBufferUsage usage, bool discard_local_storage)
Generates a pixel buffer object for the associated Image calling image()->gpuBuffer()->setBufferData(usage, discard_local_storage);.
void | deletePixelBufferObject ()
bool | hasPixelBufferObject () const

Protected Attributes

ref< Image > mImage
ivec2 mPosition
ivec2 mStart
ivec2 mSize
int | mAlign

Friends

class | DrawPixels

Detailed Description

Represents a bitmap to be drawn on the screen.

Constructor & Destructor Documentation

DrawPixels::Pixels::Pixels ( )

DrawPixels::Pixels::Pixels | ( | Image * | img,
 |  | int | scrx,
 |  | int | scry,
 |  | int | startx = 0,
 |  | int | starty = 0,
 |  | int | width = -1,
 |  | int | height = -1,
 |  | int | alignment = AlignBottom | AlignLeft
 | ) |  |

Constructor.

The parameters 'scrx' and 'scry' define the position of the viewport in pixels where the image has to be placed. If a Transform is attached to the Actor using DrawPixels scrx, scry follow the transform on the screen. The parameters 'startx', 'starty', 'width' and 'height' define the sub-portion of the Image to be rendered. The parameters 'width' and 'height' can be -1, in this case they will be automatically set so that the Image is shown until the top-right edge.

DrawPixels::Pixels::Pixels ( const Pixels & other )

DrawPixels::Pixels::~Pixels ( )

Member Function Documentation

DrawPixels::Pixels & DrawPixels::Pixels::operator= ( const Pixels & other )

const ivec2& vl::DrawPixels::Pixels::position ( ) const [inline]

const ivec2& vl::DrawPixels::Pixels::start ( ) const [inline]

const ivec2& vl::DrawPixels::Pixels::size ( ) const [inline]

void vl::DrawPixels::Pixels::setPosition ( const ivec2 & position ) [inline]

void vl::DrawPixels::Pixels::setStart ( const ivec2 & start ) [inline]

void vl::DrawPixels::Pixels::setSize ( const ivec2 & size ) [inline]

Image* vl::DrawPixels::Pixels::image ( ) [inline]

const Image* vl::DrawPixels::Pixels::image ( ) const [inline]

int vl::DrawPixels::Pixels::align ( ) const [inline]

void vl::DrawPixels::Pixels::setAlign ( int align ) [inline]

bool DrawPixels::Pixels::generatePixelBufferObject | ( | EGLBufferUsage | usage,
 |  | bool | discard_local_storage
 | ) |  |

Generates a pixel buffer object for the associated Image calling image()->gpuBuffer()->setBufferData(usage, discard_local_storage);.

Note:
All the Pixels object sharing the same Image will use the Image's PBO

void DrawPixels::Pixels::deletePixelBufferObject ( )

bool DrawPixels::Pixels::hasPixelBufferObject ( ) const

Friends And Related Function Documentation

friend class DrawPixels [friend]

Member Data Documentation

ref<Image> vl::DrawPixels::Pixels::mImage [protected]

ivec2 vl::DrawPixels::Pixels::mPosition [protected]

ivec2 vl::DrawPixels::Pixels::mStart [protected]

ivec2 vl::DrawPixels::Pixels::mSize [protected]

int vl::DrawPixels::Pixels::mAlign [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::EdgeExtractor Class Reference

vl::EdgeExtractor

vl::EdgeExtractor Class Reference

The EdgeExtractor class extracts the edges from one or more Geometry objects. More...

#include <EdgeExtractor.hpp>

Inheritance diagram for vl::EdgeExtractor:

vl::Object

List of all members.

Classes

class | Edge
A single edge as extracted from the EdgeExtractor class. More...

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
EdgeExtractor ()
void | extractEdges (Geometry *geom)
Extracts the edges from the given Geometry and appends them to edges().
bool | extractEdges (Actor *actor)
void | extractEdges (ActorCollection *actors)
void | extractEdges (SceneManager *scenemanager)
void | extractEdges (Rendering *rendering)
ref< Geometry > | generateEdgeGeometry () const
const std::vector< Edge > & | edges () const
std::vector< Edge > & | edges ()
void | reset ()
float | creaseAngle () const
The minimum angle (in degrees) considered to generate crease-edges.
void | setCreaseAngle (float a)
The minimum angle (in degrees) considered to generate crease-edges.
bool | warnNonManifold () const
void | setWarnNonManifold (bool warn_on)

Protected Member Functions

void | addEdge (std::set< EdgeExtractor::Edge > &edges, const EdgeExtractor::Edge &e, const fvec3 &n)

Protected Attributes

std::vector< Edge > | mEdges
float | mCreaseAngle
bool | mWarnNonManifold

Detailed Description

The EdgeExtractor class extracts the edges from one or more Geometry objects.

The edges are always extracted from the triangles or quads that are part of a vl::Geometry and can be of three types: silhouette edges, crease edges and boundary edges.

  • Silhouette edges are those edges that are shared by a backfacing and front facing quad or triangle.

  • Crease edges are those edges that are shared by two triangles or quads and that form an angle >= creaseAngle(), ie: 0 means that the two triangles or quads are coplanar; the edges of a cube define 90 degrees angles; the lateral edges of a 10 faces cylinder define 36 (360/10) degrees angles and so on.

  • Boundary edges are those edges that belong to a single triangle or quad.

Usage
  • Extract the edges from one or more Geometry objects using one of the extractEdges() methods.
  • Assign the Geometry returned by generateEdgeGeometry() to a new Actor. This geometry will contain the edges previously extracted ready to be rendered.
  • Assign a new EdgeUpdateCallback to the previously created Actor, using the Actor::renderingCallbacks() method.
  • Initialize the previously created EdgeUpdateCallback edges with the edges extracted by the EdgeExtractor, that is, assign EdgeExtractor::edges() to EdgeUpdateCallback::edges().
See also:
  • Edge Enhancement and Wireframe Rendering Tutorial
  • vl::EdgeRenderer

Constructor & Destructor Documentation

vl::EdgeExtractor::EdgeExtractor ( ) [inline]

Member Function Documentation

virtual const char* vl::EdgeExtractor::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void EdgeExtractor::extractEdges ( Geometry * geom )

Extracts the edges from the given Geometry and appends them to edges().

The given geometry must have a vertex array of format ArrayFVec3.

bool EdgeExtractor::extractEdges ( Actor * actor )

void EdgeExtractor::extractEdges ( ActorCollection * actors )

void EdgeExtractor::extractEdges ( SceneManager * scenemanager )

void EdgeExtractor::extractEdges ( Rendering * rendering )

ref< Geometry > EdgeExtractor::generateEdgeGeometry ( ) const

const std::vector<Edge>& vl::EdgeExtractor::edges ( ) const [inline]

std::vector<Edge>& vl::EdgeExtractor::edges ( ) [inline]

void vl::EdgeExtractor::reset ( ) [inline]

float vl::EdgeExtractor::creaseAngle ( ) const [inline]

The minimum angle (in degrees) considered to generate crease-edges.

void vl::EdgeExtractor::setCreaseAngle ( float a ) [inline]

The minimum angle (in degrees) considered to generate crease-edges.

bool vl::EdgeExtractor::warnNonManifold ( ) const [inline]

void vl::EdgeExtractor::setWarnNonManifold ( bool warn_on ) [inline]

void EdgeExtractor::addEdge | ( | std::set< EdgeExtractor::Edge > & | edges,
 |  | const EdgeExtractor::Edge & | e,
 |  | const fvec3 & | n |
 | ) |  |  | [protected]

Member Data Documentation

std::vector<Edge> vl::EdgeExtractor::mEdges [protected]

float vl::EdgeExtractor::mCreaseAngle [protected]

bool vl::EdgeExtractor::mWarnNonManifold [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::EdgeExtractor::Edge Class Reference

vl::EdgeExtractor::Edge

vl::EdgeExtractor::Edge Class Reference

A single edge as extracted from the EdgeExtractor class. More...

#include <EdgeExtractor.hpp>

List of all members.

Public Member Functions

Edge ()
Edge (const fvec3 &v1, const fvec3 &v2)
void | setVertex1 (const fvec3 &v)
const fvec3 & | vertex1 () const
void | setVertex2 (const fvec3 &v)
const fvec3 & | vertex2 () const
void | setNormal1 (const fvec3 &v)
const fvec3 & | normal1 () const
void | setNormal2 (const fvec3 &v)
const fvec3 & | normal2 () const
bool | isCrease () const
void | setIsCrease (bool iscrease)
bool | operator< (const Edge &other) const
bool | operator== (const Edge &other) const

Protected Attributes

fvec3 mVertex1
fvec3 mVertex2
fvec3 mNormal1
fvec3 mNormal2
bool | mIsCrease

Detailed Description

A single edge as extracted from the EdgeExtractor class.

Constructor & Destructor Documentation

vl::EdgeExtractor::Edge::Edge ( ) [inline]

vl::EdgeExtractor::Edge::Edge | ( | const fvec3 & | v1,
 |  | const fvec3 & | v2 |
 | ) |  |  | [inline]

Member Function Documentation

void vl::EdgeExtractor::Edge::setVertex1 ( const fvec3 & v ) [inline]

const fvec3& vl::EdgeExtractor::Edge::vertex1 ( ) const [inline]

void vl::EdgeExtractor::Edge::setVertex2 ( const fvec3 & v ) [inline]

const fvec3& vl::EdgeExtractor::Edge::vertex2 ( ) const [inline]

void vl::EdgeExtractor::Edge::setNormal1 ( const fvec3 & v ) [inline]

const fvec3& vl::EdgeExtractor::Edge::normal1 ( ) const [inline]

void vl::EdgeExtractor::Edge::setNormal2 ( const fvec3 & v ) [inline]

const fvec3& vl::EdgeExtractor::Edge::normal2 ( ) const [inline]

bool vl::EdgeExtractor::Edge::isCrease ( ) const [inline]

void vl::EdgeExtractor::Edge::setIsCrease ( bool iscrease ) [inline]

bool vl::EdgeExtractor::Edge::operator< ( const Edge & other ) const [inline]

bool vl::EdgeExtractor::Edge::operator== ( const Edge & other ) const [inline]

Member Data Documentation

fvec3 vl::EdgeExtractor::Edge::mVertex1 [protected]

fvec3 vl::EdgeExtractor::Edge::mVertex2 [protected]

fvec3 vl::EdgeExtractor::Edge::mNormal1 [protected]

fvec3 vl::EdgeExtractor::Edge::mNormal2 [protected]

bool vl::EdgeExtractor::Edge::mIsCrease [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::EdgeRenderer Class Reference

vl::EdgeRenderer

vl::EdgeRenderer Class Reference

The EdgeRenderer class implements a special Renderer that automatically extracts and renders the edges of the objects in the scene. More...

#include <EdgeRenderer.hpp>

Inheritance diagram for vl::EdgeRenderer:

vl::Renderer vl::Object

List of all members.

Classes

class | WFInfo

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
EdgeRenderer ()
void | render (const RenderQueue *render_queue, Camera *camera)
WFInfo * | declareActor (Actor *act, const fvec4 &color)
Generates and caches all the information needed to render the edges of the given Actor using the specified color.
WFInfo * | declareActor (Actor *act)
Generates and caches all the information needed to render the edges of the given Actor.
void | clearCache ()
Clears the cache containing the Actor and edge information.
void | setActorDirty (Actor *actor)
Removes all the edge/rendering information relative to the specified Actor from the cache.
void | setShowHiddenLines (bool show)
If set to true shows also the hidden lines with a dashed pattern.
bool | showHiddenLines () const
If set to true shows also the hidden lines with a dashed pattern.
void | setShowCreases (bool show)
If set to true shows not only the edges that define the silhouette of an object but also the crease edges.
bool | showCreases () const
If set to true shows not only the edges that define the silhouette of an object but also the crease edges.
void | setCreaseAngle (float degrees)
The minimum angle (in degrees) considered to generate crease-edges (default is 44 degrees).
float | creaseAngle () const
The minimum angle (in degrees) considered to generate crease-edges (default is 44 degrees).
void | setSmoothLines (bool smooth)
If set to true the lines will be rendered using antialiasing.
bool | smoothLines () const
If set to true the lines will be rendered using antialiasing.
void | setLineWidth (float width)
Defines the width of the rendered edges.
float | lineWidth () const
Defines the width of the rendered edges.
void | setDefaultLineColor (const fvec4 &c)
Defines the default color of the rendered edges. You can also define a per-Actor color using the declareActor() method.
const fvec4 & | defaultLineColor () const
Defines the default color of the rendered edges. You can also define a per-Actor color using the declareActor() method.
void | setPolygonOffsetFactor (float factor)
Defines the factor parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.
float | polygonOffsetFactor () const
Defines the factor parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.
void | setPolygonOffsetUnits (float units)
Defines the units parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.
float | polygonOffsetUnits () const
Defines the units parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

Protected Member Functions

void | updateActorCache (const RenderQueue *render_queue)
void | renderSolids (Camera *camera)
void | renderLines (Camera *camera)

Protected Attributes

std::map< ref< Actor >, ref
< WFInfo > > 		mActorCache
std::map< ref< Actor >, ref
< WFInfo > > 		mVisibleActors
fvec4 mDefaultLineColor
float | mLineWidth
float | mPolygonOffsetFactor
float | mPolygonOffsetUnits
float | mCreaseAngle
bool | mShowHiddenLines
bool | mShowCreases
bool | mSmoothLines

Detailed Description

The EdgeRenderer class implements a special Renderer that automatically extracts and renders the edges of the objects in the scene.

In order to efficiently and transparently render the edges of the objects present in the scene the EdgeRenderer class keeps an internal cache of Geometry and Actor objects that contain the extracted edges. For this reason if the Geometry of an Actor changes or if an Actor is removed from the scene you should call the setActorDirty() method. This way the cached information relative to that Actor will be removed and will be recreated only if/when such Actor becomes visible again. Call the clearCache() method to invalidate the whole cache. In order to minimized the amount of memory used by the cache it is important to keep the cache as clean and up to date as possible. The color used to render the edges can be set globally using the setDefaultLineColor() method or by Actor using the declareActor() method.

See also:
  • Edge Enhancement and Wireframe Rendering Tutorial
  • vl::EdgeExtractor

Constructor & Destructor Documentation

vl::EdgeRenderer::EdgeRenderer ( ) [inline]

Member Function Documentation

virtual const char* vl::EdgeRenderer::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Renderer.

void EdgeRenderer::render | ( | const RenderQueue * | render_queue,
 |  | Camera * | camera |
 | ) |  |  | [virtual]

Reimplemented from vl::Renderer.

EdgeRenderer::WFInfo * EdgeRenderer::declareActor | ( | Actor * | act,
 |  | const fvec4 & | color
 | ) |  |

Generates and caches all the information needed to render the edges of the given Actor using the specified color.

EdgeRenderer::WFInfo * EdgeRenderer::declareActor ( Actor * act )

Generates and caches all the information needed to render the edges of the given Actor.

void vl::EdgeRenderer::clearCache ( ) [inline]

Clears the cache containing the Actor and edge information.

Call this function when a significant part of the scene changed or was removed. The cache will be automatically rebuild at the next rendering frames.

void vl::EdgeRenderer::setActorDirty ( Actor * actor ) [inline]

Removes all the edge/rendering information relative to the specified Actor from the cache.

Call this function when an Actor's Geometry changed or when you know that an Actor that was previously visible won't be visible anymore, for example because it has been removed from the scene. Note that if the Actor becomes visible at any point later the cache will be automatically rebuilt.

void vl::EdgeRenderer::setShowHiddenLines ( bool show ) [inline]

If set to true shows also the hidden lines with a dashed pattern.

bool vl::EdgeRenderer::showHiddenLines ( ) const [inline]

If set to true shows also the hidden lines with a dashed pattern.

void vl::EdgeRenderer::setShowCreases ( bool show ) [inline]

If set to true shows not only the edges that define the silhouette of an object but also the crease edges.

bool vl::EdgeRenderer::showCreases ( ) const [inline]

If set to true shows not only the edges that define the silhouette of an object but also the crease edges.

void vl::EdgeRenderer::setCreaseAngle ( float degrees ) [inline]

The minimum angle (in degrees) considered to generate crease-edges (default is 44 degrees).

float vl::EdgeRenderer::creaseAngle ( ) const [inline]

The minimum angle (in degrees) considered to generate crease-edges (default is 44 degrees).

void vl::EdgeRenderer::setSmoothLines ( bool smooth ) [inline]

If set to true the lines will be rendered using antialiasing.

bool vl::EdgeRenderer::smoothLines ( ) const [inline]

If set to true the lines will be rendered using antialiasing.

void vl::EdgeRenderer::setLineWidth ( float width ) [inline]

Defines the width of the rendered edges.

float vl::EdgeRenderer::lineWidth ( ) const [inline]

Defines the width of the rendered edges.

void vl::EdgeRenderer::setDefaultLineColor ( const fvec4 & c ) [inline]

Defines the default color of the rendered edges. You can also define a per-Actor color using the declareActor() method.

const fvec4& vl::EdgeRenderer::defaultLineColor ( ) const [inline]

Defines the default color of the rendered edges. You can also define a per-Actor color using the declareActor() method.

void vl::EdgeRenderer::setPolygonOffsetFactor ( float factor ) [inline]

Defines the factor parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

float vl::EdgeRenderer::polygonOffsetFactor ( ) const [inline]

Defines the factor parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

void vl::EdgeRenderer::setPolygonOffsetUnits ( float units ) [inline]

Defines the units parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

float vl::EdgeRenderer::polygonOffsetUnits ( ) const [inline]

Defines the units parameter used to render the lines over the polygons. See also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

void EdgeRenderer::updateActorCache ( const RenderQueue * render_queue ) [protected]

void EdgeRenderer::renderSolids ( Camera * camera ) [protected]

void EdgeRenderer::renderLines ( Camera * camera ) [protected]

Member Data Documentation

std::map< ref<Actor>, ref<WFInfo> > vl::EdgeRenderer::mActorCache [protected]

std::map< ref<Actor>, ref<WFInfo> > vl::EdgeRenderer::mVisibleActors [protected]

fvec4 vl::EdgeRenderer::mDefaultLineColor [protected]

float vl::EdgeRenderer::mLineWidth [protected]

float vl::EdgeRenderer::mPolygonOffsetFactor [protected]

float vl::EdgeRenderer::mPolygonOffsetUnits [protected]

float vl::EdgeRenderer::mCreaseAngle [protected]

bool vl::EdgeRenderer::mShowHiddenLines [protected]

bool vl::EdgeRenderer::mShowCreases [protected]

bool vl::EdgeRenderer::mSmoothLines [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::EdgeUpdateCallback Class Reference

vl::EdgeUpdateCallback

vl::EdgeUpdateCallback Class Reference

The EdgeUpdateCallback class updates at every frame the edges of an Actor for the purpose of edge-enhancement. More...

#include <EdgeUpdateCallback.hpp>

Inheritance diagram for vl::EdgeUpdateCallback:

vl::ActorRenderingCallback vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
EdgeUpdateCallback ()
EdgeUpdateCallback (const std::vector< EdgeExtractor::Edge > &edge)
void | setShowCreases (bool sonly)
If true only the edges forming the silhouette of an object will be rendered.
bool | showCreases () const
If true only the edges forming the silhouette of an object will be rendered.
virtual void | operator() (const Camera *cam, Actor *act, Renderable *renderable, const Shader *, int pass)
Called upon callback execution.
const std::vector
< EdgeExtractor::Edge > & 		edges () const
std::vector
< EdgeExtractor::Edge > & 		edges ()

Detailed Description

The EdgeUpdateCallback class updates at every frame the edges of an Actor for the purpose of edge-enhancement.

See also:
EdgeExtractor

Constructor & Destructor Documentation

vl::EdgeUpdateCallback::EdgeUpdateCallback ( ) [inline]

vl::EdgeUpdateCallback::EdgeUpdateCallback ( const std::vector< EdgeExtractor::Edge > & edge ) [inline]

Member Function Documentation

virtual const char* vl::EdgeUpdateCallback::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::EdgeUpdateCallback::setShowCreases ( bool sonly ) [inline]

If true only the edges forming the silhouette of an object will be rendered.

bool vl::EdgeUpdateCallback::showCreases ( ) const [inline]

If true only the edges forming the silhouette of an object will be rendered.

virtual void vl::EdgeUpdateCallback::operator() | ( | const Camera * | cam,
 |  | Actor * | actor,
 |  | Renderable * | renderable,
 |  | const Shader * | shader,
 |  | int | pass |
 | ) |  |  | [inline, virtual]

Called upon callback execution.

Parameters:
cam | The camera used for the current rendering.
actor | The Actor bound to this rendering callback.
renderable | The currently selected Actor LOD.
shader | The currently active Shader.
pass | The current Actor[s] rendering pass.

Implements vl::ActorRenderingCallback.

const std::vector<EdgeExtractor::Edge>& vl::EdgeUpdateCallback::edges ( ) const [inline]

std::vector<EdgeExtractor::Edge>& vl::EdgeUpdateCallback::edges ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeUpdateCallback.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::Effect Class Reference

vl::Effect

vl::Effect Class Reference

Defines the sequence of Shader objects used to render an Actor. More...

#include <Effect.hpp>

Inheritance diagram for vl::Effect:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Effect ()
Constructor.
~Effect ()
Destructor.
void | setRenderRank (int rank)
Modifies the rendering rank of an Actor.
int | renderRank () const
Returns the rendering rank of an Effect.
const ref< ShaderSequence > & | lod (int lod_level) const
Returns the ShaderSequence representing the specified LOD level.
ref< ShaderSequence > & | lod (int lod_level)
Returns the ShaderSequence representing the specified LOD level.
Shader * | shader (int lodi=0, int pass=0)
Utility function, same as 'lod(lodi)->at(pass);'.
const Shader * | shader (int lodi=0, int pass=0) const
Utility function, same as 'lod(lodi)->at(pass);'.
void | setLOD (int lodi, Shader *shader1, Shader *shader2=NULL, Shader *shader3=NULL, Shader *shader4=NULL)
Utility function, same as 'lod(lodi) = new ShaderSequence(shader1,shader2,shader3,shader4);'.
void | setLODEvaluator (LODEvaluator *lod_evaluator)
Installs the LODEvaluator used to compute the current LOD at rendering time.
LODEvaluator * lodEvaluator ()
Returns the installed LODEvaluator (if any) or NULL.
const LODEvaluator * | lodEvaluator () const
Returns the installed LODEvaluator (if any) or NULL.
void | setEnableMask (unsigned int mask)
The enable mask of an Actor's Effect defines whether the actor should be rendered or not depending on the Rendering::enableMask().
unsigned int | enableMask () const
The enable mask of an Actor's Effect defines whether the actor should be rendered or not depending on the Rendering::enableMask().
int | evaluateLOD (Actor *actor, Camera *camera)
If a LODEvaluator is installed computes the effect LOD to be used otherwise returns 0.

Protected Attributes

ref< ShaderSequence > | mLODShaders [VL_MAX_EFFECT_LOD]
ref< LODEvaluator > mLODEvaluator
int | mRenderRank
unsigned int | mEnableMask

Detailed Description

Defines the sequence of Shader objects used to render an Actor.

Typically an Effect will have only one LOD (level of detail) with 1 pass (i.e. 1 Shader) but you can specify multiple LODs each of which defines its own set of Shader[s].

When a LOD has more than one Shader the Actor is rendered several times, once for each Shader. This technique is called multipass rendering.

The LOD to be used during the rendering is defined at rendering time if a LODEvaluator has been installed using the method setLODEvaluator(), otherwise the LOD #0 is selected.

See also:
Shader, Actor, LODEvaluator, ShaderSequence

Constructor & Destructor Documentation

vl::Effect::Effect ( ) [inline]

Constructor.

vl::Effect::~Effect ( ) [inline]

Destructor.

Member Function Documentation

virtual const char* vl::Effect::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::Effect::setRenderRank ( int rank ) [inline]

Modifies the rendering rank of an Actor.

The rendering rank affects the order in which an Actor is rendered, the greater the rank the later the Actor is rendered. The default render rank is zero.

To know more about rendering order please see Rendering Order.

See also:
Actor::setRenderRank(), Actor::setRenderBlock()

int vl::Effect::renderRank ( ) const [inline]

Returns the rendering rank of an Effect.

const ref<ShaderSequence>& vl::Effect::lod ( int lod_level ) const [inline]

Returns the ShaderSequence representing the specified LOD level.

Note:
lod_index must be < VL_MAX_EFFECT_LOD

ref<ShaderSequence>& vl::Effect::lod ( int lod_level ) [inline]

Returns the ShaderSequence representing the specified LOD level.

Note:
lod_index must be < VL_MAX_EFFECT_LOD

Shader* vl::Effect::shader | ( | int | lodi = 0,
 |  | int | pass = 0 |
 | ) |  |  | [inline]

Utility function, same as 'lod(lodi)->at(pass);'.

const Shader* vl::Effect::shader | ( | int | lodi = 0,
 |  | int | pass = 0 |
 | ) |  |  | const [inline]

Utility function, same as 'lod(lodi)->at(pass);'.

void vl::Effect::setLOD | ( | int | lodi,
 |  | Shader * | shader1,
 |  | Shader * | shader2 = NULL,
 |  | Shader * | shader3 = NULL,
 |  | Shader * | shader4 = NULL |
 | ) |  |  | [inline]

Utility function, same as 'lod(lodi) = new ShaderSequence(shader1,shader2,shader3,shader4);'.

void vl::Effect::setLODEvaluator ( LODEvaluator * lod_evaluator ) [inline]

Installs the LODEvaluator used to compute the current LOD at rendering time.

LODEvaluator* vl::Effect::lodEvaluator ( ) [inline]

Returns the installed LODEvaluator (if any) or NULL.

const LODEvaluator* vl::Effect::lodEvaluator ( ) const [inline]

Returns the installed LODEvaluator (if any) or NULL.

void vl::Effect::setEnableMask ( unsigned int mask ) [inline]

The enable mask of an Actor's Effect defines whether the actor should be rendered or not depending on the Rendering::enableMask().

unsigned int vl::Effect::enableMask ( ) const [inline]

The enable mask of an Actor's Effect defines whether the actor should be rendered or not depending on the Rendering::enableMask().

int Effect::evaluateLOD | ( | Actor * | actor,
 |  | Camera * | camera
 | ) |  |

If a LODEvaluator is installed computes the effect LOD to be used otherwise returns 0.

Member Data Documentation

ref<ShaderSequence> vl::Effect::mLODShaders[VL_MAX_EFFECT_LOD] [protected]

ref<LODEvaluator> vl::Effect::mLODEvaluator [protected]

int vl::Effect::mRenderRank [protected]

unsigned int vl::Effect::mEnableMask [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::EnableSet Class Reference

vl::EnableSet

vl::EnableSet Class Reference

A set of enables managed by Shader. More...

#include <Shader.hpp>

Inheritance diagram for vl::EnableSet:

vl::Object

List of all members.

Public Member Functions

EnableSet ()
virtual const char * | className ()
Returns the name of the class.
void | enable (EEnable capability)
void | disable (EEnable capability)
const std::vector< EEnable > & | enables () const
int | isEnabled (EEnable capability) const
void | disableAll ()
bool | blendingEnabled () const

Protected Attributes

std::vector< EEnable > | mEnables
bool | mBlendingEnabled

Detailed Description

A set of enables managed by Shader.

This class substitutes for the most part the OpenGL functions glEnable() and glDisable().

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::EnableSet::EnableSet ( ) [inline]

Member Function Documentation

virtual const char* vl::EnableSet::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::EnableSet::enable ( EEnable capability ) [inline]

void vl::EnableSet::disable ( EEnable capability ) [inline]

const std::vector<EEnable>& vl::EnableSet::enables ( ) const [inline]

int vl::EnableSet::isEnabled ( EEnable capability ) const [inline]

void vl::EnableSet::disableAll ( ) [inline]

bool vl::EnableSet::blendingEnabled ( ) const [inline]

Member Data Documentation

std::vector<EEnable> vl::EnableSet::mEnables [protected]

bool vl::EnableSet::mBlendingEnabled [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::Extrusion Class Reference

vl::Extrusion

vl::Extrusion Class Reference

The Extrusion class generates a Geometry extruding a silhouette along a path. More...

#include <Extrusion.hpp>

Inheritance diagram for vl::Extrusion:

vl::Object

List of all members.

Public Member Functions

Extrusion ()
Constructor.
vl::ref< vl::Geometry > extrude ()
Performs the actual extrusion.
void | setSilhouette (const std::vector< vl::fvec2 > &silhouette)
Sets the silhouette to be extruded.
const std::vector< vl::fvec2 > & | silhouette () const
Returns the silhouette to be extruded.
std::vector< vl::fvec2 > & | silhouette ()
Returns the silhouette to be extruded.
void | setSilhouetteMode (ESilhouetteMode mode)
Wether the silhouette is considered closed, i.e. a line-loop, or open.
ESilhouetteMode | silhouetteMode () const
Wether the silhouette is considered closed, i.e. a line-loop, or open.
void | setSmooth (bool smooth)
If true the normals of the geometry are smoothed.
bool | smooth () const
If true the normals of the geometry are smoothed.
void | setFillBottom (bool fill)
Whether a set of triangles should be generated to fill the beginning of the extrusion (default is true).
bool | fillBottom () const
Whether a set of triangles should be generated to fill the beginning of the extrusion (default is true).
void | setFillTop (bool fill)
Whether a set of triangles should be generated to fill the ending of the extrusion (default is true).
bool | fillTop () const
Whether a set of triangles should be generated to fill the ending of the extrusion (default is true).
const std::vector< vl::fvec3 > & | positionPath () const
The path along which the silhouette is extruded.
std::vector< vl::fvec3 > & | positionPath ()
The path along which the silhouette is extruded.
const std::vector< float > & | scalingPath () const
The scaling to be applied along the extrusion.
std::vector< float > & | scalingPath ()
The scaling to be applied along the extrusion.
const std::vector< float > & | rotationPath () const
The rotation to be applied along the extrusion.
std::vector< float > & | rotationPath ()
The rotation to be applied along the extrusion.
const std::vector< vl::fvec4 > & | colorPath () const
The color to be applied to the extrusion.
std::vector< vl::fvec4 > & | colorPath ()
The color to be applied to the extrusion.

Protected Attributes

std::vector< vl::fvec2 > | mSilhouette
std::vector< vl::fvec3 > | mPositionPath
std::vector< float > | mScalingPath
std::vector< float > | mRotationPath
std::vector< vl::fvec4 > | mColorPath
ESilhouetteMode mSilhouetteMode
bool | mSmooth
bool | mFillBottom
bool | mFillTop

Detailed Description

The Extrusion class generates a Geometry extruding a silhouette along a path.

See also:
  • Extrusion Tutorial for a practical example of how to use extrusions.
  • Interpolator, LinearInterpolator, CatmullRomInterpolator to generate silhouettes and extrusion paths.

Constructor & Destructor Documentation

vl::Extrusion::Extrusion ( ) [inline]

Constructor.

Member Function Documentation

ref< Geometry > Extrusion::extrude ( )

Performs the actual extrusion.

void vl::Extrusion::setSilhouette ( const std::vector< vl::fvec2 > & silhouette ) [inline]

Sets the silhouette to be extruded.

const std::vector<vl::fvec2>& vl::Extrusion::silhouette ( ) const [inline]

Returns the silhouette to be extruded.

std::vector<vl::fvec2>& vl::Extrusion::silhouette ( ) [inline]

Returns the silhouette to be extruded.

void vl::Extrusion::setSilhouetteMode ( ESilhouetteMode mode ) [inline]

Wether the silhouette is considered closed, i.e. a line-loop, or open.

ESilhouetteMode vl::Extrusion::silhouetteMode ( ) const [inline]

Wether the silhouette is considered closed, i.e. a line-loop, or open.

void vl::Extrusion::setSmooth ( bool smooth ) [inline]

If true the normals of the geometry are smoothed.

bool vl::Extrusion::smooth ( ) const [inline]

If true the normals of the geometry are smoothed.

void vl::Extrusion::setFillBottom ( bool fill ) [inline]

Whether a set of triangles should be generated to fill the beginning of the extrusion (default is true).

bool vl::Extrusion::fillBottom ( ) const [inline]

Whether a set of triangles should be generated to fill the beginning of the extrusion (default is true).

void vl::Extrusion::setFillTop ( bool fill ) [inline]

Whether a set of triangles should be generated to fill the ending of the extrusion (default is true).

bool vl::Extrusion::fillTop ( ) const [inline]

Whether a set of triangles should be generated to fill the ending of the extrusion (default is true).

const std::vector<vl::fvec3>& vl::Extrusion::positionPath ( ) const [inline]

The path along which the silhouette is extruded.

The path starts and ends with one extra control point on each side that define the orientation of the start/end extruded segments.

std::vector<vl::fvec3>& vl::Extrusion::positionPath ( ) [inline]

The path along which the silhouette is extruded.

The path starts and ends with one extra control point on each side that define the orientation of the start/end extruded segments.

const std::vector<float>& vl::Extrusion::scalingPath ( ) const [inline]

The scaling to be applied along the extrusion.

There must be one scaling control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e scalingPath().size() must be equal to positionPath().size()-2.

std::vector<float>& vl::Extrusion::scalingPath ( ) [inline]

The scaling to be applied along the extrusion.

There must be one scaling control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e scalingPath().size() must be equal to positionPath().size()-2.

const std::vector<float>& vl::Extrusion::rotationPath ( ) const [inline]

The rotation to be applied along the extrusion.

There must be one rotation control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e rotationPath().size() must be equal to positionPath().size()-2.

std::vector<float>& vl::Extrusion::rotationPath ( ) [inline]

The rotation to be applied along the extrusion.

There must be one rotation control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e rotationPath().size() must be equal to positionPath().size()-2.

const std::vector<vl::fvec4>& vl::Extrusion::colorPath ( ) const [inline]

The color to be applied to the extrusion.

There must be one color control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e colorPath().size() must be equal to positionPath().size()-2.

std::vector<vl::fvec4>& vl::Extrusion::colorPath ( ) [inline]

The color to be applied to the extrusion.

There must be one color control point for each position control point in the positionPath() with the exclusion of the starting and ending control points, i.e colorPath().size() must be equal to positionPath().size()-2.

Member Data Documentation

std::vector<vl::fvec2> vl::Extrusion::mSilhouette [protected]

std::vector<vl::fvec3> vl::Extrusion::mPositionPath [protected]

std::vector<float> vl::Extrusion::mScalingPath [protected]

std::vector<float> vl::Extrusion::mRotationPath [protected]

std::vector<vl::fvec4> vl::Extrusion::mColorPath [protected]

ESilhouetteMode vl::Extrusion::mSilhouetteMode [protected]

bool vl::Extrusion::mSmooth [protected]

bool vl::Extrusion::mFillBottom [protected]

bool vl::Extrusion::mFillTop [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOAttachmentAbstract Class Reference

vl::FBOAttachmentAbstract

vl::FBOAttachmentAbstract Class Reference

Abstract class that represents a framebuffer object attachment, i.e. More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOAttachmentAbstract:

vl::Object vl::FBORenderbufferAttachment vl::FBOTexture1DAttachment vl::FBOTexture2DAttachment vl::FBOTexture3DAttachment vl::FBOTextureAttachment vl::FBOTextureLayerAttachment vl::FBOColorBufferAttachment vl::FBODepthBufferAttachment vl::FBODepthStencilBufferAttachment vl::FBOStencilBufferAttachment

List of all members.

Public Member Functions

FBOAttachmentAbstract ()
virtual const char * | className ()
Returns the name of the class.
virtual | ~FBOAttachmentAbstract ()
virtual void | destroy ()
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)=0
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).
const std::set< ref
< FBORenderTarget > > & 		fboRenderTargets () const
Returns an std::set containing the FBORenderTarget that use this FBO attachment.

Protected Attributes

std::set< ref< FBORenderTarget > > | mFBORenderTargets

Friends

class | FBORenderTarget

Detailed Description

Abstract class that represents a framebuffer object attachment, i.e.

a texture or renderbuffer attachment.

Constructor & Destructor Documentation

vl::FBOAttachmentAbstract::FBOAttachmentAbstract ( ) [inline]

virtual vl::FBOAttachmentAbstract::~FBOAttachmentAbstract ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::FBOAttachmentAbstract::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::FBORenderbufferAttachment, vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBOStencilBufferAttachment, vl::FBODepthStencilBufferAttachment, vl::FBOTexture1DAttachment, vl::FBOTexture2DAttachment, vl::FBOTextureAttachment, vl::FBOTexture3DAttachment, and vl::FBOTextureLayerAttachment.

void FBOAttachmentAbstract::destroy ( ) [virtual]

Reimplemented in vl::FBORenderbufferAttachment.

virtual void vl::FBOAttachmentAbstract::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [pure virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implemented in vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBOStencilBufferAttachment, vl::FBODepthStencilBufferAttachment, vl::FBOTexture1DAttachment, vl::FBOTexture2DAttachment, vl::FBOTextureAttachment, vl::FBOTexture3DAttachment, and vl::FBOTextureLayerAttachment.

const std::set< ref<FBORenderTarget> >& vl::FBOAttachmentAbstract::fboRenderTargets ( ) const [inline]

Returns an std::set containing the FBORenderTarget that use this FBO attachment.

Friends And Related Function Documentation

friend class FBORenderTarget [friend]

Reimplemented in vl::FBORenderbufferAttachment.

Member Data Documentation

std::set< ref<FBORenderTarget> > vl::FBOAttachmentAbstract::mFBORenderTargets [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOColorBufferAttachment Class Reference

vl::FBOColorBufferAttachment

vl::FBOColorBufferAttachment Class Reference

A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOColorBufferAttachment:

vl::FBORenderbufferAttachment vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOColorBufferAttachment (EColorBufferFormat type)
virtual const char * | className ()
Returns the name of the class.
void | setType (EColorBufferFormat type)
Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.
EColorBufferFormat | type () const
void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Member Functions

virtual int | internalType ()

Protected Attributes

EColorBufferFormat mType

Detailed Description

A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Supports GL_EXT_framebuffer_multisample.

Constructor & Destructor Documentation

vl::FBOColorBufferAttachment::FBOColorBufferAttachment ( EColorBufferFormat type ) [inline]

Member Function Documentation

virtual const char* vl::FBOColorBufferAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBORenderbufferAttachment.

void vl::FBOColorBufferAttachment::setType ( EColorBufferFormat type ) [inline]

Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.

EColorBufferFormat vl::FBOColorBufferAttachment::type ( ) const [inline]

void vl::FBOColorBufferAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [inline, virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

virtual int vl::FBOColorBufferAttachment::internalType ( ) [inline, protected, virtual]

Implements vl::FBORenderbufferAttachment.

Member Data Documentation

EColorBufferFormat vl::FBOColorBufferAttachment::mType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBODepthBufferAttachment Class Reference

vl::FBODepthBufferAttachment

vl::FBODepthBufferAttachment Class Reference

A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBODepthBufferAttachment:

vl::FBORenderbufferAttachment vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBODepthBufferAttachment (EDepthType type)
virtual const char * | className ()
Returns the name of the class.
void | setType (EDepthType type)
Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.
EDepthType | type () const
void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Member Functions

virtual int | internalType ()

Protected Attributes

EDepthType mType

Detailed Description

A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Supports GL_EXT_framebuffer_multisample.

Constructor & Destructor Documentation

vl::FBODepthBufferAttachment::FBODepthBufferAttachment ( EDepthType type ) [inline]

Member Function Documentation

virtual const char* vl::FBODepthBufferAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBORenderbufferAttachment.

void vl::FBODepthBufferAttachment::setType ( EDepthType type ) [inline]

Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.

EDepthType vl::FBODepthBufferAttachment::type ( ) const [inline]

void vl::FBODepthBufferAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [inline, virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

virtual int vl::FBODepthBufferAttachment::internalType ( ) [inline, protected, virtual]

Implements vl::FBORenderbufferAttachment.

Member Data Documentation

EDepthType vl::FBODepthBufferAttachment::mType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBODepthStencilBufferAttachment Class Reference

vl::FBODepthStencilBufferAttachment

vl::FBODepthStencilBufferAttachment Class Reference

A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBODepthStencilBufferAttachment:

vl::FBORenderbufferAttachment vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBODepthStencilBufferAttachment (EDepthStencilType type)
virtual const char * | className ()
Returns the name of the class.
void | setType (EDepthStencilType type)
Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.
EDepthStencilType | type () const
void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Member Functions

virtual int | internalType ()

Protected Attributes

EDepthStencilType mType

Detailed Description

A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Supports GL_EXT_framebuffer_multisample.

Constructor & Destructor Documentation

vl::FBODepthStencilBufferAttachment::FBODepthStencilBufferAttachment ( EDepthStencilType type ) [inline]

Member Function Documentation

virtual const char* vl::FBODepthStencilBufferAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBORenderbufferAttachment.

void vl::FBODepthStencilBufferAttachment::setType ( EDepthStencilType type ) [inline]

Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.

EDepthStencilType vl::FBODepthStencilBufferAttachment::type ( ) const [inline]

void vl::FBODepthStencilBufferAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [inline, virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

virtual int vl::FBODepthStencilBufferAttachment::internalType ( ) [inline, protected, virtual]

Implements vl::FBORenderbufferAttachment.

Member Data Documentation

EDepthStencilType vl::FBODepthStencilBufferAttachment::mType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBORenderbufferAttachment Class Reference

vl::FBORenderbufferAttachment

vl::FBORenderbufferAttachment Class Reference

Abstract class that represents a framebuffer renderbuffer attachment, i.e. More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBORenderbufferAttachment:

vl::FBOAttachmentAbstract vl::Object vl::FBOColorBufferAttachment vl::FBODepthBufferAttachment vl::FBODepthStencilBufferAttachment vl::FBOStencilBufferAttachment

List of all members.

Public Member Functions

FBORenderbufferAttachment ()
virtual const char * | className ()
Returns the name of the class.
void | create ()
Creates a renderbuffer object calling glGenRenderbuffers().
void | destroy ()
Deletes the renderbuffer object created with the create() function.
unsigned int | handle () const
Returns the handle obtained by create() using glGenRenderbuffers().
void | initStorage (int w, int h)
Initializes the storage of the renderbuffer with the given dimensions.
void | initStorage ()
The same as calling initStorage(width(), height());.
int | width () const
Returns the with of the allocated renderbuffer storage.
int | height () const
Returns the with of the allocated renderbuffer storage.
int | samples () const
Returns the number of samples to be used when allocating the renderbuffer's storage.
void | setWidth (int w)
Defines the width to be specified when allocating the renderbuffer storage.
void | setHeight (int h)
Defines the height to be specified when allocating the renderbuffer storage.
void | setSamples (int samples)
Sets the number of samples to be specified when allocating the renderbuffer's storage. Note that this function schedules a reallocation of the renderbuffer storage.
bool | renderbufferStorageReady () const
Returns false if the renderbuffer storage needs to be created or reallocated due to a change of the sample count or renderbuffer type.

Protected Member Functions

virtual int | internalType ()=0
void | internalBindAttachment (int w, int h, int attach_point)

Protected Attributes

unsigned int | mHandle
int | mWidth
int | mHeight
int | mSamples
bool | mReallocateRenderbuffer

Friends

class | FBORenderTarget

Detailed Description

Abstract class that represents a framebuffer renderbuffer attachment, i.e.

a non texture fbo attachment.

Constructor & Destructor Documentation

vl::FBORenderbufferAttachment::FBORenderbufferAttachment ( ) [inline]

Member Function Documentation

virtual const char* vl::FBORenderbufferAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

Reimplemented in vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBOStencilBufferAttachment, and vl::FBODepthStencilBufferAttachment.

void FBORenderbufferAttachment::create ( )

Creates a renderbuffer object calling glGenRenderbuffers().

The identifier returned by glGenRenderbuffers() can be queried calling the handle() method.

void FBORenderbufferAttachment::destroy ( ) [virtual]

Deletes the renderbuffer object created with the create() function.

Reimplemented from vl::FBOAttachmentAbstract.

unsigned int vl::FBORenderbufferAttachment::handle ( ) const [inline]

Returns the handle obtained by create() using glGenRenderbuffers().

void FBORenderbufferAttachment::initStorage | ( | int | w,
 |  | int | h
 | ) |  |

Initializes the storage of the renderbuffer with the given dimensions.

Note that the renderbuffer storage type is defined by the setType() method of FBOColorBufferAttachment, FBODepthBufferAttachment, FBOStencilBufferAttachment, FBODepthStencilBufferAttachment. See also setSamples().

void vl::FBORenderbufferAttachment::initStorage ( ) [inline]

The same as calling initStorage(width(), height());.

int vl::FBORenderbufferAttachment::width ( ) const [inline]

Returns the with of the allocated renderbuffer storage.

int vl::FBORenderbufferAttachment::height ( ) const [inline]

Returns the with of the allocated renderbuffer storage.

int vl::FBORenderbufferAttachment::samples ( ) const [inline]

Returns the number of samples to be used when allocating the renderbuffer's storage.

void vl::FBORenderbufferAttachment::setWidth ( int w ) [inline]

Defines the width to be specified when allocating the renderbuffer storage.

Note that this function schedules a reallocation of the renderbuffer storage. If 'w' is set to 0 the renderbuffer storage allocation will use the default dimensions specified by the FBORenderTarget.

void vl::FBORenderbufferAttachment::setHeight ( int h ) [inline]

Defines the height to be specified when allocating the renderbuffer storage.

Note that this function schedules a reallocation of the renderbuffer storage. If 'h' is set to 0 the renderbuffer storage allocation will use the default dimensions specified by the FBORenderTarget.

void vl::FBORenderbufferAttachment::setSamples ( int samples ) [inline]

Sets the number of samples to be specified when allocating the renderbuffer's storage. Note that this function schedules a reallocation of the renderbuffer storage.

bool vl::FBORenderbufferAttachment::renderbufferStorageReady ( ) const [inline]

Returns false if the renderbuffer storage needs to be created or reallocated due to a change of the sample count or renderbuffer type.

virtual int vl::FBORenderbufferAttachment::internalType ( ) [protected, pure virtual]

Implemented in vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBOStencilBufferAttachment, and vl::FBODepthStencilBufferAttachment.

void FBORenderbufferAttachment::internalBindAttachment | ( | int | w,
 |  | int | h,
 |  | int | attach_point |
 | ) |  |  | [protected]

Friends And Related Function Documentation

friend class FBORenderTarget [friend]

Reimplemented from vl::FBOAttachmentAbstract.

Member Data Documentation

unsigned int vl::FBORenderbufferAttachment::mHandle [protected]

int vl::FBORenderbufferAttachment::mWidth [protected]

int vl::FBORenderbufferAttachment::mHeight [protected]

int vl::FBORenderbufferAttachment::mSamples [protected]

bool vl::FBORenderbufferAttachment::mReallocateRenderbuffer [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBORenderTarget Class Reference

vl::FBORenderTarget

vl::FBORenderTarget Class Reference

Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension. More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBORenderTarget:

vl::RenderTarget vl::Object

List of all members.

Public Member Functions

~FBORenderTarget ()
virtual const char * | className ()
Returns the name of the class.
virtual void | bindFramebuffer ()
Makes the framebuffer the current rendering target calling glBindFramebuffer(GL_FRAMEBUFFER, FBORenderTarget::handle()) and initializes all the previously defined attachment points.
GLenum | checkFramebufferStatus ()
Returns 0 if no FBO support is found otherwise returns the value obtained from VL_glCheckFramebufferStatus().
void | printFramebufferError (GLenum status) const
void | create ()
void | destroy ()
void | addColorAttachment (EAttachmentPoint color_attachment, FBOAttachmentAbstract *attachment)
void | addTextureAttachment (EAttachmentPoint color_attachment, FBOAttachmentAbstract *attachment)
void | addDepthAttachment (FBOAttachmentAbstract *attachment)
void | addStencilAttachment (FBOAttachmentAbstract *attachment)
const std::map
< EAttachmentPoint, ref
< FBOAttachmentAbstract > > & 		fboAttachments () const
void | removeAttachment (FBOAttachmentAbstract *attachment)
void | removeAttachment (EAttachmentPoint attach_point)
void | removeAllAttachments ()
unsigned int | handle () const

Public Attributes

std::map< EAttachmentPoint,
ref< FBOAttachmentAbstract > > 		mFBOAttachments
unsigned int | mHandle

Friends

class | OpenGLContext

Detailed Description

Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension.

An FBORenderTarget belongs to one and only one OpenGLContext and can be created using the OpenGLContext::createFBORenderTarget() method. To render to a FBORenderTarget use the Rendering::setRenderTarget() function.

Remarks:
Before using any method from FBORenderTarget make sure that the appropriate OpenGL rendering context is active using FBORenderTarget::openglContext()->makeCurrent()

All the renderbuffer attachments must specify the same number of samples.

Constructor & Destructor Documentation

vl::FBORenderTarget::~FBORenderTarget ( ) [inline]

Member Function Documentation

virtual const char* vl::FBORenderTarget::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderTarget.

void FBORenderTarget::bindFramebuffer ( ) [virtual]

Makes the framebuffer the current rendering target calling glBindFramebuffer(GL_FRAMEBUFFER, FBORenderTarget::handle()) and initializes all the previously defined attachment points.

Reimplemented from vl::RenderTarget.

GLenum FBORenderTarget::checkFramebufferStatus ( )

Returns 0 if no FBO support is found otherwise returns the value obtained from VL_glCheckFramebufferStatus().

void FBORenderTarget::printFramebufferError ( GLenum status ) const

void vl::FBORenderTarget::create ( ) [inline]

void vl::FBORenderTarget::destroy ( ) [inline]

void FBORenderTarget::addColorAttachment | ( | EAttachmentPoint | color_attachment,
 |  | FBOAttachmentAbstract * | attachment
 | ) |  |

void FBORenderTarget::addTextureAttachment | ( | EAttachmentPoint | color_attachment,
 |  | FBOAttachmentAbstract * | attachment
 | ) |  |

void FBORenderTarget::addDepthAttachment ( FBOAttachmentAbstract * attachment )

void FBORenderTarget::addStencilAttachment ( FBOAttachmentAbstract * attachment )

const std::map< EAttachmentPoint, ref<FBOAttachmentAbstract> >& vl::FBORenderTarget::fboAttachments ( ) const [inline]

void FBORenderTarget::removeAttachment ( FBOAttachmentAbstract * attachment )

void FBORenderTarget::removeAttachment ( EAttachmentPoint attach_point )

void FBORenderTarget::removeAllAttachments ( )

unsigned int vl::FBORenderTarget::handle ( ) const [inline]

Friends And Related Function Documentation

friend class OpenGLContext [friend]

Reimplemented from vl::RenderTarget.

Member Data Documentation

std::map< EAttachmentPoint, ref<FBOAttachmentAbstract> > vl::FBORenderTarget::mFBOAttachments

unsigned int vl::FBORenderTarget::mHandle

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOStencilBufferAttachment Class Reference

vl::FBOStencilBufferAttachment

vl::FBOStencilBufferAttachment Class Reference

A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOStencilBufferAttachment:

vl::FBORenderbufferAttachment vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOStencilBufferAttachment (EStencilType type)
virtual const char * | className ()
Returns the name of the class.
void | setType (EStencilType type)
Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.
EStencilType | type () const
void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Member Functions

virtual int | internalType ()

Protected Attributes

EStencilType mType

Detailed Description

A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Supports GL_EXT_framebuffer_multisample.

Constructor & Destructor Documentation

vl::FBOStencilBufferAttachment::FBOStencilBufferAttachment ( EStencilType type ) [inline]

Member Function Documentation

virtual const char* vl::FBOStencilBufferAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBORenderbufferAttachment.

void vl::FBOStencilBufferAttachment::setType ( EStencilType type ) [inline]

Defines the type to specify when allocating the renderbuffer storage. Note that this function schedules a reallocation of the renderbuffer storage.

EStencilType vl::FBOStencilBufferAttachment::type ( ) const [inline]

void vl::FBOStencilBufferAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [inline, virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

virtual int vl::FBOStencilBufferAttachment::internalType ( ) [inline, protected, virtual]

Implements vl::FBORenderbufferAttachment.

Member Data Documentation

EStencilType vl::FBOStencilBufferAttachment::mType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOTexture1DAttachment Class Reference

vl::FBOTexture1DAttachment

vl::FBOTexture1DAttachment Class Reference

A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOTexture1DAttachment:

vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOTexture1DAttachment (Texture *texture, int level)
virtual const char * | className ()
Returns the name of the class.
Texture * texture ()
const Texture * | texture () const
int | level () const
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Attributes

ref< Texture > mTexture
int | mLevel

Detailed Description

A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Wraps the function glFramebufferTexture1DEXT.

Constructor & Destructor Documentation

vl::FBOTexture1DAttachment::FBOTexture1DAttachment | ( | Texture * | texture,
 |  | int | level |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::FBOTexture1DAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

Texture* vl::FBOTexture1DAttachment::texture ( ) [inline]

const Texture* vl::FBOTexture1DAttachment::texture ( ) const [inline]

int vl::FBOTexture1DAttachment::level ( ) const [inline]

void FBOTexture1DAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

Member Data Documentation

ref<Texture> vl::FBOTexture1DAttachment::mTexture [protected]

int vl::FBOTexture1DAttachment::mLevel [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOTexture2DAttachment Class Reference

vl::FBOTexture2DAttachment

vl::FBOTexture2DAttachment Class Reference

A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOTexture2DAttachment:

vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
FBOTexture2DAttachment (Texture *texture, int level, ETex2DTarget target)
void | setTexture (Texture *texture)
Texture * texture ()
const Texture * | texture () const
int | level () const
ETex2DTarget | textureTarget () const
void | setTextureTarget (ETex2DTarget target)
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Attributes

ref< Texture > mTexture
ETex2DTarget mTextureTarget
int | mLevel

Detailed Description

A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Wraps the function glFramebufferTexture2DEXT.

Constructor & Destructor Documentation

vl::FBOTexture2DAttachment::FBOTexture2DAttachment | ( | Texture * | texture,
 |  | int | level,
 |  | ETex2DTarget | target |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::FBOTexture2DAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

void vl::FBOTexture2DAttachment::setTexture ( Texture * texture ) [inline]

Texture* vl::FBOTexture2DAttachment::texture ( ) [inline]

const Texture* vl::FBOTexture2DAttachment::texture ( ) const [inline]

int vl::FBOTexture2DAttachment::level ( ) const [inline]

ETex2DTarget vl::FBOTexture2DAttachment::textureTarget ( ) const [inline]

void vl::FBOTexture2DAttachment::setTextureTarget ( ETex2DTarget target ) [inline]

void FBOTexture2DAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

Member Data Documentation

ref<Texture> vl::FBOTexture2DAttachment::mTexture [protected]

ETex2DTarget vl::FBOTexture2DAttachment::mTextureTarget [protected]

int vl::FBOTexture2DAttachment::mLevel [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOTexture3DAttachment Class Reference

vl::FBOTexture3DAttachment

vl::FBOTexture3DAttachment Class Reference

A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOTexture3DAttachment:

vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOTexture3DAttachment (Texture *texture, int mipmap_level, int layer)
virtual const char * | className ()
Returns the name of the class.
Texture * texture ()
const Texture * | texture () const
int | mipmapLevel () const
void | setMipmapLevel (int level)
int | layer () const
void | setLayer (int layer)
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Attributes

ref< Texture > mTexture
int | mMipmapLevel
int | mLayer

Detailed Description

A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Wraps the function glFramebufferTexture3DEXT.

Constructor & Destructor Documentation

vl::FBOTexture3DAttachment::FBOTexture3DAttachment | ( | Texture * | texture,
 |  | int | mipmap_level,
 |  | int | layer |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::FBOTexture3DAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

Texture* vl::FBOTexture3DAttachment::texture ( ) [inline]

const Texture* vl::FBOTexture3DAttachment::texture ( ) const [inline]

int vl::FBOTexture3DAttachment::mipmapLevel ( ) const [inline]

void vl::FBOTexture3DAttachment::setMipmapLevel ( int level ) [inline]

int vl::FBOTexture3DAttachment::layer ( ) const [inline]

void vl::FBOTexture3DAttachment::setLayer ( int layer ) [inline]

void FBOTexture3DAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

Member Data Documentation

ref<Texture> vl::FBOTexture3DAttachment::mTexture [protected]

int vl::FBOTexture3DAttachment::mMipmapLevel [protected]

int vl::FBOTexture3DAttachment::mLayer [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOTextureAttachment Class Reference

vl::FBOTextureAttachment

vl::FBOTextureAttachment Class Reference

A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOTextureAttachment:

vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOTextureAttachment (Texture *texture, int level)
virtual const char * | className ()
Returns the name of the class.
Texture * texture ()
const Texture * | texture () const
int | level () const
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Attributes

ref< Texture > mTexture
int | mLevel

Detailed Description

A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Wraps the glFramebufferTextureEXT function from GL_ARB_geometry_shader4.

Constructor & Destructor Documentation

vl::FBOTextureAttachment::FBOTextureAttachment | ( | Texture * | texture,
 |  | int | level |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::FBOTextureAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

Texture* vl::FBOTextureAttachment::texture ( ) [inline]

const Texture* vl::FBOTextureAttachment::texture ( ) const [inline]

int vl::FBOTextureAttachment::level ( ) const [inline]

void FBOTextureAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

Member Data Documentation

ref<Texture> vl::FBOTextureAttachment::mTexture [protected]

int vl::FBOTextureAttachment::mLevel [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FBOTextureLayerAttachment Class Reference

vl::FBOTextureLayerAttachment

vl::FBOTextureLayerAttachment Class Reference

A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...

#include <FramebufferObject.hpp>

Inheritance diagram for vl::FBOTextureLayerAttachment:

vl::FBOAttachmentAbstract vl::Object

List of all members.

Public Member Functions

FBOTextureLayerAttachment (Texture *texture, int mipmap_level, int layer)
virtual const char * | className ()
Returns the name of the class.
Texture * texture ()
const Texture * | texture () const
int | mipmapLevel () const
void | setMipmapLevel (int level)
int | layer () const
void | setLayer (int layer)
virtual void | bindAttachment (int w, int h, EAttachmentPoint attach_point)
Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

Protected Attributes

ref< Texture > mTexture
int | mMipmapLevel
int | mLayer

Detailed Description

A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget).

Wraps the function glFramebufferTextureLayerEXT from GL_EXT_texture_array and GL_ARB_geometry_shader4.

Constructor & Destructor Documentation

vl::FBOTextureLayerAttachment::FBOTextureLayerAttachment | ( | Texture * | texture,
 |  | int | mipmap_level,
 |  | int | layer |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::FBOTextureLayerAttachment::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::FBOAttachmentAbstract.

Texture* vl::FBOTextureLayerAttachment::texture ( ) [inline]

const Texture* vl::FBOTextureLayerAttachment::texture ( ) const [inline]

int vl::FBOTextureLayerAttachment::mipmapLevel ( ) const [inline]

void vl::FBOTextureLayerAttachment::setMipmapLevel ( int level ) [inline]

int vl::FBOTextureLayerAttachment::layer ( ) const [inline]

void vl::FBOTextureLayerAttachment::setLayer ( int layer ) [inline]

void FBOTextureLayerAttachment::bindAttachment | ( | int | w,
 |  | int | h,
 |  | EAttachmentPoint | attach_point |
 | ) |  |  | [virtual]

Binds this renderbuffer to the currently active framebuffer object (GL_FRAMEBUFFER).

This function also initializes its storage if 'w' and 'h' differ from the renderbuffer's current width() and height() and the renderbuffer is not a texture.

Implements vl::FBOAttachmentAbstract.

Member Data Documentation

ref<Texture> vl::FBOTextureLayerAttachment::mTexture [protected]

int vl::FBOTextureLayerAttachment::mMipmapLevel [protected]

int vl::FBOTextureLayerAttachment::mLayer [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FileSystem Class Reference

vl::FileSystem

vl::FileSystem Class Reference

Manages multiple VirtualDirectory objects. More...

#include <FileSystem.hpp>

Inheritance diagram for vl::FileSystem:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
FileSystem ()
virtual ref< VirtualFile > | locateFile (const String &full_path, const String &alternate_path=String()) const
Looks for a VirtualFile on the disk and in the currently active FileSystem.
virtual ref< VirtualDirectory > | locateDirectory (const String &name) const
virtual void | listFilesRecursive (std::vector< String > &file_list) const
Returns the names of all the files contained in the previously added Directories.
virtual void | listFilesRecursive (std::vector< String > &file_list, const String &match) const
Returns the names of all the files matching the given filter.
Collection< VirtualDirectory > * directories ()
Returns the list of VirtualDirectory objects added to a FileSystem.
const Collection
< VirtualDirectory > * 		directories () const
Returns the list of VirtualDirectory objects added to a FileSystem.

Protected Attributes

Collection< VirtualDirectory > mDirectories

Detailed Description

Manages multiple VirtualDirectory objects.

Useful when you want to query more than one VirtualDirectory from a single point.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • VirtualFile
  • DiskFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

vl::FileSystem::FileSystem ( ) [inline]

Member Function Documentation

virtual const char* vl::FileSystem::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

ref< VirtualFile > FileSystem::locateFile | ( | const String & | full_path,
 |  | const String & | alternate_path = String() |
 | ) |  |  | const [virtual]

Looks for a VirtualFile on the disk and in the currently active FileSystem.

If more than a file exists with the same name the VirtualFile returned is the one found in the VirtualDirectory added the latest.

This means that a VirtualDirectory overrides the ones added before if duplicate file name exists. If a file with the given name exists in the "." directory it will be located and returned immediately.

Visualization Library locates a file scanning the following paths (in the specified order):

  • first split full_path into file_path and file_name

  • look for the following file paths:
    1. ./file_path/file_name
    2. /fs/file_path/file_name
    3. ./alternate_path/file_path/file_name
    4. /fs/alternate_path/file_path/file_name
    5. ./file_name
    6. /fs/file_name
    7. ./alternate_path/file_name
    8. /fs/alternate_path/file_name

"/fs" stays for Visualization Library currently mounted FileSystems.

ref< VirtualDirectory > FileSystem::locateDirectory ( const String & name ) const [virtual]

void FileSystem::listFilesRecursive ( std::vector< String > & file_list ) const [virtual]

Returns the names of all the files contained in the previously added Directories.

Files from different Directories but with the same name appear more than once in 'file_list'. Use carefully this function as it enumerates recursively all the files in the directory trees.

void FileSystem::listFilesRecursive | ( | std::vector< String > & | file_list,
 |  | const String & | match |
 | ) |  |  | const [virtual]

Returns the names of all the files matching the given filter.

Use carefully this function since it enumerates recursively all the files in the directory trees. The match parameter must be of the type "*abc" or "*abc*" or "abc*".

Collection<VirtualDirectory>* vl::FileSystem::directories ( ) [inline]

Returns the list of VirtualDirectory objects added to a FileSystem.

const Collection<VirtualDirectory>* vl::FileSystem::directories ( ) const [inline]

Returns the list of VirtualDirectory objects added to a FileSystem.

Member Data Documentation

Collection<VirtualDirectory> vl::FileSystem::mDirectories [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::Fog Class Reference

vl::Fog

vl::Fog Class Reference

Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::Fog:

vl::RenderState vl::Object

List of all members.

Public Member Functions

Fog (EFogMode mode=FM_LINEAR, fvec4 color=fvec4(0, 0, 0, 0), float density=1, float start=0, float end=1)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EFogMode mode, fvec4 color, float density, float start, float end)
void | setColor (fvec4 color)
void | setMode (EFogMode mode)
void | setDensity (float density)
void | setStart (float start)
void | setEnd (float end)
fvec4 | color () const
EFogMode | mode () const
float | density () const
float | start () const
float | end () const

Protected Attributes

fvec4 mColor
EFogMode mMode
float | mDensity
float | mStart
float | mEnd

Detailed Description

Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_FOG

Constructor & Destructor Documentation

vl::Fog::Fog | ( | EFogMode | mode = FM_LINEAR,
 |  | fvec4 | color = fvec4(0,0,0,0),
 |  | float | density = 1,
 |  | float | start = 0,
 |  | float | end = 1 |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::Fog::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::Fog::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void Fog::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::Fog::set | ( | EFogMode | mode,
 |  | fvec4 | color,
 |  | float | density,
 |  | float | start,
 |  | float | end |
 | ) |  |  | [inline]

void vl::Fog::setColor ( fvec4 color ) [inline]

void vl::Fog::setMode ( EFogMode mode ) [inline]

void vl::Fog::setDensity ( float density ) [inline]

void vl::Fog::setStart ( float start ) [inline]

void vl::Fog::setEnd ( float end ) [inline]

fvec4 vl::Fog::color ( ) const [inline]

EFogMode vl::Fog::mode ( ) const [inline]

float vl::Fog::density ( ) const [inline]

float vl::Fog::start ( ) const [inline]

float vl::Fog::end ( ) const [inline]

Member Data Documentation

fvec4 vl::Fog::mColor [protected]

EFogMode vl::Fog::mMode [protected]

float vl::Fog::mDensity [protected]

float vl::Fog::mStart [protected]

float vl::Fog::mEnd [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Font Class Reference

vl::Font

vl::Font Class Reference

A font to be used with a Text renderable. More...

#include <Font.hpp>

Inheritance diagram for vl::Font:

vl::Object

List of all members.

Public Member Functions

~Font ()
virtual const char * | className ()
Returns the name of the class.
bool | operator< (const Font &other) const
const String & | filePath () const
void | loadFont (const String &path)
Loads a font using fileSystem()locateFile().
int | size () const
void | setSize (int size)
Glyph * | glyph (int character)
void | setSmooth (bool smooth)
bool | smooth () const
void | releaseFreeTypeData ()

Protected Attributes

String mFilePath
std::map< int, ref< Glyph > > | mGlyphMap
FT_Face mFT_Face
std::vector< unsigned char > | mMemoryFile
int | mSize
float | mHeight
bool | mSmooth

Friends

class | Text
class | FontManager

Detailed Description

A font to be used with a Text renderable.

Constructor & Destructor Documentation

vl::Font::~Font ( )

Member Function Documentation

virtual const char* vl::Font::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

bool vl::Font::operator< ( const Font & other ) const [inline]

const String& vl::Font::filePath ( ) const [inline]

void vl::Font::loadFont ( const String & path )

Loads a font using fileSystem()locateFile().

int vl::Font::size ( ) const [inline]

void vl::Font::setSize ( int size )

Glyph* vl::Font::glyph ( int character )

void vl::Font::setSmooth ( bool smooth )

bool vl::Font::smooth ( ) const [inline]

void vl::Font::releaseFreeTypeData ( )

Friends And Related Function Documentation

friend class Text [friend]

friend class FontManager [friend]

Member Data Documentation

String vl::Font::mFilePath [protected]

std::map< int, ref<Glyph> > vl::Font::mGlyphMap [protected]

FT_Face vl::Font::mFT_Face [protected]

std::vector<unsigned char> vl::Font::mMemoryFile [protected]

int vl::Font::mSize [protected]

float vl::Font::mHeight [protected]

bool vl::Font::mSmooth [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FontManager Class Reference

vl::FontManager

vl::FontManager Class Reference

The FontManager class keeps a map associating a font path, size and smoothing flag to a Font object. More...

#include <FontManager.hpp>

Inheritance diagram for vl::FontManager:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Font * | acquireFont (const String &font, int size, bool smooth=false)
const std::vector< ref< Font > > & | fonts () const
void | releaseFont (Font *font)
void | releaseAllFonts ()

Protected Attributes

std::vector< ref< Font > > | mFonts

Detailed Description

The FontManager class keeps a map associating a font path, size and smoothing flag to a Font object.

See also:
  • Font
  • Text
  • Actor
  • VectorGraphics

Member Function Documentation

virtual const char* vl::FontManager::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Font * FontManager::acquireFont | ( | const String & | font,
 |  | int | size,
 |  | bool | smooth = false
 | ) |  |

const std::vector< ref<Font> >& vl::FontManager::fonts ( ) const [inline]

void FontManager::releaseFont ( Font * font )

void FontManager::releaseAllFonts ( )

Member Data Documentation

std::vector< ref<Font> > vl::FontManager::mFonts [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::FrontFace Class Reference

vl::FrontFace

vl::FrontFace Class Reference

Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::FrontFace:

vl::RenderState vl::Object

List of all members.

Public Member Functions

FrontFace (EFrontFace frontface=FF_CCW)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EFrontFace frontface)
EFrontFace | frontFace () const

Protected Attributes

EFrontFace mFrontFace

Detailed Description

Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::FrontFace::FrontFace ( EFrontFace frontface = FF_CCW ) [inline]

Member Function Documentation

virtual const char* vl::FrontFace::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::FrontFace::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void FrontFace::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::FrontFace::set ( EFrontFace frontface ) [inline]

EFrontFace vl::FrontFace::frontFace ( ) const [inline]

Member Data Documentation

EFrontFace vl::FrontFace::mFrontFace [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Frustum Class Reference

vl::Frustum

vl::Frustum Class Reference

A set of planes defining a frustum used for culling purposes (frustum culling). More...

#include <Frustum.hpp>

Inheritance diagram for vl::Frustum:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
std::vector< Plane > & | planes ()
const std::vector< Plane > & | planes () const
void | setPlane (unsigned i, const Plane &plane)
const Plane & | plane (unsigned i) const
bool | cull (const Sphere &sphere) const
bool | cull (const AABB &aabb) const
bool | cull (const std::vector< fvec3 > &points) const

Protected Attributes

std::vector< Plane > | mPlanes

Detailed Description

A set of planes defining a frustum used for culling purposes (frustum culling).

See also:
Camera, Viewport

Member Function Documentation

virtual const char* vl::Frustum::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

std::vector<Plane>& vl::Frustum::planes ( ) [inline]

const std::vector<Plane>& vl::Frustum::planes ( ) const [inline]

void vl::Frustum::setPlane | ( | unsigned | i,
 |  | const Plane & | plane |
 | ) |  |  | [inline]

const Plane& vl::Frustum::plane ( unsigned i ) const [inline]

bool vl::Frustum::cull ( const Sphere & sphere ) const [inline]

bool vl::Frustum::cull ( const AABB & aabb ) const [inline]

bool vl::Frustum::cull ( const std::vector< fvec3 > & points ) const [inline]

Member Data Documentation

std::vector<Plane> vl::Frustum::mPlanes [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Frustum.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::Geometry Class Reference

vl::Geometry

vl::Geometry Class Reference

The Geometry class is a Renderable that implements a polygonal mesh made of polygons, lines and points. More...

#include <Geometry.hpp>

Inheritance diagram for vl::Geometry:

vl::Renderable vl::Object vl::BezierSurface

List of all members.

Classes

class | TextureArray

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Geometry ()
Constructor.
virtual | ~Geometry ()
Destructor.
ref< Geometry > shallowCopy ()
Performs a shallow copy (as opposed to a deep copy) of the specified Geometry.
ref< Geometry > | deepCopy () const
Performs a deep copy (as opposed to a shallow copy) of the specified Geometry.
Geometry & | operator= (const Geometry &other)
Performs a shallowCopy() of the Geometry.
virtual void | computeBounds_Implementation ()
int | triangleCount () const
int | lineCount () const
int | pointCount () const
void | computeNormals ()
Computes the normals in a "smooth" way, i.e.
virtual void | render (const Actor *, const OpenGLContext *, const Camera *) const
Renders the Renderable.
virtual void | clearArrays (bool clear_draw_calls=true)
Removes all the previously installed arrays.
void | setColorArray (const fvec4 &col)
Filles the color array with a single color.
void | setVertexArray (ArrayAbstract *data)
void | setNormalArray (ArrayAbstract *data)
void | setColorArray (ArrayAbstract *data)
void | setSecondaryColorArray (ArrayAbstract *data)
void | setFogCoordArray (ArrayAbstract *data)
void | setTexCoordArray (int tex_unit, ArrayAbstract *data)
const ArrayAbstract * | vertexArray () const
ArrayAbstract * vertexArray ()
const ArrayAbstract * | normalArray () const
ArrayAbstract * normalArray ()
const ArrayAbstract * | colorArray () const
ArrayAbstract * colorArray ()
const ArrayAbstract * | secondaryColorArray () const
ArrayAbstract * secondaryColorArray ()
const ArrayAbstract * | fogCoordArray () const
ArrayAbstract * fogCoordArray ()
const ArrayAbstract * | texCoordArray (int tex_unit) const
ArrayAbstract * | texCoordArray (int tex_unit)
Collection
< VertexAttributeArray > * 		vertexAttributeArrays ()
Returns the list of VertexAttributeArray objects bound to a Geometry.
const Collection
< VertexAttributeArray > * 		vertexAttributeArrays () const
Returns the list of VertexAttributeArray objects bound to a Geometry.
void | setVertexAttributeArray (unsigned int name, bool normalize, bool pure_integer, ArrayAbstract *data)
void | setVertexAttributeArray (const VertexAttributeArray &info)
const VertexAttributeArray * | findVertexAttribute (unsigned int name) const
VertexAttributeArray * | findVertexAttribute (unsigned int name)
void | eraseVertexAttributeByName (unsigned int name)
Collection< Primitives > * primitives ()
Returns the list of Primitives objects bound to a Geometry.
const Collection< Primitives > * | primitives () const
Returns the list of Primitives objects bound to a Geometry.
void | updateVBOs (bool discard_local_data=false)
Uploads the data stored in the local buffers on the GPU memory.
void | deleteVBOs ()
Destroyes the VBO (VertexBufferObjects) associated to this Geometry attributes.
void | transform (const mat4 &matr, bool normalize=true)
Transforms vertices and normals belonging to this geometry.
void | shrinkDrawElements ()
Tries to convert DrawElementsUInt in DrawElementsUShort/UByte and DrawElementsUShort in DrawElementsUByte in order to use less memory.
void | mergeTriangleStrips ()
Merges the PT_TRIANGLE_STRIP Primitive objects into one single PT_TRIANGLE_STRIP DrawElements.
void | convertPrimitivesToDrawArrays ()
Converts all the Primitives objects bound to a Geometry into DrawArrays.
bool | sortVertices ()
Sorts the vertices of the geometry to maximize vertex-cache coherency.
void | sortTriangles ()
Calls DrawElements::sortTriangles().
void | colorizePrimitives ()
Assigns a random color to each vertex of each Primitives object. If a vertex is shared among more than one Primitives object its color is undefined.
void | regenerateVertices (const std::vector< unsigned int > &map_new_to_old)
void | updateVBOs ()
Updates the vertex buffer objects.

Detailed Description

The Geometry class is a Renderable that implements a polygonal mesh made of polygons, lines and points.

See also:
  • ArrayAbstract
  • Renderable
  • Actor
  • Transform
  • Effect

Constructor & Destructor Documentation

Geometry::Geometry ( )

Constructor.

Geometry::~Geometry ( ) [virtual]

Destructor.

Member Function Documentation

virtual const char* vl::Geometry::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Renderable.

Reimplemented in vl::BezierSurface.

ref< Geometry > Geometry::shallowCopy ( )

Performs a shallow copy (as opposed to a deep copy) of the specified Geometry.

See also:
deepCopy()

ref< Geometry > Geometry::deepCopy ( ) const

Performs a deep copy (as opposed to a shallow copy) of the specified Geometry.

See also:
shallowCopy()

Geometry & Geometry::operator= ( const Geometry & other )

Performs a shallowCopy() of the Geometry.

void Geometry::computeBounds_Implementation ( ) [virtual]

Implements vl::Renderable.

int Geometry::triangleCount ( ) const [virtual]

Reimplemented from vl::Renderable.

int Geometry::lineCount ( ) const [virtual]

Reimplemented from vl::Renderable.

int Geometry::pointCount ( ) const [virtual]

Reimplemented from vl::Renderable.

void Geometry::computeNormals ( )

Computes the normals in a "smooth" way, i.e.

averaging the normals of those polygons that share one or more vertices.

This function computes smoothed normals for triangle primitives and leaves unchanged the normals of line and point primitives when possible, i.e. when they don't share vertices with the polygonal primitives.

Note:
This function modifies the local buffers. After calling this you might want to update the buffers allocated on the GPU.

void Geometry::render | ( | const Actor * | actor,
 |  | const OpenGLContext * | ,
 |  | const Camera * | camera |
 | ) |  |  | const [virtual]

Renders the Renderable.

Implements vl::Renderable.

void Geometry::clearArrays ( bool clear_draw_calls = true ) [virtual]

Removes all the previously installed arrays.

void Geometry::setColorArray ( const fvec4 & col )

Filles the color array with a single color.

If the color array has been already defined it must be of one of the following types: ArrayFVec3, ArrayFVec4, ArrayUByte3, ArrayUBVec4 If no color array has been defined a new ArrayUBVec4 is installed and filled.

Remarks:
Since the color array element count will be set to the number elements in the position array this function must be called after the position array has been defined.

void Geometry::setVertexArray ( ArrayAbstract * data )

void Geometry::setNormalArray ( ArrayAbstract * data )

void Geometry::setColorArray ( ArrayAbstract * data )

void Geometry::setSecondaryColorArray ( ArrayAbstract * data )

void Geometry::setFogCoordArray ( ArrayAbstract * data )

void Geometry::setTexCoordArray | ( | int | tex_unit,
 |  | ArrayAbstract * | data
 | ) |  |

const ArrayAbstract* vl::Geometry::vertexArray ( ) const [inline]

ArrayAbstract* vl::Geometry::vertexArray ( ) [inline]

const ArrayAbstract* vl::Geometry::normalArray ( ) const [inline]

ArrayAbstract* vl::Geometry::normalArray ( ) [inline]

const ArrayAbstract* vl::Geometry::colorArray ( ) const [inline]

ArrayAbstract* vl::Geometry::colorArray ( ) [inline]

const ArrayAbstract* vl::Geometry::secondaryColorArray ( ) const [inline]

ArrayAbstract* vl::Geometry::secondaryColorArray ( ) [inline]

const ArrayAbstract* vl::Geometry::fogCoordArray ( ) const [inline]

ArrayAbstract* vl::Geometry::fogCoordArray ( ) [inline]

const ArrayAbstract* vl::Geometry::texCoordArray ( int tex_unit ) const [inline]

ArrayAbstract* vl::Geometry::texCoordArray ( int tex_unit ) [inline]

Collection<VertexAttributeArray>* vl::Geometry::vertexAttributeArrays ( ) [inline]

Returns the list of VertexAttributeArray objects bound to a Geometry.

const Collection<VertexAttributeArray>* vl::Geometry::vertexAttributeArrays ( ) const [inline]

Returns the list of VertexAttributeArray objects bound to a Geometry.

void vl::Geometry::setVertexAttributeArray | ( | unsigned int | name,
 |  | bool | normalize,
 |  | bool | pure_integer,
 |  | ArrayAbstract * | data |
 | ) |  |  | [inline]

void Geometry::setVertexAttributeArray ( const VertexAttributeArray & info )

const VertexAttributeArray * Geometry::findVertexAttribute ( unsigned int name ) const

VertexAttributeArray * Geometry::findVertexAttribute ( unsigned int name )

void Geometry::eraseVertexAttributeByName ( unsigned int name )

Collection<Primitives>* vl::Geometry::primitives ( ) [inline]

Returns the list of Primitives objects bound to a Geometry.

const Collection<Primitives>* vl::Geometry::primitives ( ) const [inline]

Returns the list of Primitives objects bound to a Geometry.

void Geometry::updateVBOs ( bool = false ) [virtual]

Uploads the data stored in the local buffers on the GPU memory.

If 'discard_local_data' is set to true the memory used by the local buffers is released.

Reimplemented from vl::Renderable.

void Geometry::deleteVBOs ( ) [virtual]

Destroyes the VBO (VertexBufferObjects) associated to this Geometry attributes.

If 'clear_primitives' all the VBOs associated the Primitives objects are also deleted.

Note:
This function does not touch the local (non GPU) data stored in the buffers associated to the vertex attributes and Primitives.

Reimplemented from vl::Renderable.

void Geometry::transform | ( | const mat4 & | matr,
 |  | bool | normalize = true
 | ) |  |

Transforms vertices and normals belonging to this geometry.

If 'normalize' == true the normals are normalized after being transformed

Note:
This functions supports every possible vertex format, type and layout.
See also:
  • ArrayAbstract::transform()
  • ArrayAbstract::normalize()
  • ArrayAbstract::computeBoundingSphere()
  • ArrayAbstract::computeBoundingBox()

void Geometry::shrinkDrawElements ( )

Tries to convert DrawElementsUInt in DrawElementsUShort/UByte and DrawElementsUShort in DrawElementsUByte in order to use less memory.

void Geometry::mergeTriangleStrips ( )

Merges the PT_TRIANGLE_STRIP Primitive objects into one single PT_TRIANGLE_STRIP DrawElements.

void Geometry::convertPrimitivesToDrawArrays ( )

Converts all the Primitives objects bound to a Geometry into DrawArrays.

bool Geometry::sortVertices ( )

Sorts the vertices of the geometry to maximize vertex-cache coherency.

This function will work only if all the Primitives are DrawElements.

Returns:
true if all the Primitives are DrawElements and the sorting took place.

void Geometry::sortTriangles ( )

Calls DrawElements::sortTriangles().

void Geometry::colorizePrimitives ( )

Assigns a random color to each vertex of each Primitives object. If a vertex is shared among more than one Primitives object its color is undefined.

void Geometry::regenerateVertices ( const std::vector< unsigned int > & map_new_to_old )

void vl::Geometry::updateVBOs ( )

Updates the vertex buffer objects.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::GeometryLoadCallback Class Reference

vl::GeometryLoadCallback

vl::GeometryLoadCallback Class Reference

Defines a set of actions to be executed to a Geometry as soon as it is loaded. More...

#include <GeometryLoadCallback.hpp>

Inheritance diagram for vl::GeometryLoadCallback:

vl::LoadCallback vl::Object

List of all members.

Public Member Functions

GeometryLoadCallback ()
virtual const char * | className ()
Returns the name of the class.
void | operator() (ResourceDatabase *db)
bool | discardOriginalNormals () const
Discards the original normals.
void | setDiscardOriginalNormals (bool on)
Discards the original normals.
bool | computeNormals () const
Compute normals if not present.
void | setComputeNormals (bool cn)
Compute normals if not present.
bool | removeDoubles () const
Remove duplicated vertices.
void | setRemoveDoubles (bool rd)
Remove duplicated vertices.
void | setSortVertices (bool on)
Sorts the mesh's vertices for better performances.
bool | sortVertices () const
Sorts the mesh's vertices for better performances.
void | setSortTriangles (bool on)
Sorts the mesh's triangles for better performances.
bool | sortTriangles () const
Sorts the mesh's triangles for better performances.
void | setStripfy (bool on)
Convert mesh into a set of triangle strips if possible.
bool | stripfy () const
Convert mesh into a set of triangle strips if possible.
bool | convertToDrawArrays () const
Converts the Geometry Primitives into DrawArrays. Useful in conjuction with setStripfy(true).
void | setConvertToDrawArrays (bool on)
Converts the Geometry Primitives into DrawArrays. Useful in conjuction with setStripfy(true).
void | setUseDisplayLists (bool on)
Enable display lists usage (overrides VBOs).
bool | useDisplayLists () const
Enable display lists usage (overrides VBOs).
void | setUseVBOs (bool on)
Enable VBO usage if display lists are disabled.
bool | useVBOs () const
Enable VBO usage if display lists are disabled.
const mat4 & | transformMatrix () const
void | setTransformMatrix (const mat4 &m)
bool | transformGeometry () const
Transforms the Geometries using transformMatrix().
void | setTransformGeometry (bool on)
Transforms the Geometries using transformMatrix().

Protected Attributes

mat4 mMatrix
bool | mTransformGeometry
bool | mDiscardOriginalNormals
bool | mComputeNormals
bool | mRemoveDoubles
bool | mSortTriangles
bool | mSortVertices
bool | mStripfy
bool | mConvertToDrawArrays
bool | mUseDisplayLists
bool | mUseVBOs

Detailed Description

Defines a set of actions to be executed to a Geometry as soon as it is loaded.

Constructor & Destructor Documentation

vl::GeometryLoadCallback::GeometryLoadCallback ( ) [inline]

Member Function Documentation

virtual const char* vl::GeometryLoadCallback::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::GeometryLoadCallback::operator() ( ResourceDatabase * db ) [inline, virtual]

Implements vl::LoadCallback.

bool vl::GeometryLoadCallback::discardOriginalNormals ( ) const [inline]

Discards the original normals.

void vl::GeometryLoadCallback::setDiscardOriginalNormals ( bool on ) [inline]

Discards the original normals.

bool vl::GeometryLoadCallback::computeNormals ( ) const [inline]

Compute normals if not present.

void vl::GeometryLoadCallback::setComputeNormals ( bool cn ) [inline]

Compute normals if not present.

bool vl::GeometryLoadCallback::removeDoubles ( ) const [inline]

Remove duplicated vertices.

void vl::GeometryLoadCallback::setRemoveDoubles ( bool rd ) [inline]

Remove duplicated vertices.

void vl::GeometryLoadCallback::setSortVertices ( bool on ) [inline]

Sorts the mesh's vertices for better performances.

bool vl::GeometryLoadCallback::sortVertices ( ) const [inline]

Sorts the mesh's vertices for better performances.

void vl::GeometryLoadCallback::setSortTriangles ( bool on ) [inline]

Sorts the mesh's triangles for better performances.

bool vl::GeometryLoadCallback::sortTriangles ( ) const [inline]

Sorts the mesh's triangles for better performances.

void vl::GeometryLoadCallback::setStripfy ( bool on ) [inline]

Convert mesh into a set of triangle strips if possible.

bool vl::GeometryLoadCallback::stripfy ( ) const [inline]

Convert mesh into a set of triangle strips if possible.

bool vl::GeometryLoadCallback::convertToDrawArrays ( ) const [inline]

Converts the Geometry Primitives into DrawArrays. Useful in conjuction with setStripfy(true).

void vl::GeometryLoadCallback::setConvertToDrawArrays ( bool on ) [inline]

Converts the Geometry Primitives into DrawArrays. Useful in conjuction with setStripfy(true).

void vl::GeometryLoadCallback::setUseDisplayLists ( bool on ) [inline]

Enable display lists usage (overrides VBOs).

bool vl::GeometryLoadCallback::useDisplayLists ( ) const [inline]

Enable display lists usage (overrides VBOs).

void vl::GeometryLoadCallback::setUseVBOs ( bool on ) [inline]

Enable VBO usage if display lists are disabled.

bool vl::GeometryLoadCallback::useVBOs ( ) const [inline]

Enable VBO usage if display lists are disabled.

const mat4& vl::GeometryLoadCallback::transformMatrix ( ) const [inline]

void vl::GeometryLoadCallback::setTransformMatrix ( const mat4 & m ) [inline]

bool vl::GeometryLoadCallback::transformGeometry ( ) const [inline]

Transforms the Geometries using transformMatrix().

void vl::GeometryLoadCallback::setTransformGeometry ( bool on ) [inline]

Transforms the Geometries using transformMatrix().

Member Data Documentation

mat4 vl::GeometryLoadCallback::mMatrix [protected]

bool vl::GeometryLoadCallback::mTransformGeometry [protected]

bool vl::GeometryLoadCallback::mDiscardOriginalNormals [protected]

bool vl::GeometryLoadCallback::mComputeNormals [protected]

bool vl::GeometryLoadCallback::mRemoveDoubles [protected]

bool vl::GeometryLoadCallback::mSortTriangles [protected]

bool vl::GeometryLoadCallback::mSortVertices [protected]

bool vl::GeometryLoadCallback::mStripfy [protected]

bool vl::GeometryLoadCallback::mConvertToDrawArrays [protected]

bool vl::GeometryLoadCallback::mUseDisplayLists [protected]

bool vl::GeometryLoadCallback::mUseVBOs [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GeometryLoadCallback.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::GhostCameraManipulator Class Reference

vl::GhostCameraManipulator

vl::GhostCameraManipulator Class Reference

The GhostCameraManipulator class is an UIEventListener that controls the position and orientation of a Camera. More...

#include <GhostCameraManipulator.hpp>

Inheritance diagram for vl::GhostCameraManipulator:

vl::UIEventListener vl::Object

List of all members.

Public Member Functions

GhostCameraManipulator ()
virtual const char * | className ()
Returns the name of the class.
virtual void | mouseMoveEvent (int x, int y)
virtual void | runEvent ()
void | setCamera (Camera *camera)
Camera * camera ()
const Camera * | camera () const
void | setKeysForward (EKey key, EKey modifier=Key_None)
void | setKeysBackward (EKey key, EKey modifier=Key_None)
void | setKeysLeft (EKey key, EKey modifier=Key_None)
void | setKeysRight (EKey key, EKey modifier=Key_None)
void | setKeysUp (EKey key, EKey modifier=Key_None)
void | setKeysDown (EKey key, EKey modifier=Key_None)
void | prepareToReconnect ()
Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.
void | setPosition (vec3 position)
const vec3 & | position () const
void | setXDegrees (Real degree)
Real xDegrees ()
void | setYDegrees (Real degree)
Real yDegrees ()
Real | rotationSpeed () const
Real | movementSpeed () const
void | setRotationSpeed (Real speed)
void | setMovementSpeed (Real speed)

Protected Attributes

ref< Camera > mCamera
vec3 mPosition
Real mLastTime
Real mRotationSpeed
Real mMovementSpeed
Real mXDegrees
Real mYDegrees
EKey | mKeysForward [2]
EKey | mKeysBackward [2]
EKey | mKeysUp [2]
EKey | mKeysDown [2]
EKey | mKeysLeft [2]
EKey | mKeysRight [2]

Detailed Description

The GhostCameraManipulator class is an UIEventListener that controls the position and orientation of a Camera.

Using the GhostCameraManipulator class the user can freely fly around in the scene just like a ghost would do.

Constructor & Destructor Documentation

GhostCameraManipulator::GhostCameraManipulator ( )

Member Function Documentation

virtual const char* vl::GhostCameraManipulator::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::UIEventListener.

void GhostCameraManipulator::mouseMoveEvent | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

void GhostCameraManipulator::runEvent ( ) [virtual]

Reimplemented from vl::UIEventListener.

void GhostCameraManipulator::setCamera ( Camera * camera )

Camera * GhostCameraManipulator::camera ( )

const Camera * GhostCameraManipulator::camera ( ) const

void vl::GhostCameraManipulator::setKeysForward | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void vl::GhostCameraManipulator::setKeysBackward | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void vl::GhostCameraManipulator::setKeysLeft | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void vl::GhostCameraManipulator::setKeysRight | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void vl::GhostCameraManipulator::setKeysUp | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void vl::GhostCameraManipulator::setKeysDown | ( | EKey | key,
 |  | EKey | modifier = Key_None |
 | ) |  |  | [inline]

void GhostCameraManipulator::prepareToReconnect ( ) [virtual]

Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.

Reimplemented from vl::UIEventListener.

void vl::GhostCameraManipulator::setPosition ( vec3 position ) [inline]

const vec3& vl::GhostCameraManipulator::position ( ) const [inline]

void vl::GhostCameraManipulator::setXDegrees ( Real degree ) [inline]

Real vl::GhostCameraManipulator::xDegrees ( ) [inline]

void vl::GhostCameraManipulator::setYDegrees ( Real degree ) [inline]

Real vl::GhostCameraManipulator::yDegrees ( ) [inline]

Real vl::GhostCameraManipulator::rotationSpeed ( ) const [inline]

Real vl::GhostCameraManipulator::movementSpeed ( ) const [inline]

void vl::GhostCameraManipulator::setRotationSpeed ( Real speed ) [inline]

void vl::GhostCameraManipulator::setMovementSpeed ( Real speed ) [inline]

Member Data Documentation

ref<Camera> vl::GhostCameraManipulator::mCamera [protected]

vec3 vl::GhostCameraManipulator::mPosition [protected]

Real vl::GhostCameraManipulator::mLastTime [protected]

Real vl::GhostCameraManipulator::mRotationSpeed [protected]

Real vl::GhostCameraManipulator::mMovementSpeed [protected]

Real vl::GhostCameraManipulator::mXDegrees [protected]

Real vl::GhostCameraManipulator::mYDegrees [protected]

EKey vl::GhostCameraManipulator::mKeysForward[2] [protected]

EKey vl::GhostCameraManipulator::mKeysBackward[2] [protected]

EKey vl::GhostCameraManipulator::mKeysUp[2] [protected]

EKey vl::GhostCameraManipulator::mKeysDown[2] [protected]

EKey vl::GhostCameraManipulator::mKeysLeft[2] [protected]

EKey vl::GhostCameraManipulator::mKeysRight[2] [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLBufferObject Class Reference

vl::GLBufferObject

vl::GLBufferObject Class Reference

The GLBufferObject class is a Buffer that can upload its data on the GPU memory. More...

#include <GLBufferObject.hpp>

Inheritance diagram for vl::GLBufferObject:

vl::Buffer vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
GLBufferObject ()
GLBufferObject (const GLBufferObject &other)
GLBufferObject & | operator= (const GLBufferObject &other)
void | swap (GLBufferObject &other)
~GLBufferObject ()
unsigned int | handle () const
int | byteCountGPU () const
void | createGLBufferObject ()
void | deleteGLBufferObject ()
void | downloadGLBufferObject ()
void | setBufferData (EGLBufferUsage usage, bool discard_local_storage=false)
void | setBufferSubData (GLintptr offset=0, int byte_count=-1, bool discard_local_storage=false)
void | setBufferData (int byte_count, const GLvoid *data, EGLBufferUsage usage)
void | setBufferSubData (GLintptr offset, int byte_count, const GLvoid *data)
void * | mapGPUBuffer (EGLBufferAccess access)
bool | unmapGPUBuffer ()
EGLBufferUsage | usage () const

Protected Attributes

unsigned int | mHandle
int | mByteCountGPU
EGLBufferUsage mUsage

Detailed Description

The GLBufferObject class is a Buffer that can upload its data on the GPU memory.

Remarks:
GLBufferObject is the storage used by ArrayAbstract and subclasses like ArrayFVec3, ArrayUByte4 etc.

Constructor & Destructor Documentation

vl::GLBufferObject::GLBufferObject ( ) [inline]

vl::GLBufferObject::GLBufferObject ( const GLBufferObject & other ) [inline]

vl::GLBufferObject::~GLBufferObject ( ) [inline]

Member Function Documentation

virtual const char* vl::GLBufferObject::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Buffer.

GLBufferObject& vl::GLBufferObject::operator= ( const GLBufferObject & other ) [inline]

void vl::GLBufferObject::swap ( GLBufferObject & other ) [inline]

unsigned int vl::GLBufferObject::handle ( ) const [inline]

int vl::GLBufferObject::byteCountGPU ( ) const [inline]

void vl::GLBufferObject::createGLBufferObject ( ) [inline]

void vl::GLBufferObject::deleteGLBufferObject ( ) [inline]

void vl::GLBufferObject::downloadGLBufferObject ( ) [inline]

void vl::GLBufferObject::setBufferData | ( | EGLBufferUsage | usage,
 |  | bool | discard_local_storage = false |
 | ) |  |  | [inline]

void vl::GLBufferObject::setBufferSubData | ( | GLintptr | offset = 0,
 |  | int | byte_count = -1,
 |  | bool | discard_local_storage = false |
 | ) |  |  | [inline]

void vl::GLBufferObject::setBufferData | ( | int | byte_count,
 |  | const GLvoid * | data,
 |  | EGLBufferUsage | usage |
 | ) |  |  | [inline]

void vl::GLBufferObject::setBufferSubData | ( | GLintptr | offset,
 |  | int | byte_count,
 |  | const GLvoid * | data |
 | ) |  |  | [inline]

void* vl::GLBufferObject::mapGPUBuffer ( EGLBufferAccess access ) [inline]

bool vl::GLBufferObject::unmapGPUBuffer ( ) [inline]

EGLBufferUsage vl::GLBufferObject::usage ( ) const [inline]

Member Data Documentation

unsigned int vl::GLBufferObject::mHandle [protected]

int vl::GLBufferObject::mByteCountGPU [protected]

EGLBufferUsage vl::GLBufferObject::mUsage [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLBufferObject.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLSLFragmentShader Class Reference

vl::GLSLFragmentShader

vl::GLSLFragmentShader Class Reference

Wraps a GLSL fragment shader to be bound to a GLSL program. More...

#include <GLSL.hpp>

Inheritance diagram for vl::GLSLFragmentShader:

vl::GLSLShader vl::Object

List of all members.

Public Member Functions

GLSLFragmentShader (const String &source=String())
virtual const char * className ()
Returns the name of the class.

Detailed Description

Wraps a GLSL fragment shader to be bound to a GLSL program.

See also:
GLSLProgram, GLSLVertexShader, GLSLGeometryShader, Shader, Effect

Constructor & Destructor Documentation

vl::GLSLFragmentShader::GLSLFragmentShader ( const String & source = String() ) [inline]

Parameters:
source Fragment shader's source code or path to a text file containing the fragment shader's source code.

Member Function Documentation

virtual const char* vl::GLSLFragmentShader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::GLSLShader.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLSLGeometryShader Class Reference

vl::GLSLGeometryShader

vl::GLSLGeometryShader Class Reference

Wraps a GLSL geometry shader to be bound to a GLSL program. More...

#include <GLSL.hpp>

Inheritance diagram for vl::GLSLGeometryShader:

vl::GLSLShader vl::Object

List of all members.

Public Member Functions

GLSLGeometryShader (const String &source=String())
virtual const char * className ()
Returns the name of the class.

Detailed Description

Wraps a GLSL geometry shader to be bound to a GLSL program.

See also:
GLSLProgram, GLSLFragmentShader, GLSLVertexShader, Shader, Effect

Constructor & Destructor Documentation

vl::GLSLGeometryShader::GLSLGeometryShader ( const String & source = String() ) [inline]

Parameters:
source Geometry shader's source code or path to a text file containing the geometry shader's source code.

Member Function Documentation

virtual const char* vl::GLSLGeometryShader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::GLSLShader.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLSLProgram Class Reference

vl::GLSLProgram

vl::GLSLProgram Class Reference

Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders. More...

#include <GLSL.hpp>

Inheritance diagram for vl::GLSLProgram:

vl::RenderState vl::Object

List of all members.

Public Member Functions

GLSLProgram ()
Constructor.
~GLSLProgram ()
Destructor. Calls deleteProgram().
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
void | createProgram ()
Calls glCreateProgram() in order to acquire a GLSL program handle, see also http://www.opengl.org/sdk/docs/man/xhtml/glCreateProgram.xml for more information.
void | deleteProgram ()
Deletes the GLSL program calling glDeleteProgram(handle()), see also http://www.opengl.org/sdk/docs/man/xhtml/glDeleteProgram.xml for more information.
unsigned int | handle () const
The handle of the GLSL program as returned by glCreateProgram().
bool | useProgram () const
Equivalent to glUseProgram(handle()), see also http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml for more information.
void | apply (const Camera *) const
Calls useProgram().
virtual void | initResources ()
Calls linkProgram() and applyes this program's uniforms.
bool | linkProgram (bool force_relink=false)
Links the GLSLProgram calling glLinkProgram(handle()) only if the program needs to be linked.
bool | linkStatus () const
bool | linked () const
Returns true if the program has been succesfully linked.
void | scheduleRelinking ()
Schedules a relink of the GLSL program.
bool | attachShader (GLSLShader *shader)
Attaches the GLSLShader to this GLSLProgram.
bool | detachShader (GLSLShader *shader)
Removes a GLSLShader from the GLSLShader and schedules a relink of the program, see also http://www.opengl.org/sdk/docs/man/xhtml/glDetachShader.xml for more information.
String | infoLog () const
Returns the info log of this GLSL program using the OpenGL function glGetProgramInfoLog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glGetProgramInfoLog.xml for more information.
bool | validateProgram () const
Returns true if the validation of this GLSL program is succesful, see also http://www.opengl.org/sdk/docs/man/xhtml/glValidateProgram.xml for more information.
void | bindAttribLocation (unsigned int index, const std::string &name)
Equivalent to glBindAttribLocation(handle(), index, name.c_str()).
int | getAttribLocation (const char *name) const
Eqivalento to glGetAttribLocation(handle(), name).
int | shaderCount () const
Returns the number of GLSLShader objects bound to this GLSLProgram.
const GLSLShader * | shader (int i) const
Returns the i-th GLSLShader objects bound to this GLSLProgram.
GLSLShader * | shader (int i)
Returns the i-th GLSLShader objects bound to this GLSLProgram.
void | detachAllShaders ()
Removes all the previously linked shaders and schedules a relinking.
void | bindFragDataLocation (int color_number, const std::string &name)
void | unbindFragDataLocation (const std::string &name)
int | fragDataLocationBinding (const std::string &name) const
void | setGeometryVerticesOut (int vertex_count)
See GL_ARB_geometry_shader4's GL_GEOMETRY_VERTICES_OUT_EXT.
int | geometryVerticesOut () const
See GL_ARB_geometry_shader4's GL_GEOMETRY_VERTICES_OUT_EXT.
void | setGeometryInputType (EGeometryInputType type)
See GL_ARB_geometry_shader4's GL_GEOMETRY_INPUT_TYPE_EXT.
EGeometryInputType | geometryInputType () const
See GL_ARB_geometry_shader4's GL_GEOMETRY_INPUT_TYPE_EXT.
void | setGeometryOutputType (EGeometryOutputType type)
See GL_ARB_geometry_shader4's GL_GEOMETRY_OUTPUT_TYPE_EXT.
EGeometryOutputType | geometryOutputType () const
See GL_ARB_geometry_shader4's GL_GEOMETRY_OUTPUT_TYPE_EXT.
void | applyUniformSet (const UniformSet *uniforms) const
Applies a set of uniforms to the currently bound GLSL program.
int | getUniformLocation (const std::string &name) const
Returns the binding index of the uniform with the given name.
void | getUniformfv (int location, float *params) const
Equivalent to glGetUniformfv(handle(), location, params).
void | getUniformfv (const std::string &name, float *params) const
Equivalent to getUniformfv(getUniformLocation(name), params).
void | getUniformiv (int location, int *params) const
Equivalent to glGetUniformiv(handle(), location, params).
void | getUniformiv (const std::string &name, int *params) const
Equivalent to getUniformiv(getUniformLocation(name).
void | getUniform (int location, fvec2 &vec) const
void | getUniform (int location, fvec3 &vec) const
void | getUniform (int location, fvec4 &vec) const
void | getUniform (int location, fmat2 &mat) const
void | getUniform (int location, fmat3 &mat) const
void | getUniform (int location, fmat4 &mat) const
void | getUniform (int location, ivec2 &vec) const
void | getUniform (int location, ivec3 &vec) const
void | getUniform (int location, ivec4 &vec) const
void | getUniform (const std::string &name, fvec2 &vec) const
void | getUniform (const std::string &name, fvec3 &vec) const
void | getUniform (const std::string &name, fvec4 &vec) const
void | getUniform (const std::string &name, fmat2 &mat) const
void | getUniform (const std::string &name, fmat3 &mat) const
void | getUniform (const std::string &name, fmat4 &mat) const
void | getUniform (const std::string &name, ivec2 &vec) const
void | getUniform (const std::string &name, ivec3 &vec) const
void | getUniform (const std::string &name, ivec4 &vec) const
UniformSet * uniformSet ()
Returns a GLSLProgram's 'static' UniformSet.
const UniformSet * | uniformSet () const
Returns a GLSLProgram's 'static' UniformSet.
void | setUniformSet (UniformSet *uniforms)
Sets a GLSLProgram's 'static' UniformSet.
void | setUniform (Uniform *uniform)
Sets a GLSLProgram's 'static' Uniform.
Uniform * | getUniform (const std::string &name)
Returns the specified Uniform. Returns NULL if there isn't such a Uniform.
Uniform * | gocUniform (const std::string &name)
Gets or creates the specified Uniform.

Static Public Member Functions

static int | maxVertexAttributes ()
Equivalent to glGetIntegerv( GL_MAX_VERTEX_ATTRIBS, &max ).

Protected Attributes

std::vector< ref< GLSLShader > > | mShaders
std::map< std::string, int > | mFragDataLocation
std::map< std::string, int > | mUniformLocation
ref< UniformSet > mUniformSet
unsigned int | mHandle
bool | mScheduleLink
int | mGeometryVerticesOut
EGeometryInputType mGeometryInputType
EGeometryOutputType mGeometryOutputType

Friends

class | Renderer

Detailed Description

Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders.

Uniforms
You have 3 ways to set the value of a uniform:
  1. call useProgram() to activate the GLSLProgram and directly call glUniform* (see also getUniformLocation()).
  2. add a Uniform to the Actor's UniformSet, see Actor::uniformSet()
  3. add a Uniform to the Actor's Shader UniformSet, see Shader::uniformSet()
Remarks:
The Uniforms defined in the Actor and the ones defined in the Shader must not overlap, that is, an Actor must not define Uniforms present in the Shader and vice versa.
See also:
  • GLSLVertexShader
  • GLSLFragmentShader
  • GLSLGeometryShader
  • Shader
  • Effect
  • Actor::renderingCallbacks()

Constructor & Destructor Documentation

GLSLProgram::GLSLProgram ( )

Constructor.

GLSLProgram::~GLSLProgram ( )

Destructor. Calls deleteProgram().

Member Function Documentation

virtual const char* vl::GLSLProgram::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::GLSLProgram::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void GLSLProgram::createProgram ( )

Calls glCreateProgram() in order to acquire a GLSL program handle, see also http://www.opengl.org/sdk/docs/man/xhtml/glCreateProgram.xml for more information.

Note:
The program is created only if handle() == 0

void GLSLProgram::deleteProgram ( )

Deletes the GLSL program calling glDeleteProgram(handle()), see also http://www.opengl.org/sdk/docs/man/xhtml/glDeleteProgram.xml for more information.

After this function handle() will return 0.

unsigned int vl::GLSLProgram::handle ( ) const [inline]

The handle of the GLSL program as returned by glCreateProgram().

See also:
http://www.opengl.org/sdk/docs/man/xhtml/glCreateProgram.xml
  • createProgram()
  • deleteProgram()

bool GLSLProgram::useProgram ( ) const

Equivalent to glUseProgram(handle()), see also http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml for more information.

void GLSLProgram::apply ( const Camera * ) const [virtual]

Calls useProgram().

Implements vl::RenderState.

void GLSLProgram::initResources ( ) [virtual]

Calls linkProgram() and applyes this program's uniforms.

See also:
setUniform() setUniformSet() uniformSet()

Reimplemented from vl::RenderState.

bool GLSLProgram::linkProgram ( bool force_relink = false )

Links the GLSLProgram calling glLinkProgram(handle()) only if the program needs to be linked.

See also:
  • http://www.opengl.org/sdk/docs/man/xhtml/glLinkProgram.xml
  • scheduleRelinking()
  • linked()

bool GLSLProgram::linkStatus ( ) const

bool vl::GLSLProgram::linked ( ) const [inline]

Returns true if the program has been succesfully linked.

void GLSLProgram::scheduleRelinking ( )

Schedules a relink of the GLSL program.

bool GLSLProgram::attachShader ( GLSLShader * shader )

Attaches the GLSLShader to this GLSLProgram.

Note:
Attaching a shader triggers the compilation of the shader (if not already compiled) and relinking of the program.

bool GLSLProgram::detachShader ( GLSLShader * shader )

Removes a GLSLShader from the GLSLShader and schedules a relink of the program, see also http://www.opengl.org/sdk/docs/man/xhtml/glDetachShader.xml for more information.

String GLSLProgram::infoLog ( ) const

Returns the info log of this GLSL program using the OpenGL function glGetProgramInfoLog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glGetProgramInfoLog.xml for more information.

bool GLSLProgram::validateProgram ( ) const

Returns true if the validation of this GLSL program is succesful, see also http://www.opengl.org/sdk/docs/man/xhtml/glValidateProgram.xml for more information.

void GLSLProgram::bindAttribLocation | ( | unsigned int | index,
 |  | const std::string & | name
 | ) |  |

Equivalent to glBindAttribLocation(handle(), index, name.c_str()).

int vl::GLSLProgram::getAttribLocation ( const char * name ) const [inline]

Eqivalento to glGetAttribLocation(handle(), name).

Note:
The program must be linked before calling this function.

int GLSLProgram::maxVertexAttributes ( ) [static]

Equivalent to glGetIntegerv( GL_MAX_VERTEX_ATTRIBS, &max ).

int vl::GLSLProgram::shaderCount ( ) const [inline]

Returns the number of GLSLShader objects bound to this GLSLProgram.

const GLSLShader* vl::GLSLProgram::shader ( int i ) const [inline]

Returns the i-th GLSLShader objects bound to this GLSLProgram.

GLSLShader* vl::GLSLProgram::shader ( int i ) [inline]

Returns the i-th GLSLShader objects bound to this GLSLProgram.

void GLSLProgram::detachAllShaders ( )

Removes all the previously linked shaders and schedules a relinking.

void GLSLProgram::bindFragDataLocation | ( | int | color_number,
 |  | const std::string & | name
 | ) |  |

void GLSLProgram::unbindFragDataLocation ( const std::string & name )

int GLSLProgram::fragDataLocationBinding ( const std::string & name ) const

void vl::GLSLProgram::setGeometryVerticesOut ( int vertex_count ) [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_VERTICES_OUT_EXT.

int vl::GLSLProgram::geometryVerticesOut ( ) const [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_VERTICES_OUT_EXT.

void vl::GLSLProgram::setGeometryInputType ( EGeometryInputType type ) [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_INPUT_TYPE_EXT.

EGeometryInputType vl::GLSLProgram::geometryInputType ( ) const [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_INPUT_TYPE_EXT.

void vl::GLSLProgram::setGeometryOutputType ( EGeometryOutputType type ) [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_OUTPUT_TYPE_EXT.

EGeometryOutputType vl::GLSLProgram::geometryOutputType ( ) const [inline]

See GL_ARB_geometry_shader4's GL_GEOMETRY_OUTPUT_TYPE_EXT.

void GLSLProgram::applyUniformSet ( const UniformSet * uniforms ) const

Applies a set of uniforms to the currently bound GLSL program.

This function expects the GLSLProgram to be already bound, see useProgram().

int vl::GLSLProgram::getUniformLocation ( const std::string & name ) const [inline]

Returns the binding index of the uniform with the given name.

void vl::GLSLProgram::getUniformfv | ( | int | location,
 |  | float * | params |
 | ) |  |  | const [inline]

Equivalent to glGetUniformfv(handle(), location, params).

void vl::GLSLProgram::getUniformfv | ( | const std::string & | name,
 |  | float * | params |
 | ) |  |  | const [inline]

Equivalent to getUniformfv(getUniformLocation(name), params).

void vl::GLSLProgram::getUniformiv | ( | int | location,
 |  | int * | params |
 | ) |  |  | const [inline]

Equivalent to glGetUniformiv(handle(), location, params).

void vl::GLSLProgram::getUniformiv | ( | const std::string & | name,
 |  | int * | params |
 | ) |  |  | const [inline]

Equivalent to getUniformiv(getUniformLocation(name).

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fvec2 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fvec3 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fvec4 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fmat2 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fmat3 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | fmat4 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | ivec2 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | ivec3 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | int | location,
 |  | ivec4 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fvec2 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fvec3 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fvec4 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fmat2 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fmat3 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | fmat4 & | mat |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | ivec2 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | ivec3 & | vec |
 | ) |  |  | const [inline]

void vl::GLSLProgram::getUniform | ( | const std::string & | name,
 |  | ivec4 & | vec |
 | ) |  |  | const [inline]

UniformSet* vl::GLSLProgram::uniformSet ( ) [inline]

Returns a GLSLProgram's 'static' UniformSet.

See also:
See setUniform() for more information about 'static' Uniforms and Uniform management.

const UniformSet* vl::GLSLProgram::uniformSet ( ) const [inline]

Returns a GLSLProgram's 'static' UniformSet.

See also:
See setUniform() for more information about 'static' Uniforms and Uniform management.

void vl::GLSLProgram::setUniformSet ( UniformSet * uniforms ) [inline]

Sets a GLSLProgram's 'static' UniformSet.

See also:
See setUniform() for more information about 'static' Uniforms and Uniform management.

void vl::GLSLProgram::setUniform ( Uniform * uniform ) [inline]

Sets a GLSLProgram's 'static' Uniform.

This is an utility function, it is equivalent to:

 if (!uniformSet()) setUniformSet(new UniformSet); uniformSet()->setUniform(uniform);

Uniform* vl::GLSLProgram::getUniform ( const std::string & name ) [inline]

Returns the specified Uniform. Returns NULL if there isn't such a Uniform.

Uniform* vl::GLSLProgram::gocUniform ( const std::string & name ) [inline]

Gets or creates the specified Uniform.

Friends And Related Function Documentation

friend class Renderer [friend]

Member Data Documentation

std::vector< ref<GLSLShader> > vl::GLSLProgram::mShaders [protected]

std::map<std::string, int> vl::GLSLProgram::mFragDataLocation [protected]

std::map<std::string, int> vl::GLSLProgram::mUniformLocation [protected]

ref<UniformSet> vl::GLSLProgram::mUniformSet [protected]

unsigned int vl::GLSLProgram::mHandle [protected]

bool vl::GLSLProgram::mScheduleLink [protected]

int vl::GLSLProgram::mGeometryVerticesOut [protected]

EGeometryInputType vl::GLSLProgram::mGeometryInputType [protected]

EGeometryOutputType vl::GLSLProgram::mGeometryOutputType [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLSLShader Class Reference

vl::GLSLShader

vl::GLSLShader Class Reference

Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader. More...

#include <GLSL.hpp>

Inheritance diagram for vl::GLSLShader:

vl::Object vl::GLSLFragmentShader vl::GLSLGeometryShader vl::GLSLVertexShader

List of all members.

Public Member Functions

GLSLShader (EShaderType type, const String &source=String())
~GLSLShader ()
virtual const char * | className ()
Returns the name of the class.
EShaderType | type () const
void | setSource (const std::string &source)
Sets the sources for this shader and schedules a recompilation for it.
void | setSource (const String &source)
Sets the sources for this shader and schedules a recompilation for it.
const std::string & | source () const
Returns the sources for this shader.
bool | compile ()
Compiles the shader, see also http://www.opengl.org/sdk/docs/man/xhtml/glCompileShader.xml for more information.
bool | compileStatus () const
Returns true if the shader has been succesfully compiled.
String | infoLog () const
Returns a String object containing this shader's info log as returned by glGetShaderInfoLog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glGetShaderInfoLog.xml for more information.
void | createShader ()
Creates the shader using the OpenGL function glCreateShader(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCreateShader.xml for more information.
void | deleteShader ()
Deletes the shader using the OpenGL function glDeleteShader(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDeleteShader.xml for more information.
unsigned int | handle () const
The handle of this OpenGL shader object as returned by glCreateShader().

Protected Attributes

EShaderType mType
std::string | mSource
unsigned int | mHandle
bool | mCompiled

Detailed Description

Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader.

See also:
GLSLProgram, Shader, Effect, Actor

Constructor & Destructor Documentation

GLSLShader::GLSLShader | ( | EShaderType | type,
 |  | const String & | source = String()
 | ) |  |

GLSLShader::~GLSLShader ( )

Member Function Documentation

virtual const char* vl::GLSLShader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::GLSLVertexShader, vl::GLSLFragmentShader, and vl::GLSLGeometryShader.

EShaderType vl::GLSLShader::type ( ) const [inline]

void GLSLShader::setSource ( const std::string & source )

Sets the sources for this shader and schedules a recompilation for it.

void GLSLShader::setSource ( const String & source )

Sets the sources for this shader and schedules a recompilation for it.

const std::string& vl::GLSLShader::source ( ) const [inline]

Returns the sources for this shader.

bool GLSLShader::compile ( )

Compiles the shader, see also http://www.opengl.org/sdk/docs/man/xhtml/glCompileShader.xml for more information.

This function also create the shader if handle() == 0 using the OpenGL function glCreateShader(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCreateShader.xml

bool GLSLShader::compileStatus ( ) const

Returns true if the shader has been succesfully compiled.

The check is done using the OpenGL function glGetShaderiv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glGetShader.xml for more information.

String GLSLShader::infoLog ( ) const

Returns a String object containing this shader's info log as returned by glGetShaderInfoLog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glGetShaderInfoLog.xml for more information.

void GLSLShader::createShader ( )

Creates the shader using the OpenGL function glCreateShader(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCreateShader.xml for more information.

void GLSLShader::deleteShader ( )

Deletes the shader using the OpenGL function glDeleteShader(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDeleteShader.xml for more information.

unsigned int vl::GLSLShader::handle ( ) const [inline]

The handle of this OpenGL shader object as returned by glCreateShader().

Member Data Documentation

EShaderType vl::GLSLShader::mType [protected]

std::string vl::GLSLShader::mSource [protected]

unsigned int vl::GLSLShader::mHandle [protected]

bool vl::GLSLShader::mCompiled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::GLSLVertexShader Class Reference

vl::GLSLVertexShader

vl::GLSLVertexShader Class Reference

Wraps a GLSL vertex shader to be bound to a GLSL program. More...

#include <GLSL.hpp>

Inheritance diagram for vl::GLSLVertexShader:

vl::GLSLShader vl::Object

List of all members.

Public Member Functions

GLSLVertexShader (const String &source=String())
Constructor.
virtual const char * className ()
Returns the name of the class.

Detailed Description

Wraps a GLSL vertex shader to be bound to a GLSL program.

See also:
GLSLProgram, GLSLFragmentShader, GLSLGeometryShader, Shader, Effect

Constructor & Destructor Documentation

vl::GLSLVertexShader::GLSLVertexShader ( const String & source = String() ) [inline]

Constructor.

Parameters:
source Vertex shader's source code or path to a text file containing the vertex shader's source code.

Member Function Documentation

virtual const char* vl::GLSLVertexShader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::GLSLShader.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::Glyph Class Reference

vl::Glyph

vl::Glyph Class Reference

The Glyph associated to a character of a given Font. More...

#include <Font.hpp>

Inheritance diagram for vl::Glyph:

vl::Object

List of all members.

Public Member Functions

Glyph ()
~Glyph ()
virtual const char * | className ()
Returns the name of the class.
unsigned int | textureHandle () const
void | setTextureHandle (unsigned int handle)
int | width () const
void | setWidth (int width)
int | height () const
void | setHeight (int height)
int | left () const
void | setLeft (int left)
int | top () const
void | setTop (int top)
float | s0 () const
void | setS0 (float s0)
float | t0 () const
void | setT0 (float t0)
float | s1 () const
void | setS1 (float s1)
float | t1 () const
void | setT1 (float t1)
const fvec2 & | advance () const
void | setAdvance (const fvec2 &advance)
unsigned int | glyphIndex () const
void | setGlyphIndex (unsigned int glyph_index)
const Font * | font () const
void | setFont (Font *font)

Protected Attributes

unsigned int | mTextureHandle
int | mWidth
int | mHeight
int | mLeft
int | mTop
float | mS0
float | mT0
float | mS1
float | mT1
fvec2 mAdvance
unsigned int | mGlyphIndex
Font * mFont

Detailed Description

The Glyph associated to a character of a given Font.

Constructor & Destructor Documentation

vl::Glyph::Glyph ( ) [inline]

vl::Glyph::~Glyph ( )

Member Function Documentation

virtual const char* vl::Glyph::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

unsigned int vl::Glyph::textureHandle ( ) const [inline]

void vl::Glyph::setTextureHandle ( unsigned int handle ) [inline]

int vl::Glyph::width ( ) const [inline]

void vl::Glyph::setWidth ( int width ) [inline]

int vl::Glyph::height ( ) const [inline]

void vl::Glyph::setHeight ( int height ) [inline]

int vl::Glyph::left ( ) const [inline]

void vl::Glyph::setLeft ( int left ) [inline]

int vl::Glyph::top ( ) const [inline]

void vl::Glyph::setTop ( int top ) [inline]

float vl::Glyph::s0 ( ) const [inline]

void vl::Glyph::setS0 ( float s0 ) [inline]

float vl::Glyph::t0 ( ) const [inline]

void vl::Glyph::setT0 ( float t0 ) [inline]

float vl::Glyph::s1 ( ) const [inline]

void vl::Glyph::setS1 ( float s1 ) [inline]

float vl::Glyph::t1 ( ) const [inline]

void vl::Glyph::setT1 ( float t1 ) [inline]

const fvec2& vl::Glyph::advance ( ) const [inline]

void vl::Glyph::setAdvance ( const fvec2 & advance ) [inline]

unsigned int vl::Glyph::glyphIndex ( ) const [inline]

void vl::Glyph::setGlyphIndex ( unsigned int glyph_index ) [inline]

const Font* vl::Glyph::font ( ) const [inline]

void vl::Glyph::setFont ( Font * font ) [inline]

Member Data Documentation

unsigned int vl::Glyph::mTextureHandle [protected]

int vl::Glyph::mWidth [protected]

int vl::Glyph::mHeight [protected]

int vl::Glyph::mLeft [protected]

int vl::Glyph::mTop [protected]

float vl::Glyph::mS0 [protected]

float vl::Glyph::mT0 [protected]

float vl::Glyph::mS1 [protected]

float vl::Glyph::mT1 [protected]

fvec2 vl::Glyph::mAdvance [protected]

unsigned int vl::Glyph::mGlyphIndex [protected]

Font* vl::Glyph::mFont [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::GZipCodec Class Reference

vl::GZipCodec

vl::GZipCodec Class Reference

The GZipCodec class is a VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm. More...

#include <GZipCodec.hpp>

Inheritance diagram for vl::GZipCodec:

vl::VirtualFile vl::Object

List of all members.

Public Member Functions

GZipCodec (VirtualFile *stream=NULL)
Constructor.
GZipCodec (const String &gz_path)
Constructor.
~GZipCodec ()
Destructor.
virtual const char * | className ()
Returns the name of the class.
virtual bool | open (EOpenMode mode)
Opens a compressed stream.
virtual bool | isOpen () const
Returns true if the file is open for read or writing.
virtual bool | exists () const
Returns true if the input or output stream file exists.
virtual void | close ()
Closes the GZipStream.
virtual long long | size () const
Returns the uncompressed size of the stream. This is not a thread safe function.
virtual ref< VirtualFile > | clone () const
Returns an equivalent GZipCodec.
GZipCodec & | operator= (const GZipCodec &other)
void | setCompressionLevel (int level)
Sets the compression level used during write operations.
int | compressionLevel () const
void | setStream (VirtualFile *stream)
Installs the VirtualFile representing the GZip file to be read or to be written.
const VirtualFile * | stream () const
Returns the VirtualFile representing the GZip file to be read or to be written.
VirtualFile * stream ()
Returns the VirtualFile representing the GZip file to be read or to be written.
long long | uncompressedSize ()
Returns the uncompressed size of the stream.
long long | compressedSize () const
Returns the size of the compressed stream as returned by stream()->size().
float | compressionRatio () const
Returns the compression ratio computed as compressedsize/uncompressedsize.
bool | warnOnSeek () const
void | setWarnOnSeek (bool warn_on)

Protected Types

enum | { ZNone, ZCompress, ZDecompress }

Protected Member Functions

virtual long long | read_Implementation (void *buffer, long long bytes_to_read)
virtual long long | write_Implementation (const void *buffer, long long byte_count)
virtual long long | position_Implementation () const
void | resetStream ()
bool | seekSet_Implementation (long long pos)
bool | fillUncompressedBuffer ()

Protected Attributes

int | mCompressionLevel
ref< VirtualFile > mStream
long long | mReadBytes
long long | mWrittenBytes
bool | mWarnOnSeek
z_stream_s * | mZStream
unsigned char | mZipBufferIn [CHUNK_SIZE]
unsigned char | mZipBufferOut [CHUNK_SIZE]
std::vector< char > | mUncompressedBuffer
int | mUncompressedBufferPtr
long long | mStreamSize
long long | mUncompressedSize
enum vl::GZipCodec:: { ... } | mMode

Static Protected Attributes

static const int | CHUNK_SIZE = 128*1024

Detailed Description

The GZipCodec class is a VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm.

Member Enumeration Documentation

anonymous enum [protected]

Enumerator:
ZNone
ZCompress
ZDecompress

Constructor & Destructor Documentation

GZipCodec::GZipCodec ( VirtualFile * stream = NULL )

Constructor.

GZipCodec::GZipCodec ( const String & gz_path )

Constructor.

GZipCodec::~GZipCodec ( )

Destructor.

Member Function Documentation

virtual const char* vl::GZipCodec::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualFile.

bool GZipCodec::open ( EOpenMode mode ) [virtual]

Opens a compressed stream.

  • If mode == OM_ReadOnly the stream will be decompressed during read operations.
  • If mode == OM_WriteOnly the stream will be compressed during write operations.

Implements vl::VirtualFile.

virtual bool vl::GZipCodec::isOpen ( ) const [inline, virtual]

Returns true if the file is open for read or writing.

Implements vl::VirtualFile.

virtual bool vl::GZipCodec::exists ( ) const [inline, virtual]

Returns true if the input or output stream file exists.

Implements vl::VirtualFile.

void GZipCodec::close ( ) [virtual]

Closes the GZipStream.

Implements vl::VirtualFile.

long long GZipCodec::size ( ) const [virtual]

Returns the uncompressed size of the stream. This is not a thread safe function.

Implements vl::VirtualFile.

ref< VirtualFile > GZipCodec::clone ( ) const [virtual]

Returns an equivalent GZipCodec.

Implements vl::VirtualFile.

GZipCodec & GZipCodec::operator= ( const GZipCodec & other )

void vl::GZipCodec::setCompressionLevel ( int level ) [inline]

Sets the compression level used during write operations.

Parameters:
level Values can be between 0 (faster compression) to 9 (slower but better compression).

int vl::GZipCodec::compressionLevel ( ) const [inline]

void GZipCodec::setStream ( VirtualFile * stream )

Installs the VirtualFile representing the GZip file to be read or to be written.

const VirtualFile* vl::GZipCodec::stream ( ) const [inline]

Returns the VirtualFile representing the GZip file to be read or to be written.

VirtualFile* vl::GZipCodec::stream ( ) [inline]

Returns the VirtualFile representing the GZip file to be read or to be written.

long long GZipCodec::uncompressedSize ( )

Returns the uncompressed size of the stream.

Note:
This function needs to seek to the end of the GZip stream in order to read the uncompressed file size.

long long vl::GZipCodec::compressedSize ( ) const [inline]

Returns the size of the compressed stream as returned by stream()->size().

float GZipCodec::compressionRatio ( ) const

Returns the compression ratio computed as compressedsize/uncompressedsize.

bool vl::GZipCodec::warnOnSeek ( ) const [inline]

void vl::GZipCodec::setWarnOnSeek ( bool warn_on ) [inline]

long long GZipCodec::read_Implementation | ( | void * | buffer,
 |  | long long | bytes_to_read |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

long long GZipCodec::write_Implementation | ( | const void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

long long GZipCodec::position_Implementation ( ) const [protected, virtual]

Implements vl::VirtualFile.

void GZipCodec::resetStream ( ) [protected]

bool GZipCodec::seekSet_Implementation ( long long pos ) [protected, virtual]

Implements vl::VirtualFile.

bool GZipCodec::fillUncompressedBuffer ( ) [protected]

Member Data Documentation

int vl::GZipCodec::mCompressionLevel [protected]

ref<VirtualFile> vl::GZipCodec::mStream [protected]

long long vl::GZipCodec::mReadBytes [protected]

long long vl::GZipCodec::mWrittenBytes [protected]

bool vl::GZipCodec::mWarnOnSeek [protected]

z_stream_s* vl::GZipCodec::mZStream [protected]

const int vl::GZipCodec::CHUNK_SIZE = 128*1024 [static, protected]

unsigned char vl::GZipCodec::mZipBufferIn[CHUNK_SIZE] [protected]

unsigned char vl::GZipCodec::mZipBufferOut[CHUNK_SIZE] [protected]

std::vector<char> vl::GZipCodec::mUncompressedBuffer [protected]

int vl::GZipCodec::mUncompressedBufferPtr [protected]

long long vl::GZipCodec::mStreamSize [protected]

long long vl::GZipCodec::mUncompressedSize [protected]

enum { ... } vl::GZipCodec::mMode [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::Hint Class Reference

vl::Hint

vl::Hint Class Reference

Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::Hint:

vl::RenderState vl::Object

List of all members.

Public Member Functions

Hint ()
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | setPerspectiveCorrectionHint (EHintMode mode)
void | setPolygonSmoohtHint (EHintMode mode)
void | setLineSmoothHint (EHintMode mode)
void | setPointSmoothHint (EHintMode mode)
void | setFogHint (EHintMode mode)
void | setGenerateMipmapHint (EHintMode mode)
EHintMode | perspectiveCorrectionHint () const
EHintMode | polygonSmoohtHint () const
EHintMode | lineSmoothHint () const
EHintMode | pointSmoothHint () const
EHintMode | fogHint () const
EHintMode | generateMipmapHint () const

Protected Attributes

EHintMode mPerspectiveCorrectionHint
EHintMode mPointSmoothHint
EHintMode mLineSmoothHint
EHintMode mPolygonSmoothHint
EHintMode mFogHint
EHintMode mGenerateMipmapHint

Detailed Description

Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::Hint::Hint ( ) [inline]

Member Function Documentation

virtual const char* vl::Hint::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::Hint::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void Hint::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::Hint::setPerspectiveCorrectionHint ( EHintMode mode ) [inline]

void vl::Hint::setPolygonSmoohtHint ( EHintMode mode ) [inline]

void vl::Hint::setLineSmoothHint ( EHintMode mode ) [inline]

void vl::Hint::setPointSmoothHint ( EHintMode mode ) [inline]

void vl::Hint::setFogHint ( EHintMode mode ) [inline]

void vl::Hint::setGenerateMipmapHint ( EHintMode mode ) [inline]

EHintMode vl::Hint::perspectiveCorrectionHint ( ) const [inline]

EHintMode vl::Hint::polygonSmoohtHint ( ) const [inline]

EHintMode vl::Hint::lineSmoothHint ( ) const [inline]

EHintMode vl::Hint::pointSmoothHint ( ) const [inline]

EHintMode vl::Hint::fogHint ( ) const [inline]

EHintMode vl::Hint::generateMipmapHint ( ) const [inline]

Member Data Documentation

EHintMode vl::Hint::mPerspectiveCorrectionHint [protected]

EHintMode vl::Hint::mPointSmoothHint [protected]

EHintMode vl::Hint::mLineSmoothHint [protected]

EHintMode vl::Hint::mPolygonSmoothHint [protected]

EHintMode vl::Hint::mFogHint [protected]

EHintMode vl::Hint::mGenerateMipmapHint [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Image Class Reference

vl::Image

vl::Image Class Reference

Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps. More...

#include <Image.hpp>

Inheritance diagram for vl::Image:

vl::Object

List of all members.

Public Member Functions

Image ()
Image (const String &path)
Image (int x, int y, int z, int bytealign, EImageFormat format, EImageType type)
Note that the image is not allocated.
virtual const char * | className ()
Returns the name of the class.
virtual | ~Image ()
Image & | operator= (const Image &other)
bool | isCubemap () const
bool | isValid () const
Returns true if the image has valid width/height/depth, pitch and byte alignment, type/format combination.
EImageDimension | dimension () const
void | allocate ()
void | allocate1D (int x, EImageFormat format, EImageType type)
void | allocate2D (int x, int y, int bytealign, EImageFormat format, EImageType type)
void | allocate3D (int x, int y, int z, int bytealign, EImageFormat format, EImageType type)
void | allocateCubemap (int x, int y, int bytealign, EImageFormat format, EImageType type)
void | reset (int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap)
void | clear ()
int | byteAlignment () const
Returns the byte-alignment of the row of the image.
void | setByteAlignment (int bytealign)
Modifies the byte-alignment of the rows of the image, thus changing its pitch.
int | bitsPerPixel () const
int | requiredMemory () const
Returns the number of bytes requested to store the image.
String | print () const
String | printType () const
String | printFormat () const
void | setWidth (int x)
void | setHeight (int y)
void | setDepth (int z)
void | setFormat (EImageFormat format)
void | setType (EImageType type)
KeyValues * | tags () const
void | setTags (KeyValues *tags)
void | setImageBuffer (GLBufferObject *gpu_buffer)
Sets a GLBufferObject to be used as the Image's pixels storage in local and GPU memory.
GLBufferObject * imageBuffer ()
The GLBufferObject used as the Image's pixels storage in local and GPU memory.
const GLBufferObject * | imageBuffer () const
The GLBufferObject used as the Image's pixels storage in local and GPU memory.
const unsigned char * | pixels () const
unsigned char * | pixels ()
bool | empty ()
unsigned char * | pixelsZSlice (int slice)
Returns the pixels of the specified Z slice of a 3D image.
unsigned char * | pixelsXP ()
unsigned char * | pixelsXN ()
unsigned char * | pixelsYP ()
unsigned char * | pixelsYN ()
unsigned char * | pixelsZP ()
unsigned char * | pixelsZN ()
void | setMipmaps (const std::vector< ref< Image > > &mipmaps)
const std::vector< ref< Image > > & | mipmaps () const
void | clearMipmaps ()
int | width () const
int | height () const
int | depth () const
int | pitch () const
EImageFormat | format () const
EImageType | type () const
int | alphaBits () const
Useful to know if the image format supports alpha or not.
void | readPixels (int x, int y, int width, int height, EReadDrawBuffer read_buffer, bool store_in_pixel_buffer_object)
Reads a rectangular pixel area from the specified read buffer and stores it in an Image.
void | flipVertically ()
ref< Image > | convertType (EImageType new_type) const
Converts the type() of an image.
ref< Image > | convertFormat (EImageFormat new_format) const
Converts the format() of an image.
bool | equalize ()
Equalizes the image. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.
bool | contrast (float black, float white)
Adjusts the contrast of an image. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.
bool | contrastHounsfieldAuto ()
Adjusts the contrast of an image using the window-center/window-with method used for CT images. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.
bool | contrastHounsfield (float center, float width, float intercept, float range)
Adjusts the contrast of an image using the window-center/window-with method used for CT images. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.
fvec4 | sampleLinear (double x)
Performs a sampling on a 1d image using linear filtering.
fvec4 | sampleLinear (double x, double y)
Performs a sampling on a 2d image using bilinear filtering.
fvec4 | sampleLinear (double x, double y, double z)
Performs a sampling on a 3d image using trilinear filtering.
fvec4 | sample (int x, int y=0, int z=0)
Returns the color associated to the specified pixel.
ref< Image > | subImage (int xstart, int ystart, int width, int height)
Creates a new image containing the specified rectangular pixel area taken from the source image.
void | copySubImage (Image *img_src, RectI src, ivec2 dst)
Copies the rectangular area specified by src of img_src into an Image at position dst.
void | substituteColorRGB_RGBA (unsigned int before, unsigned int after)
Substitutes the color 'before' with the new color 'after'.
void | substituteColorRGB_RGB (unsigned int before, unsigned int after)
Substitutes the color 'before' with the new color 'after'.
void | substituteColorGreenKey (unsigned int col0, unsigned int col1)

Static Public Member Functions

static int | bitsPerPixel (EImageType type, EImageFormat format)
Returns the number of bits used to represents one pixel.
static int | requiredMemory (int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap)
static int | requiredMemory1D (int x, EImageFormat format, EImageType type)
static int | requiredMemory2D (int x, int y, int bytealign, EImageFormat format, EImageType type)
static int | requiredMemory3D (int x, int y, int z, int bytealign, EImageFormat format, EImageType type)
static int | requiredMemoryCubemap (int x, int y, int bytealign, EImageFormat format, EImageType type)
static int | isCompressedFormat (EImageFormat fmt)
static ref< Image > | createCubemap (const Image *xp, const Image *xn, const Image *yp, const Image *yn, const Image *zp, const Image *zn)
static ref< Image > | makeNonUniformColorSpectrum (int width, const std::vector< fvec4 > &colors, const std::vector< float > &col_pos)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeNonUniformColorSpectrum (int width, int col_count, const fvec4 *colors, const float *col_pos)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeColorSpectrum (int width, const std::vector< fvec4 > &colors)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeColorSpectrum (int width, const fvec4 &c0, const fvec4 &c1)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeColorSpectrum (int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeColorSpectrum (int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2, const fvec4 &c3)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.
static ref< Image > | makeColorSpectrum (int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2, const fvec4 &c3, const fvec4 &c4)
Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

Protected Member Functions

void | updatePitch ()

Protected Attributes

ref< GLBufferObject > mPixels
ref< KeyValues > mTags
std::vector< ref< Image > > | mMipmaps
int | mWidth
int | mHeight
int | mDepth
int | mPitch
int | mByteAlign
EImageFormat mFormat
EImageType mType
bool | mIsCubemap

Detailed Description

Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps.

Image also supports the GL_EXT_pixel_buffer_object extension, see readPixels() and gpuBuffer().

Remarks:
The copy operator performs a deep copy of all the pixel data and thus is to be considered an expensive operation.

Constructor & Destructor Documentation

Image::Image ( )

Image::Image ( const String & path )

Image::Image | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

Note that the image is not allocated.

Image::~Image ( ) [virtual]

Member Function Documentation

virtual const char* vl::Image::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Image & Image::operator= ( const Image & other )

bool vl::Image::isCubemap ( ) const [inline]

bool Image::isValid ( ) const

Returns true if the image has valid width/height/depth, pitch and byte alignment, type/format combination.

Remarks:
In order to be valid an image must be at least 1x0x0 (1D image) or 1x1x0 (2D or cubemap image) or 1x1x1 (3D image). Sizes like Nx0xM, 0xNxM, 0xNx0, 0x0xN, 0x0x0 are not valid.
Invalid type/format combinations are for example:
  • OGL_RGB / IT_UNSIGNED_SHORT_4_4_4_4: since here the format has 3 components while the type has 4.
  • IF_COMPRESSED_RGB_S3TC_DXT1_EXT / IT_BYTE: since compressed formats require IT_COMPRESSED_TYPE.

EImageDimension Image::dimension ( ) const

void Image::allocate ( )

void Image::allocate1D | ( | int | x,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

void Image::allocate2D | ( | int | x,
 |  | int | y,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

void Image::allocate3D | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

void Image::allocateCubemap | ( | int | x,
 |  | int | y,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

void Image::reset | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type,
 |  | bool | is_cubemap
 | ) |  |

void Image::clear ( )

int Image::byteAlignment ( ) const

Returns the byte-alignment of the row of the image.

Possible return values are 1, 2, 4 and 8.

void Image::setByteAlignment ( int bytealign )

Modifies the byte-alignment of the rows of the image, thus changing its pitch.

Only values like 0, 1, 2, 4 and 8 are allowed. If 0 is passed the byte-alignment takes the value returned by "sizeof(unsigned char*)".

Remarks:
This function must be called before the allocate() function or in any case on a non allocated image otherwise it won't have any effect.

int Image::bitsPerPixel | ( | EImageType | type,
 |  | EImageFormat | format |
 | ) |  |  | [static]

Returns the number of bits used to represents one pixel.

int vl::Image::bitsPerPixel ( ) const [inline]

int Image::requiredMemory ( ) const

Returns the number of bytes requested to store the image.

Doesn't take into consideration mipmaps.

int Image::requiredMemory | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type,
 |  | bool | is_cubemap |
 | ) |  |  | [static]

static int vl::Image::requiredMemory1D | ( | int | x,
 |  | EImageFormat | format,
 |  | EImageType | type |
 | ) |  |  | [inline, static]

static int vl::Image::requiredMemory2D | ( | int | x,
 |  | int | y,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type |
 | ) |  |  | [inline, static]

static int vl::Image::requiredMemory3D | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type |
 | ) |  |  | [inline, static]

static int vl::Image::requiredMemoryCubemap | ( | int | x,
 |  | int | y,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type |
 | ) |  |  | [inline, static]

String Image::print ( ) const

String Image::printType ( ) const

String Image::printFormat ( ) const

void vl::Image::setWidth ( int x ) [inline]

void vl::Image::setHeight ( int y ) [inline]

void vl::Image::setDepth ( int z ) [inline]

void vl::Image::setFormat ( EImageFormat format ) [inline]

void vl::Image::setType ( EImageType type ) [inline]

KeyValues* vl::Image::tags ( ) const [inline]

void vl::Image::setTags ( KeyValues * tags ) [inline]

void vl::Image::setImageBuffer ( GLBufferObject * gpu_buffer ) [inline]

Sets a GLBufferObject to be used as the Image's pixels storage in local and GPU memory.

You can bind it to a GL_PIXEL_PACK_BUFFER and GL_PIXEL_UNPACK_BUFFER using glBindBuffer() to take advantage of the GL_EXT_pixel_buffer_object extension.

GLBufferObject* vl::Image::imageBuffer ( ) [inline]

The GLBufferObject used as the Image's pixels storage in local and GPU memory.

You can bind it to a GL_PIXEL_PACK_BUFFER and GL_PIXEL_UNPACK_BUFFER using glBindBuffer() to take advantage of the GL_EXT_pixel_buffer_object extension.

const GLBufferObject* vl::Image::imageBuffer ( ) const [inline]

The GLBufferObject used as the Image's pixels storage in local and GPU memory.

You can bind it to a GL_PIXEL_PACK_BUFFER and GL_PIXEL_UNPACK_BUFFER using glBindBuffer() to take advantage of the GL_EXT_pixel_buffer_object extension.

const unsigned char* vl::Image::pixels ( ) const [inline]

unsigned char* vl::Image::pixels ( ) [inline]

bool vl::Image::empty ( ) [inline]

unsigned char * Image::pixelsZSlice ( int slice )

Returns the pixels of the specified Z slice of a 3D image.

unsigned char * Image::pixelsXP ( )

unsigned char * Image::pixelsXN ( )

unsigned char * Image::pixelsYP ( )

unsigned char * Image::pixelsYN ( )

unsigned char * Image::pixelsZP ( )

unsigned char * Image::pixelsZN ( )

void vl::Image::setMipmaps ( const std::vector< ref< Image > > & mipmaps ) [inline]

const std::vector< ref<Image> >& vl::Image::mipmaps ( ) const [inline]

void vl::Image::clearMipmaps ( ) [inline]

int vl::Image::width ( ) const [inline]

int vl::Image::height ( ) const [inline]

int vl::Image::depth ( ) const [inline]

int vl::Image::pitch ( ) const [inline]

EImageFormat vl::Image::format ( ) const [inline]

EImageType vl::Image::type ( ) const [inline]

int Image::alphaBits ( ) const

Useful to know if the image format supports alpha or not.

int Image::isCompressedFormat ( EImageFormat fmt ) [static]

void Image::readPixels | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height,
 |  | EReadDrawBuffer | read_buffer,
 |  | bool | store_in_pixel_buffer_object
 | ) |  |

Reads a rectangular pixel area from the specified read buffer and stores it in an Image.

If 'store_in_pixel_buffer_object' is true the data will be copied in the GPU memory using the GL_EXT_pixel_buffer_object extension, while the local buffer will be deallocated.

Note:
The image returned by this function might seem flipped upside down.

void Image::flipVertically ( )

ref< Image > Image::createCubemap | ( | const Image * | xp,
 |  | const Image * | xn,
 |  | const Image * | yp,
 |  | const Image * | yn,
 |  | const Image * | zp,
 |  | const Image * | zn |
 | ) |  |  | [static]

static ref<Image> vl::Image::makeNonUniformColorSpectrum | ( | int | width,
 |  | const std::vector< fvec4 > & | colors,
 |  | const std::vector< float > & | col_pos |
 | ) |  |  | [inline, static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeNonUniformColorSpectrum | ( | int | width,
 |  | int | col_count,
 |  | const fvec4 * | colors,
 |  | const float * | col_pos |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeColorSpectrum | ( | int | width,
 |  | const std::vector< fvec4 > & | colors |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeColorSpectrum | ( | int | width,
 |  | const fvec4 & | c0,
 |  | const fvec4 & | c1 |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeColorSpectrum | ( | int | width,
 |  | const fvec4 & | c0,
 |  | const fvec4 & | c1,
 |  | const fvec4 & | c2 |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeColorSpectrum | ( | int | width,
 |  | const fvec4 & | c0,
 |  | const fvec4 & | c1,
 |  | const fvec4 & | c2,
 |  | const fvec4 & | c3 |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > Image::makeColorSpectrum | ( | int | width,
 |  | const fvec4 & | c0,
 |  | const fvec4 & | c1,
 |  | const fvec4 & | c2,
 |  | const fvec4 & | c3,
 |  | const fvec4 & | c4 |
 | ) |  |  | [static]

Creates a 1D Image whose color is interpolated from left to right from the specified spectrum.

ref< Image > vl::Image::convertType ( EImageType new_type ) const

Converts the type() of an image.

The source image type and the new type must be one of the following:

  • IT_UNSIGNED_BYTE
  • IT_BYTE
  • IT_UNSIGNED_SHORT
  • IT_SHORT
  • IT_UNSIGNED_INT
  • IT_INT
  • IT_FLOAT

The source image format must be one of the following:

  • IF_RGB
  • IF_RGBA
  • IF_BGR
  • IF_BGRA
  • IF_RED
  • IF_GREEN
  • IF_BLUE
  • IF_ALPHA
  • IF_LUMINANCE
  • IF_LUMINANCE_ALPHA
  • IF_DEPTH_COMPONENT

ref< Image > vl::Image::convertFormat ( EImageFormat new_format ) const

Converts the format() of an image.

The source image type must be one of the following:

  • IT_UNSIGNED_BYTE
  • IT_BYTE
  • IT_UNSIGNED_SHORT
  • IT_SHORT
  • IT_UNSIGNED_INT
  • IT_INT
  • IT_FLOAT

The source image format and the new format must be one of the following:

  • IF_RGB
  • IF_RGBA
  • IF_BGR
  • IF_BGRA
  • IF_RED
  • IF_GREEN
  • IF_BLUE
  • IF_ALPHA
  • IF_LUMINANCE
  • IF_LUMINANCE_ALPHA

bool Image::equalize ( )

Equalizes the image. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.

This function is mainly useful for images whose type() is IF_LUMINANCE, IF_RED, IF_GREEN, IF_BLUE, IF_ALPHA or IF_DEPTH_COMPONENT.

IF_RGB, IF_RGBA, IF_BGR, IF_BGRA and IF_LUMINANCE_ALPHA types are not optimally handled yet.

bool Image::contrast | ( | float | black,
 |  | float | white
 | ) |  |

Adjusts the contrast of an image. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.

This function supports only images whose type() is IF_LUMINANCE, IF_RED, IF_GREEN, IF_BLUE, IF_ALPHA or IF_DEPTH_COMPONENT.

The parameters black and white are in normalized units (0=black, 1=white) but are not required to be in the range between 0 and 1.

bool Image::contrastHounsfieldAuto ( )

Adjusts the contrast of an image using the window-center/window-with method used for CT images. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.

The center and width parameters are in Hounsfield units.

Calls contrastHounsfield(float center, float width, float intercept, float range) with center, with, range and intercept parameters extracted from the image tags() "WindowCenter", "WindowWidth", "BitsStored" and "RescaleIntercept". This function is equivalent to the code below.

if ( !tags()->has("WindowCenter") || !tags()->has("WindowWidth") || !tags()->has("BitsStored") || !tags()->has("RescaleIntercept"))
  return false;

float center    = tags()->value("WindowCenter").toFloat();
float width     = tags()->value("WindowWidth").toFloat();
float range     = (1<<tags()->value("BitsStored").toInt()) - 1.0f;
float intercept = tags()->value("RescaleIntercept").toFloat();

// Hounsfield units: -1000 = air, +1000 = solid bone
// Transform from Hounsfield units to normalized 0..1 units
center = (center-intercept) / range;
width  = width / range;
return contrast( center-width/2.0f, center+width/2.0f );

bool Image::contrastHounsfield | ( | float | center,
 |  | float | width,
 |  | float | intercept,
 |  | float | range
 | ) |  |

Adjusts the contrast of an image using the window-center/window-with method used for CT images. Returns false if the image format() or type() is not supported. This function supports both 3D images and cubemaps.

The center and width parameters are in Hounsfield units.

This function is equivalent to the code below:

// Hounsfield units: -1000 = air, +1000 = solid bone
// Transform from Hounsfield units to normalized 0..1 units
center = (center-intercept) / range;
width  = width / range;
return contrast( center-width/2.0f, center+width/2.0f );

fvec4 Image::sampleLinear ( double x )

Performs a sampling on a 1d image using linear filtering.

fvec4 Image::sampleLinear | ( | double | x,
 |  | double | y
 | ) |  |

Performs a sampling on a 2d image using bilinear filtering.

fvec4 Image::sampleLinear | ( | double | x,
 |  | double | y,
 |  | double | z
 | ) |  |

Performs a sampling on a 3d image using trilinear filtering.

fvec4 Image::sample | ( | int | x,
 |  | int | y = 0,
 |  | int | z = 0
 | ) |  |

Returns the color associated to the specified pixel.

The rgb values are mapped to 0..1 for all image types but IT_FLOAT. The value returned for images of type IT_FLOAT is returned exactly as is stored in the image.

The image type() must be one of the following:

  • IT_UNSIGNED_BYTE
  • IT_BYTE
  • IT_UNSIGNED_SHORT
  • IT_SHORT
  • IT_UNSIGNED_INT
  • IT_INT
  • IT_FLOAT

The image format() must be one of the following:

  • IF_RGB
  • IF_RGBA
  • IF_BGR
  • IF_BGRA
  • IF_RED
  • IF_GREEN
  • IF_BLUE
  • IF_ALPHA
  • IF_LUMINANCE
  • IF_LUMINANCE_ALPHA
  • IF_DEPTH_COMPONENT

ref< Image > Image::subImage | ( | int | xstart,
 |  | int | ystart,
 |  | int | width,
 |  | int | height
 | ) |  |

Creates a new image containing the specified rectangular pixel area taken from the source image.

The returned image is of the same type() and format() of the original one.

Note:
  • This function supports only 2d images.
  • This function does not support compressed types and formats.

void Image::copySubImage | ( | Image * | img_src,
 |  | RectI | src,
 |  | ivec2 | dst
 | ) |  |

Copies the rectangular area specified by src of img_src into an Image at position dst.

The source and destination image should be of the same type() and format() for maximum performances.

void Image::substituteColorRGB_RGBA | ( | unsigned int | before,
 |  | unsigned int | after
 | ) |  |

Substitutes the color 'before' with the new color 'after'.

Parameters:
before | is an hexadecimal representation of an RGB triplet given in the form 0xRRGGBB.
after | is an hexadecimal representation of an RGBA quadruplet given in the form 0xRRGGBBAA. For example 0xFF0000FF is opaque red, 0x00FF0088 is half transparent green. This function can be very useful when you want to modify a specified color of an image or when you want to perform color-key transparency, i.e. when you want to set the transparency of the pixels that have a particular color.
Note:
  • This function can be used only if the image type() is IT_UNSIGNED_BYTE and format() is either IF_RGB or IF_RGBA.
  • If the image format() is set to IF_RGB then the alpha value specified in 'after' is ignored.
  • If you want to be sure to keep the alpha channel intact use the substituteColorRGB_RGB() function instead.

void Image::substituteColorRGB_RGB | ( | unsigned int | before,
 |  | unsigned int | after
 | ) |  |

Substitutes the color 'before' with the new color 'after'.

Parameters:
before | is an hexadecimal representation of an RGB triplet given in the form 0xRRGGBB.
after | is an hexadecimal representation of an RGB tripet given in the form 0xRRGGBB. For example 0xFF0000 is opaque red, 0x00FF00 is green. This function can be very useful when you want to modify a specified color of an image but you want to keep the alpha channel intact.
Note:
  • This function can be used only if the image type() is IT_UNSIGNED_BYTE and format() is either IF_RGB or IF_RGBA.
  • If you want to change the alpha channel of the modified pixels use the substituteColorRGB_RGBA() function instead.

void Image::substituteColorGreenKey | ( | unsigned int | col0,
 |  | unsigned int | col1
 | ) |  |

void Image::updatePitch ( ) [protected]

Member Data Documentation

ref<GLBufferObject> vl::Image::mPixels [protected]

ref<KeyValues> vl::Image::mTags [protected]

std::vector< ref<Image> > vl::Image::mMipmaps [protected]

int vl::Image::mWidth [protected]

int vl::Image::mHeight [protected]

int vl::Image::mDepth [protected]

int vl::Image::mPitch [protected]

int vl::Image::mByteAlign [protected]

EImageFormat vl::Image::mFormat [protected]

EImageType vl::Image::mType [protected]

bool vl::Image::mIsCubemap [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::Interpolator Class Reference

vl::Interpolator

vl::Interpolator Class Reference

Abstract class for all the interpolators. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::Interpolator:

vl::Object vl::InterpolatorDouble vl::InterpolatorDVec2 vl::InterpolatorDVec3 vl::InterpolatorDVec4 vl::InterpolatorFloat vl::InterpolatorFVec2 vl::InterpolatorFVec3 vl::InterpolatorFVec4

List of all members.

Public Member Functions

Interpolator ()

Detailed Description

Abstract class for all the interpolators.

An Interpolator is an object that implements a specific interpolation scheme (linear, Catmull-Rom, Bezier etc.) to interpolate data such as vectors, colors, rotations an so on. Interpolators are very useful for tasks such as animating an object's position and/or rotation, creating a smooth curved line from a set of control points, creating extrusion paths and silhouettes etc.

See also:
LinearInterpolator, CatmullRomInterpolator, the Interpolators Tutorial page and the Extrusion class.

Constructor & Destructor Documentation

vl::Interpolator::Interpolator ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorDouble Class Reference

vl::InterpolatorDouble

vl::InterpolatorDouble Class Reference

Abstract class that interpolates double values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorDouble:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorDouble vl::LinearInterpolatorDouble

List of all members.

Public Member Functions

virtual double computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates double values.

Member Function Documentation

virtual double vl::InterpolatorDouble::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorDouble, and vl::LinearInterpolatorDouble.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorDVec2 Class Reference

vl::InterpolatorDVec2

vl::InterpolatorDVec2 Class Reference

Abstract class that interpolates vl::dvec2 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorDVec2:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorDVec2 vl::LinearInterpolatorDVec2

List of all members.

Public Member Functions

virtual vl::dvec2 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::dvec2 values.

Member Function Documentation

virtual vl::dvec2 vl::InterpolatorDVec2::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorDVec2, and vl::LinearInterpolatorDVec2.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorDVec3 Class Reference

vl::InterpolatorDVec3

vl::InterpolatorDVec3 Class Reference

Abstract class that interpolates vl::dvec3 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorDVec3:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorDVec3 vl::LinearInterpolatorDVec3

List of all members.

Public Member Functions

virtual vl::dvec3 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::dvec3 values.

Member Function Documentation

virtual vl::dvec3 vl::InterpolatorDVec3::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorDVec3, and vl::LinearInterpolatorDVec3.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorDVec4 Class Reference

vl::InterpolatorDVec4

vl::InterpolatorDVec4 Class Reference

Abstract class that interpolates vl::dvec4 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorDVec4:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorDVec4 vl::LinearInterpolatorDVec4

List of all members.

Public Member Functions

virtual vl::dvec4 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::dvec4 values.

Member Function Documentation

virtual vl::dvec4 vl::InterpolatorDVec4::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorDVec4, and vl::LinearInterpolatorDVec4.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorFloat Class Reference

vl::InterpolatorFloat

vl::InterpolatorFloat Class Reference

Abstract class that interpolates float values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorFloat:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorFloat vl::LinearInterpolatorFloat

List of all members.

Public Member Functions

virtual float computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates float values.

Member Function Documentation

virtual float vl::InterpolatorFloat::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorFloat, and vl::LinearInterpolatorFloat.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorFVec2 Class Reference

vl::InterpolatorFVec2

vl::InterpolatorFVec2 Class Reference

Abstract class that interpolates vl::fvec2 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorFVec2:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorFVec2 vl::LinearInterpolatorFVec2

List of all members.

Public Member Functions

virtual vl::fvec2 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::fvec2 values.

Member Function Documentation

virtual vl::fvec2 vl::InterpolatorFVec2::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorFVec2, and vl::LinearInterpolatorFVec2.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorFVec3 Class Reference

vl::InterpolatorFVec3

vl::InterpolatorFVec3 Class Reference

Abstract class that interpolates vl::fvec3 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorFVec3:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorFVec3 vl::LinearInterpolatorFVec3

List of all members.

Public Member Functions

virtual vl::fvec3 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::fvec3 values.

Member Function Documentation

virtual vl::fvec3 vl::InterpolatorFVec3::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorFVec3, and vl::LinearInterpolatorFVec3.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::InterpolatorFVec4 Class Reference

vl::InterpolatorFVec4

vl::InterpolatorFVec4 Class Reference

Abstract class that interpolates vl::fvec4 values. More...

#include <Interpolator.hpp>

Inheritance diagram for vl::InterpolatorFVec4:

vl::Interpolator vl::Object vl::CatmullRomInterpolatorFVec4 vl::LinearInterpolatorFVec4

List of all members.

Public Member Functions

virtual vl::fvec4 computePoint (float t) const =0
Samples the interpolator at the given point.

Detailed Description

Abstract class that interpolates vl::fvec4 values.

Member Function Documentation

virtual vl::fvec4 vl::InterpolatorFVec4::computePoint ( float t ) const [pure virtual]

Samples the interpolator at the given point.

Implemented in vl::CatmullRomInterpolatorFVec4, and vl::LinearInterpolatorFVec4.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::KeyValues Class Reference

vl::KeyValues

vl::KeyValues Class Reference

A set of key/value pairs used to store generic information. More...

#include <KeyValues.hpp>

Inheritance diagram for vl::KeyValues:

vl::Object

List of all members.

Public Member Functions

bool | has (const String &key) const
String | value (const String &key) const
String & | set (const String &key)
void | erase (const String &key)
void | getKeys (std::vector< String > &keys) const
void | clear ()
const std::map< String, String > & | keyValueMap () const
std::map< String, String > & | keyValueMap ()
void | print ()

Protected Attributes

std::map< String, String > | mKeyValues

Detailed Description

A set of key/value pairs used to store generic information.

Member Function Documentation

bool vl::KeyValues::has ( const String & key ) const [inline]

String KeyValues::value ( const String & key ) const

String& vl::KeyValues::set ( const String & key ) [inline]

void vl::KeyValues::erase ( const String & key ) [inline]

void KeyValues::getKeys ( std::vector< String > & keys ) const

void vl::KeyValues::clear ( ) [inline]

const std::map<String,String>& vl::KeyValues::keyValueMap ( ) const [inline]

std::map<String,String>& vl::KeyValues::keyValueMap ( ) [inline]

void KeyValues::print ( )

Member Data Documentation

std::map<String,String> vl::KeyValues::mKeyValues [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::Light Class Reference

vl::Light

vl::Light Class Reference

Wraps the OpenGL function glLight(). More...

#include <Light.hpp>

Inheritance diagram for vl::Light:

vl::RenderState vl::Object

List of all members.

Public Member Functions

Light (int light_index)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
virtual void | disable () const
virtual void | enable () const
void | setAmbient (const fvec4 &ambientcolor)
const fvec4 & | ambient () const
void | setDiffuse (const fvec4 &diffusecolor)
const fvec4 & | diffuse () const
void | setSpecular (const fvec4 &specularcolor)
const fvec4 & | specular () const
void | setPosition (const fvec4 &position)
The position or direction of a light.
const fvec4 & | position () const
The position or direction of a light.
void | setSpotDirection (const fvec3 &spotdirection)
const fvec3 & | spotDirection () const
void | setSpotExponent (float spotexponent)
float | spotExponent () const
void | setSpotCutoff (float spotcutoff)
Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot lighting.
float | spotCutoff () const
Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot lighting.
void | setLinearAttenuation (float linearattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.
float | linearAttenuation () const
void | setQuadraticAttenuation (float quadraticattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.
float | quadraticAttenuation () const
void | setConstantAttenuation (float constantattenuation)
If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.
float | constantAttenuation () const
void | setLightIndex (int light_index)
int | lightIndex () const
void | followTransform (Transform *transform)
If NULL follows the camera otherwise the given transformation node.
Transform * followedTransform ()
const Transform * | followedTransform () const

Protected Attributes

fvec4 mAmbient
fvec4 mDiffuse
fvec4 mSpecular
fvec4 mPosition
fvec3 mSpotDirection
float | mSpotExponent
float | mSpotCutoff
float | mConstantAttenuation
float | mLinearAttenuation
float | mQuadraticAttenuation
ref< Transform > mFollowedTransform
int | mLightIndex

Detailed Description

Wraps the OpenGL function glLight().

See also http://www.opengl.org/sdk/docs/man/xhtml/glLight.xml for more information.

See also the Lights Tutorial for a practical example of how to use OpenGL lights.

See also:
Shader, Effect, Actor, vl::EN_LIGHTING

Constructor & Destructor Documentation

Light::Light ( int light_index )

Member Function Documentation

virtual const char* vl::Light::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::Light::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void Light::apply ( const Camera * camera ) const [virtual]

Implements vl::RenderState.

virtual void vl::Light::disable ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

virtual void vl::Light::enable ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void vl::Light::setAmbient ( const fvec4 & ambientcolor ) [inline]

const fvec4& vl::Light::ambient ( ) const [inline]

void vl::Light::setDiffuse ( const fvec4 & diffusecolor ) [inline]

const fvec4& vl::Light::diffuse ( ) const [inline]

void vl::Light::setSpecular ( const fvec4 & specularcolor ) [inline]

const fvec4& vl::Light::specular ( ) const [inline]

void vl::Light::setPosition ( const fvec4 & position ) [inline]

The position or direction of a light.

  • If the fourth component of position equals 0.0f then the light is considered a directional light and position points in the direction of the light.
  • If the fourth component of position equals 1.0f then the light is considered a positional light and position contains the position of the light.

Note. The position or direction of a light is relative to the followed Transform or to the camera if the light does not follow any transform.

const fvec4& vl::Light::position ( ) const [inline]

The position or direction of a light.

void vl::Light::setSpotDirection ( const fvec3 & spotdirection ) [inline]

const fvec3& vl::Light::spotDirection ( ) const [inline]

void vl::Light::setSpotExponent ( float spotexponent ) [inline]

float vl::Light::spotExponent ( ) const [inline]

void vl::Light::setSpotCutoff ( float spotcutoff ) [inline]

Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot lighting.

float vl::Light::spotCutoff ( ) const [inline]

Valid values are from 0.0f to 90.0f plus the special value 180.0f (default) which disables the spot lighting.

void vl::Light::setLinearAttenuation ( float linearattenuation ) [inline]

If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.

float vl::Light::linearAttenuation ( ) const [inline]

void vl::Light::setQuadraticAttenuation ( float quadraticattenuation ) [inline]

If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.

float vl::Light::quadraticAttenuation ( ) const [inline]

void vl::Light::setConstantAttenuation ( float constantattenuation ) [inline]

If the light is positional, rather than directional, its intensity is attenuated by the reciprocal of the sum of the constant attenuation, the linear attenuation times the distance between the light and the vertex being lighted, and the quadratic attenuation times the square of the same distance.

float vl::Light::constantAttenuation ( ) const [inline]

void Light::setLightIndex ( int light_index )

int vl::Light::lightIndex ( ) const [inline]

void Light::followTransform ( Transform * transform )

If NULL follows the camera otherwise the given transformation node.

Transform * Light::followedTransform ( )

const Transform * Light::followedTransform ( ) const

Member Data Documentation

fvec4 vl::Light::mAmbient [protected]

fvec4 vl::Light::mDiffuse [protected]

fvec4 vl::Light::mSpecular [protected]

fvec4 vl::Light::mPosition [protected]

fvec3 vl::Light::mSpotDirection [protected]

float vl::Light::mSpotExponent [protected]

float vl::Light::mSpotCutoff [protected]

float vl::Light::mConstantAttenuation [protected]

float vl::Light::mLinearAttenuation [protected]

float vl::Light::mQuadraticAttenuation [protected]

ref<Transform> vl::Light::mFollowedTransform [protected]

int vl::Light::mLightIndex [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LightModel Class Reference

vl::LightModel

vl::LightModel Class Reference

Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::LightModel:

vl::RenderState vl::Object

List of all members.

Public Member Functions

LightModel ()
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | setLocalViewer (bool localviewer)
void | setTwoSide (bool twoside)
void | setColorControl (EColorControl colorcontrol)
void | setAmbientColor (fvec4 ambientcolor)
bool | localViewer () const
bool | twoSide () const
EColorControl | colorControl () const
fvec4 | ambientColor () const

Protected Attributes

fvec4 mAmbientColor
EColorControl mColorControl
bool | mLocalViewer
bool | mTwoSide

Detailed Description

Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_LIGHTING

Constructor & Destructor Documentation

vl::LightModel::LightModel ( ) [inline]

Member Function Documentation

virtual const char* vl::LightModel::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::LightModel::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void LightModel::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::LightModel::setLocalViewer ( bool localviewer ) [inline]

void vl::LightModel::setTwoSide ( bool twoside ) [inline]

void vl::LightModel::setColorControl ( EColorControl colorcontrol ) [inline]

void vl::LightModel::setAmbientColor ( fvec4 ambientcolor ) [inline]

bool vl::LightModel::localViewer ( ) const [inline]

bool vl::LightModel::twoSide ( ) const [inline]

EColorControl vl::LightModel::colorControl ( ) const [inline]

fvec4 vl::LightModel::ambientColor ( ) const [inline]

Member Data Documentation

fvec4 vl::LightModel::mAmbientColor [protected]

EColorControl vl::LightModel::mColorControl [protected]

bool vl::LightModel::mLocalViewer [protected]

bool vl::LightModel::mTwoSide [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::LinearInterpolator< T > Class Template Reference

vl::LinearInterpolator

vl::LinearInterpolator< T > Class Template Reference

The LinearInterpolator class is a template class that implements linear interpolation. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolator< T >:

vl::Object

List of all members.

Public Member Functions

LinearInterpolator ()
LinearInterpolator (const std::vector< T > &path)
T | computePoint (float t) const
Samples the path at the given point. The t parameter must be in the range 0.0 ... 1.0 included.
void | setPath (const std::vector< T > &path)
The control points defining the Catmull-Rom spline.
const std::vector< T > & | path () const
The control points defining the Catmull-Rom spline.
std::vector< T > & | path ()
The control points defining the Catmull-Rom spline.

Protected Attributes

std::vector< T > | mPath
std::vector< T > | mLinearSpline

Detailed Description

template<typename T>
class vl::LinearInterpolator< T >

The LinearInterpolator class is a template class that implements linear interpolation.

See also:
CatmullRomInterpolator, Interpolator and the Interpolators Tutorial page.

Constructor & Destructor Documentation

template<typename T >
vl::LinearInterpolator< T >::LinearInterpolator ( ) [inline]

template<typename T >
vl::LinearInterpolator< T >::LinearInterpolator ( const std::vector< T > & path ) [inline]

Member Function Documentation

template<typename T >
T vl::LinearInterpolator< T >::computePoint ( float t ) const [inline]

Samples the path at the given point. The t parameter must be in the range 0.0 ... 1.0 included.

template<typename T >
void vl::LinearInterpolator< T >::setPath ( const std::vector< T > & path ) [inline]

The control points defining the Catmull-Rom spline.

Because of the Catmull-Rom formula the interpolated path must start and end with an extra control point (one on each side) and cannot have less than 4 control points.

template<typename T >
const std::vector<T>& vl::LinearInterpolator< T >::path ( ) const [inline]

The control points defining the Catmull-Rom spline.

template<typename T >
std::vector<T>& vl::LinearInterpolator< T >::path ( ) [inline]

The control points defining the Catmull-Rom spline.

Member Data Documentation

template<typename T >
std::vector<T> vl::LinearInterpolator< T >::mPath [protected]

template<typename T >
std::vector<T> vl::LinearInterpolator< T >::mLinearSpline [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorDouble Class Reference

vl::LinearInterpolatorDouble

vl::LinearInterpolatorDouble Class Reference

Interpolates double values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorDouble:

vl::InterpolatorDouble vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorDouble ()
LinearInterpolatorDouble (const std::vector< double > &path)
double | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorDouble_T * interpolator ()
const LinearInterpolatorDouble_T * | interpolator () const
void | setInterpolator (LinearInterpolatorDouble_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorDouble_T > 		mInterpolator

Detailed Description

Interpolates double values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorDouble::LinearInterpolatorDouble ( ) [inline]

vl::LinearInterpolatorDouble::LinearInterpolatorDouble ( const std::vector< double > & path ) [inline]

Member Function Documentation

double vl::LinearInterpolatorDouble::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDouble.

LinearInterpolatorDouble_T* vl::LinearInterpolatorDouble::interpolator ( ) [inline]

const LinearInterpolatorDouble_T* vl::LinearInterpolatorDouble::interpolator ( ) const [inline]

void vl::LinearInterpolatorDouble::setInterpolator ( LinearInterpolatorDouble_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorDouble_T> vl::LinearInterpolatorDouble::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorDVec2 Class Reference

vl::LinearInterpolatorDVec2

vl::LinearInterpolatorDVec2 Class Reference

Interpolates vl::dvec2 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorDVec2:

vl::InterpolatorDVec2 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorDVec2 ()
LinearInterpolatorDVec2 (const std::vector< vl::dvec2 > &path)
vl::dvec2 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorDVec2_T * interpolator ()
const LinearInterpolatorDVec2_T * | interpolator () const
void | setInterpolator (LinearInterpolatorDVec2_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorDVec2_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec2 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorDVec2::LinearInterpolatorDVec2 ( ) [inline]

vl::LinearInterpolatorDVec2::LinearInterpolatorDVec2 ( const std::vector< vl::dvec2 > & path ) [inline]

Member Function Documentation

vl::dvec2 vl::LinearInterpolatorDVec2::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec2.

LinearInterpolatorDVec2_T* vl::LinearInterpolatorDVec2::interpolator ( ) [inline]

const LinearInterpolatorDVec2_T* vl::LinearInterpolatorDVec2::interpolator ( ) const [inline]

void vl::LinearInterpolatorDVec2::setInterpolator ( LinearInterpolatorDVec2_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorDVec2_T> vl::LinearInterpolatorDVec2::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorDVec3 Class Reference

vl::LinearInterpolatorDVec3

vl::LinearInterpolatorDVec3 Class Reference

Interpolates vl::dvec3 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorDVec3:

vl::InterpolatorDVec3 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorDVec3 ()
LinearInterpolatorDVec3 (const std::vector< vl::dvec3 > &path)
vl::dvec3 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorDVec3_T * interpolator ()
const LinearInterpolatorDVec3_T * | interpolator () const
void | setInterpolator (LinearInterpolatorDVec3_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorDVec3_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec3 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorDVec3::LinearInterpolatorDVec3 ( ) [inline]

vl::LinearInterpolatorDVec3::LinearInterpolatorDVec3 ( const std::vector< vl::dvec3 > & path ) [inline]

Member Function Documentation

vl::dvec3 vl::LinearInterpolatorDVec3::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec3.

LinearInterpolatorDVec3_T* vl::LinearInterpolatorDVec3::interpolator ( ) [inline]

const LinearInterpolatorDVec3_T* vl::LinearInterpolatorDVec3::interpolator ( ) const [inline]

void vl::LinearInterpolatorDVec3::setInterpolator ( LinearInterpolatorDVec3_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorDVec3_T> vl::LinearInterpolatorDVec3::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorDVec4 Class Reference

vl::LinearInterpolatorDVec4

vl::LinearInterpolatorDVec4 Class Reference

Interpolates vl::dvec4 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorDVec4:

vl::InterpolatorDVec4 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorDVec4 ()
LinearInterpolatorDVec4 (const std::vector< vl::dvec4 > &path)
vl::dvec4 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorDVec4_T * interpolator ()
const LinearInterpolatorDVec4_T * | interpolator () const
void | setInterpolator (LinearInterpolatorDVec4_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorDVec4_T > 		mInterpolator

Detailed Description

Interpolates vl::dvec4 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorDVec4::LinearInterpolatorDVec4 ( ) [inline]

vl::LinearInterpolatorDVec4::LinearInterpolatorDVec4 ( const std::vector< vl::dvec4 > & path ) [inline]

Member Function Documentation

vl::dvec4 vl::LinearInterpolatorDVec4::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorDVec4.

LinearInterpolatorDVec4_T* vl::LinearInterpolatorDVec4::interpolator ( ) [inline]

const LinearInterpolatorDVec4_T* vl::LinearInterpolatorDVec4::interpolator ( ) const [inline]

void vl::LinearInterpolatorDVec4::setInterpolator ( LinearInterpolatorDVec4_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorDVec4_T> vl::LinearInterpolatorDVec4::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorFloat Class Reference

vl::LinearInterpolatorFloat

vl::LinearInterpolatorFloat Class Reference

Interpolates float values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorFloat:

vl::InterpolatorFloat vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorFloat ()
LinearInterpolatorFloat (const std::vector< float > &path)
float | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorFloat_T * interpolator ()
const LinearInterpolatorFloat_T * | interpolator () const
void | setInterpolator (LinearInterpolatorFloat_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorFloat_T > 		mInterpolator

Detailed Description

Interpolates float values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorFloat::LinearInterpolatorFloat ( ) [inline]

vl::LinearInterpolatorFloat::LinearInterpolatorFloat ( const std::vector< float > & path ) [inline]

Member Function Documentation

float vl::LinearInterpolatorFloat::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFloat.

LinearInterpolatorFloat_T* vl::LinearInterpolatorFloat::interpolator ( ) [inline]

const LinearInterpolatorFloat_T* vl::LinearInterpolatorFloat::interpolator ( ) const [inline]

void vl::LinearInterpolatorFloat::setInterpolator ( LinearInterpolatorFloat_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorFloat_T> vl::LinearInterpolatorFloat::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorFVec2 Class Reference

vl::LinearInterpolatorFVec2

vl::LinearInterpolatorFVec2 Class Reference

Interpolates vl::fvec2 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorFVec2:

vl::InterpolatorFVec2 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorFVec2 ()
LinearInterpolatorFVec2 (const std::vector< vl::fvec2 > &path)
vl::fvec2 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorFVec2_T * interpolator ()
const LinearInterpolatorFVec2_T * | interpolator () const
void | setInterpolator (LinearInterpolatorFVec2_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorFVec2_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec2 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorFVec2::LinearInterpolatorFVec2 ( ) [inline]

vl::LinearInterpolatorFVec2::LinearInterpolatorFVec2 ( const std::vector< vl::fvec2 > & path ) [inline]

Member Function Documentation

vl::fvec2 vl::LinearInterpolatorFVec2::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec2.

LinearInterpolatorFVec2_T* vl::LinearInterpolatorFVec2::interpolator ( ) [inline]

const LinearInterpolatorFVec2_T* vl::LinearInterpolatorFVec2::interpolator ( ) const [inline]

void vl::LinearInterpolatorFVec2::setInterpolator ( LinearInterpolatorFVec2_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorFVec2_T> vl::LinearInterpolatorFVec2::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorFVec3 Class Reference

vl::LinearInterpolatorFVec3

vl::LinearInterpolatorFVec3 Class Reference

Interpolates vl::fvec3 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorFVec3:

vl::InterpolatorFVec3 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorFVec3 ()
LinearInterpolatorFVec3 (const std::vector< vl::fvec3 > &path)
vl::fvec3 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorFVec3_T * interpolator ()
const LinearInterpolatorFVec3_T * | interpolator () const
void | setInterpolator (LinearInterpolatorFVec3_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorFVec3_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec3 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorFVec3::LinearInterpolatorFVec3 ( ) [inline]

vl::LinearInterpolatorFVec3::LinearInterpolatorFVec3 ( const std::vector< vl::fvec3 > & path ) [inline]

Member Function Documentation

vl::fvec3 vl::LinearInterpolatorFVec3::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec3.

LinearInterpolatorFVec3_T* vl::LinearInterpolatorFVec3::interpolator ( ) [inline]

const LinearInterpolatorFVec3_T* vl::LinearInterpolatorFVec3::interpolator ( ) const [inline]

void vl::LinearInterpolatorFVec3::setInterpolator ( LinearInterpolatorFVec3_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorFVec3_T> vl::LinearInterpolatorFVec3::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LinearInterpolatorFVec4 Class Reference

vl::LinearInterpolatorFVec4

vl::LinearInterpolatorFVec4 Class Reference

Interpolates vl::fvec4 values using a LinearInterpolator. More...

#include <LinearInterpolator.hpp>

Inheritance diagram for vl::LinearInterpolatorFVec4:

vl::InterpolatorFVec4 vl::Interpolator vl::Object

List of all members.

Public Member Functions

LinearInterpolatorFVec4 ()
LinearInterpolatorFVec4 (const std::vector< vl::fvec4 > &path)
vl::fvec4 | computePoint (float t) const
Samples the interpolator at the given point.
LinearInterpolatorFVec4_T * interpolator ()
const LinearInterpolatorFVec4_T * | interpolator () const
void | setInterpolator (LinearInterpolatorFVec4_T *interpolator)

Protected Attributes

vl::ref
< LinearInterpolatorFVec4_T > 		mInterpolator

Detailed Description

Interpolates vl::fvec4 values using a LinearInterpolator.

Constructor & Destructor Documentation

vl::LinearInterpolatorFVec4::LinearInterpolatorFVec4 ( ) [inline]

vl::LinearInterpolatorFVec4::LinearInterpolatorFVec4 ( const std::vector< vl::fvec4 > & path ) [inline]

Member Function Documentation

vl::fvec4 vl::LinearInterpolatorFVec4::computePoint ( float t ) const [inline, virtual]

Samples the interpolator at the given point.

Implements vl::InterpolatorFVec4.

LinearInterpolatorFVec4_T* vl::LinearInterpolatorFVec4::interpolator ( ) [inline]

const LinearInterpolatorFVec4_T* vl::LinearInterpolatorFVec4::interpolator ( ) const [inline]

void vl::LinearInterpolatorFVec4::setInterpolator ( LinearInterpolatorFVec4_T * interpolator ) [inline]

Member Data Documentation

vl::ref<LinearInterpolatorFVec4_T> vl::LinearInterpolatorFVec4::mInterpolator [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LineStipple Class Reference

vl::LineStipple

vl::LineStipple Class Reference

Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::LineStipple:

vl::RenderState vl::Object

List of all members.

Public Member Functions

LineStipple (int factor=1, GLushort pattern=~(GLushort) 0)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (int factor, GLushort pattern)
void | setFactor (int factor)
void | setPattern (GLushort pattern)
int | factor () const
GLushort | pattern () const

Protected Attributes

int | mFactor
GLushort | mPattern

Detailed Description

Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_LINE_STIPPLE

Constructor & Destructor Documentation

vl::LineStipple::LineStipple | ( | int | factor = 1,
 |  | GLushort | pattern = ~(GLushort)0 |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::LineStipple::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::LineStipple::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void LineStipple::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::LineStipple::set | ( | int | factor,
 |  | GLushort | pattern |
 | ) |  |  | [inline]

void vl::LineStipple::setFactor ( int factor ) [inline]

void vl::LineStipple::setPattern ( GLushort pattern ) [inline]

int vl::LineStipple::factor ( ) const [inline]

GLushort vl::LineStipple::pattern ( ) const [inline]

Member Data Documentation

int vl::LineStipple::mFactor [protected]

GLushort vl::LineStipple::mPattern [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::LineWidth Class Reference

vl::LineWidth

vl::LineWidth Class Reference

Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::LineWidth:

vl::RenderState vl::Object

List of all members.

Public Member Functions

LineWidth (float linewidth=1.0f)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (float linewidth)
float | lineWidth () const

Protected Attributes

float | mLineWidth

Detailed Description

Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::LineWidth::LineWidth ( float linewidth = 1.0f ) [inline]

Member Function Documentation

virtual const char* vl::LineWidth::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::LineWidth::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void LineWidth::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::LineWidth::set ( float linewidth ) [inline]

float vl::LineWidth::lineWidth ( ) const [inline]

Member Data Documentation

float vl::LineWidth::mLineWidth [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::LoadCallback Class Reference

vl::LoadCallback

vl::LoadCallback Class Reference

Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback. More...

#include <LoadWriterManager.hpp>

Inheritance diagram for vl::LoadCallback:

vl::Object vl::GeometryLoadCallback

List of all members.

Public Member Functions

virtual void operator() (ResourceDatabase *db)=0

Detailed Description

Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback.

Member Function Documentation

virtual void vl::LoadCallback::operator() ( ResourceDatabase * db ) [pure virtual]

Implemented in vl::GeometryLoadCallback.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LoadWriter3DS Class Reference

vl::LoadWriter3DS

vl::LoadWriter3DS Class Reference

The LoadWriter3DS class is a ResourceLoadWriter capable of reading 3DS files. More...

#include <vl3DS.hpp>

Inheritance diagram for vl::LoadWriter3DS:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriter3DS ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriter3DS class is a ResourceLoadWriter capable of reading 3DS files.

Constructor & Destructor Documentation

vl::LoadWriter3DS::LoadWriter3DS ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriter3DS::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriter3DS::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriter3DS::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriter3DS::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriter3DS::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterAC3D Class Reference

vl::LoadWriterAC3D

vl::LoadWriterAC3D Class Reference

The LoadWriterAC3D class is a ResourceLoadWriter capable of reading AC3D files. More...

#include <vlAC3D.hpp>

Inheritance diagram for vl::LoadWriterAC3D:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterAC3D ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriterAC3D class is a ResourceLoadWriter capable of reading AC3D files.

Constructor & Destructor Documentation

vl::LoadWriterAC3D::LoadWriterAC3D ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterAC3D::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterAC3D::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterAC3D::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterAC3D::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterAC3D::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterBMP Class Reference

vl::LoadWriterBMP

vl::LoadWriterBMP Class Reference

The LoadWriterBMP class is a ResourceLoadWriter capable of reading BMP files. More...

#include <vlBMP.hpp>

Inheritance diagram for vl::LoadWriterBMP:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterBMP ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
bool | writeResource (VirtualFile *, ResourceDatabase *) const

Detailed Description

The LoadWriterBMP class is a ResourceLoadWriter capable of reading BMP files.

Constructor & Destructor Documentation

vl::LoadWriterBMP::LoadWriterBMP ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterBMP::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterBMP::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterBMP::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterBMP::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterBMP::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterDAT Class Reference

vl::LoadWriterDAT

vl::LoadWriterDAT Class Reference

The LoadWriterDAT class is a ResourceLoadWriter capable of reading DAT files. More...

#include <vlDAT.hpp>

Inheritance diagram for vl::LoadWriterDAT:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterDAT ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
bool | writeResource (VirtualFile *, ResourceDatabase *) const

Detailed Description

The LoadWriterDAT class is a ResourceLoadWriter capable of reading DAT files.

Constructor & Destructor Documentation

vl::LoadWriterDAT::LoadWriterDAT ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterDAT::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDAT::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDAT::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDAT::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDAT::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterDDS Class Reference

vl::LoadWriterDDS

vl::LoadWriterDDS Class Reference

The LoadWriterDDS class is a ResourceLoadWriter capable of reading DDS files. More...

#include <vlDDS.hpp>

Inheritance diagram for vl::LoadWriterDDS:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterDDS ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
bool | writeResource (VirtualFile *, ResourceDatabase *) const

Detailed Description

The LoadWriterDDS class is a ResourceLoadWriter capable of reading DDS files.

Constructor & Destructor Documentation

vl::LoadWriterDDS::LoadWriterDDS ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterDDS::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDDS::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDDS::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDDS::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDDS::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterDICOM Class Reference

vl::LoadWriterDICOM

vl::LoadWriterDICOM Class Reference

The LoadWriterDICOM class is a ResourceLoadWriter capable of reading DICOM files. More...

#include <vlDICOM.hpp>

Inheritance diagram for vl::LoadWriterDICOM:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterDICOM ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
bool | writeResource (VirtualFile *, ResourceDatabase *) const

Detailed Description

The LoadWriterDICOM class is a ResourceLoadWriter capable of reading DICOM files.

Constructor & Destructor Documentation

vl::LoadWriterDICOM::LoadWriterDICOM ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterDICOM::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDICOM::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterDICOM::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDICOM::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterDICOM::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterJPG Class Reference

vl::LoadWriterJPG

vl::LoadWriterJPG Class Reference

The LoadWriterJPG class is a ResourceLoadWriter capable of reading JPG files. More...

#include <vlJPG.hpp>

Inheritance diagram for vl::LoadWriterJPG:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterJPG ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &path, ResourceDatabase *resource) const
bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const
int | quality () const
void | setQuality (int quality)
Sets the quality level used when saving a file. Must be between 0 and 100.

Protected Attributes

int | mQuality

Detailed Description

The LoadWriterJPG class is a ResourceLoadWriter capable of reading JPG files.

Constructor & Destructor Documentation

vl::LoadWriterJPG::LoadWriterJPG ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterJPG::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterJPG::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterJPG::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterJPG::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterJPG::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

int vl::LoadWriterJPG::quality ( ) const [inline]

void vl::LoadWriterJPG::setQuality ( int quality ) [inline]

Sets the quality level used when saving a file. Must be between 0 and 100.

Member Data Documentation

int vl::LoadWriterJPG::mQuality [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterManager Class Reference

vl::LoadWriterManager

vl::LoadWriterManager Class Reference

The LoadWriterManager class loads and writes resources using the registered ResourceLoadWriter objects. More...

#include <LoadWriterManager.hpp>

Inheritance diagram for vl::LoadWriterManager:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterManager ()
LoadWriterManager (const LoadWriterManager &other)
void | registerLoadWriter (ResourceLoadWriter *)
Collection< ResourceLoadWriter > * loadWriters ()
Returns the set of registered ResourceLoadWriter objects.
const Collection
< ResourceLoadWriter > * 		loadWriters () const
Returns the set of registered ResourceLoadWriter objects.
template<class T >
T * | loadWriter ()
Returns the first ResourceLoadWriter of the specified type found.
bool | canLoad (const String &path) const
Returns true if there is a ResourceLoadWriter registered to load the specified path or extension.
bool | canLoad (VirtualFile *file) const
Returns true if there is a ResourceLoadWriter registered to load the specified file.
bool | canWrite (const String &path) const
Returns true if there is a ResourceLoadWriter registered to write the specified path or extension.
bool | canWrite (VirtualFile *file) const
Returns true if there is a ResourceLoadWriter registered to write the specified file.
const ResourceLoadWriter * | findLoader (const String &path) const
Returns the ResourceLoadWriter that has been registered to load the resource type specified by the given path or extension.
const ResourceLoadWriter * | findWriter (const String &path) const
Returns the ResourceLoadWriter that has been registered to write the resource type specified by the given path or extension.
const ResourceLoadWriter * | findLoader (VirtualFile *file) const
Returns the ResourceLoadWriter that has been registered to load the resource type specified by the given file.
const ResourceLoadWriter * | findWriter (VirtualFile *file) const
Returns the ResourceLoadWriter that has been registered to write the resource type specified by the given file.
ref< ResourceDatabase > | loadResource (const String &path, bool quick=true) const
Loads the resource specified by the given path using the appropriate ResourceLoadWriter.
ref< ResourceDatabase > | loadResource (VirtualFile *file, bool quick=true) const
Loads the resource specified by the given file using the appropriate ResourceLoadWriter.
bool | writeResource (const String &path, ResourceDatabase *resource) const
Writes the resource specified by the given file using the appropriate ResourceLoadWriter.
bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const
Writes the resource specified by the given file using the appropriate ResourceLoadWriter.
const Collection< LoadCallback > * | loadCallbacks () const
const Collection< WriteCallback > * | writeCallbacks () const
Collection< LoadCallback > * loadCallbacks ()
Collection< WriteCallback > * writeCallbacks ()

Protected Attributes

Collection< ResourceLoadWriter > mLoadWriters
Collection< LoadCallback > mLoadCallbacks
Collection< WriteCallback > mWriteCallbacks

Detailed Description

The LoadWriterManager class loads and writes resources using the registered ResourceLoadWriter objects.

You can install a LoadCallback to operate on loaded data or you can install a WriteCallback to operate on the data to be written, using the methods loadCallbacks() and writeCallbacks().

Constructor & Destructor Documentation

vl::LoadWriterManager::LoadWriterManager ( ) [inline]

vl::LoadWriterManager::LoadWriterManager ( const LoadWriterManager & other ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterManager::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void LoadWriterManager::registerLoadWriter ( ResourceLoadWriter * load_writer )

Collection<ResourceLoadWriter>* vl::LoadWriterManager::loadWriters ( ) [inline]

Returns the set of registered ResourceLoadWriter objects.

const Collection<ResourceLoadWriter>* vl::LoadWriterManager::loadWriters ( ) const [inline]

Returns the set of registered ResourceLoadWriter objects.

template<class T >
T* vl::LoadWriterManager::loadWriter ( ) [inline]

Returns the first ResourceLoadWriter of the specified type found.

bool vl::LoadWriterManager::canLoad ( const String & path ) const [inline]

Returns true if there is a ResourceLoadWriter registered to load the specified path or extension.

bool vl::LoadWriterManager::canLoad ( VirtualFile * file ) const [inline]

Returns true if there is a ResourceLoadWriter registered to load the specified file.

bool vl::LoadWriterManager::canWrite ( const String & path ) const [inline]

Returns true if there is a ResourceLoadWriter registered to write the specified path or extension.

bool vl::LoadWriterManager::canWrite ( VirtualFile * file ) const [inline]

Returns true if there is a ResourceLoadWriter registered to write the specified file.

const ResourceLoadWriter * LoadWriterManager::findLoader ( const String & path ) const

Returns the ResourceLoadWriter that has been registered to load the resource type specified by the given path or extension.

const ResourceLoadWriter * LoadWriterManager::findWriter ( const String & path ) const

Returns the ResourceLoadWriter that has been registered to write the resource type specified by the given path or extension.

const ResourceLoadWriter * LoadWriterManager::findLoader ( VirtualFile * file ) const

Returns the ResourceLoadWriter that has been registered to load the resource type specified by the given file.

const ResourceLoadWriter * LoadWriterManager::findWriter ( VirtualFile * file ) const

Returns the ResourceLoadWriter that has been registered to write the resource type specified by the given file.

ref< ResourceDatabase > LoadWriterManager::loadResource | ( | const String & | path,
 |  | bool | quick = true |
 | ) |  |  | const

Loads the resource specified by the given path using the appropriate ResourceLoadWriter.

ref< ResourceDatabase > LoadWriterManager::loadResource | ( | VirtualFile * | file,
 |  | bool | quick = true |
 | ) |  |  | const

Loads the resource specified by the given file using the appropriate ResourceLoadWriter.

bool LoadWriterManager::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const

Writes the resource specified by the given file using the appropriate ResourceLoadWriter.

bool LoadWriterManager::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const

Writes the resource specified by the given file using the appropriate ResourceLoadWriter.

const Collection<LoadCallback>* vl::LoadWriterManager::loadCallbacks ( ) const [inline]

const Collection<WriteCallback>* vl::LoadWriterManager::writeCallbacks ( ) const [inline]

Collection<LoadCallback>* vl::LoadWriterManager::loadCallbacks ( ) [inline]

Collection<WriteCallback>* vl::LoadWriterManager::writeCallbacks ( ) [inline]

Member Data Documentation

Collection<ResourceLoadWriter> vl::LoadWriterManager::mLoadWriters [protected]

Collection<LoadCallback> vl::LoadWriterManager::mLoadCallbacks [protected]

Collection<WriteCallback> vl::LoadWriterManager::mWriteCallbacks [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LoadWriterMD2 Class Reference

vl::LoadWriterMD2

vl::LoadWriterMD2 Class Reference

The LoadWriterMD2 class is a ResourceLoadWriter capable of reading MD2 files. More...

#include <vlMD2.hpp>

Inheritance diagram for vl::LoadWriterMD2:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterMD2 ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriterMD2 class is a ResourceLoadWriter capable of reading MD2 files.

Constructor & Destructor Documentation

vl::LoadWriterMD2::LoadWriterMD2 ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterMD2::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterMD2::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterMD2::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterMD2::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterMD2::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterOBJ Class Reference

vl::LoadWriterOBJ

vl::LoadWriterOBJ Class Reference

The LoadWriterOBJ class is a ResourceLoadWriter capable of reading OBJ files. More...

#include <vlOBJ.hpp>

Inheritance diagram for vl::LoadWriterOBJ:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterOBJ ()
void | registerLoadWriter ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriterOBJ class is a ResourceLoadWriter capable of reading OBJ files.

Constructor & Destructor Documentation

vl::LoadWriterOBJ::LoadWriterOBJ ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterOBJ::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

void vl::LoadWriterOBJ::registerLoadWriter ( )

ref<ResourceDatabase> vl::LoadWriterOBJ::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterOBJ::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterOBJ::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterOBJ::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::LoadWriterPLY Class Reference

vl::LoadWriterPLY

vl::LoadWriterPLY Class Reference

The LoadWriterPLY class is a ResourceLoadWriter capable of reading PLY files. More...

#include <vlPLY.hpp>

Inheritance diagram for vl::LoadWriterPLY:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterPLY ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriterPLY class is a ResourceLoadWriter capable of reading PLY files.

Constructor & Destructor Documentation

vl::LoadWriterPLY::LoadWriterPLY ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterPLY::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterPLY::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterPLY::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterPLY::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterPLY::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::LoadWriterPNG Class Reference

vl::LoadWriterPNG

vl::LoadWriterPNG Class Reference

The LoadWriterPNG class is a ResourceLoadWriter capable of reading PNG files. More...

#include <vlPNG.hpp>

Inheritance diagram for vl::LoadWriterPNG:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterPNG ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &path, ResourceDatabase *resource) const
bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const
int | compression () const
void | setCompression (int compression)
Sets the compression level used when saving a file. Should be between 0 and 9.

Protected Attributes

int | mCompression

Detailed Description

The LoadWriterPNG class is a ResourceLoadWriter capable of reading PNG files.

Constructor & Destructor Documentation

vl::LoadWriterPNG::LoadWriterPNG ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterPNG::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterPNG::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterPNG::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterPNG::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterPNG::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

int vl::LoadWriterPNG::compression ( ) const [inline]

void vl::LoadWriterPNG::setCompression ( int compression ) [inline]

Sets the compression level used when saving a file. Should be between 0 and 9.

Member Data Documentation

int vl::LoadWriterPNG::mCompression [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::LoadWriterSTL Class Reference

vl::LoadWriterSTL

vl::LoadWriterSTL Class Reference

The LoadWriterSTL class is a ResourceLoadWriter capable of reading STL files. More...

#include <vlSTL.hpp>

Inheritance diagram for vl::LoadWriterSTL:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterSTL ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &, ResourceDatabase *) const
Not supported yet.
bool | writeResource (VirtualFile *, ResourceDatabase *) const
Not supported yet.

Detailed Description

The LoadWriterSTL class is a ResourceLoadWriter capable of reading STL files.

Constructor & Destructor Documentation

vl::LoadWriterSTL::LoadWriterSTL ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterSTL::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterSTL::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterSTL::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterSTL::writeResource | ( | const String & | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterSTL::writeResource | ( | VirtualFile * | ,
 |  | ResourceDatabase * |  |
 | ) |  |  | const [inline, virtual]

Not supported yet.

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::LoadWriterTGA Class Reference

vl::LoadWriterTGA

vl::LoadWriterTGA Class Reference

The LoadWriterTGA class is a ResourceLoadWriter capable of reading TGA files. More...

#include <vlTGA.hpp>

Inheritance diagram for vl::LoadWriterTGA:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterTGA ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &path, ResourceDatabase *resource) const
bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const

Detailed Description

The LoadWriterTGA class is a ResourceLoadWriter capable of reading TGA files.

Constructor & Destructor Documentation

vl::LoadWriterTGA::LoadWriterTGA ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterTGA::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterTGA::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterTGA::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterTGA::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterTGA::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::LoadWriterTIFF Class Reference

vl::LoadWriterTIFF

vl::LoadWriterTIFF Class Reference

The LoadWriterTIFF class is a ResourceLoadWriter capable of reading TIFF files. More...

#include <vlTIFF.hpp>

Inheritance diagram for vl::LoadWriterTIFF:

vl::ResourceLoadWriter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
LoadWriterTIFF ()
ref< ResourceDatabase > | loadResource (const String &path) const
ref< ResourceDatabase > | loadResource (VirtualFile *file) const
bool | writeResource (const String &path, ResourceDatabase *resource) const
bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const

Detailed Description

The LoadWriterTIFF class is a ResourceLoadWriter capable of reading TIFF files.

Constructor & Destructor Documentation

vl::LoadWriterTIFF::LoadWriterTIFF ( ) [inline]

Member Function Documentation

virtual const char* vl::LoadWriterTIFF::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterTIFF::loadResource ( const String & path ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

ref<ResourceDatabase> vl::LoadWriterTIFF::loadResource ( VirtualFile * file ) const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterTIFF::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

bool vl::LoadWriterTIFF::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [inline, virtual]

Implements vl::ResourceLoadWriter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::LODEvaluator Class Reference

vl::LODEvaluator

vl::LODEvaluator Class Reference

Abstract class to compute the appropriate LOD of an Actor or Effect. More...

#include <LODEvaluator.hpp>

Inheritance diagram for vl::LODEvaluator:

vl::Object vl::DistanceLODEvaluator vl::PixelLODEvaluator

List of all members.

Public Member Functions

LODEvaluator ()
virtual int | evaluate (Actor *actor, Camera *camera)=0
virtual const char * | className ()
Returns the name of the class.

Detailed Description

Abstract class to compute the appropriate LOD of an Actor or Effect.

See also:
  • DistanceLODEvaluator
  • PixelLODEvaluator

Constructor & Destructor Documentation

vl::LODEvaluator::LODEvaluator ( ) [inline]

Member Function Documentation

virtual int vl::LODEvaluator::evaluate | ( | Actor * | actor,
 |  | Camera * | camera |
 | ) |  |  | [pure virtual]

Implemented in vl::DistanceLODEvaluator, and vl::PixelLODEvaluator.

virtual const char* vl::LODEvaluator::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::DistanceLODEvaluator, and vl::PixelLODEvaluator.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LODEvaluator.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::Log Class Reference

vl::Log

vl::Log Class Reference

The Log class is the abstract base class used to generate logging data. More...

#include <Log.hpp>

Inheritance diagram for vl::Log:

vl::Object vl::StandardLog

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Log ()

Static Public Member Functions

static void | setLogger (Log *logger)
static Log * | logger ()
static void | print (ELogLevel level, const String &log)
static void | print (const String &log)
static void | debug (const String &log)
static void | info (const String &log)
static void | warning (const String &log)
static void | error (const String &log)
static void | bug (const String &log)

Protected Member Functions

virtual void | printImplementation (ELogLevel level, const String &log)=0

Static Protected Attributes

static ref< Log > | mLogger

Detailed Description

The Log class is the abstract base class used to generate logging data.

Constructor & Destructor Documentation

vl::Log::Log ( ) [inline]

Member Function Documentation

virtual const char* vl::Log::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::StandardLog.

static void vl::Log::setLogger ( Log * logger ) [inline, static]

static Log* vl::Log::logger ( ) [inline, static]

void Log::print | ( | ELogLevel | level,
 |  | const String & | log |
 | ) |  |  | [static]

void Log::print ( const String & log ) [static]

void Log::debug ( const String & log ) [static]

void Log::info ( const String & log ) [static]

void Log::warning ( const String & log ) [static]

void Log::error ( const String & log ) [static]

void Log::bug ( const String & log ) [static]

virtual void vl::Log::printImplementation | ( | ELogLevel | level,
 |  | const String & | log |
 | ) |  |  | [protected, pure virtual]

Implemented in vl::StandardLog.

Member Data Documentation

ref< Log > Log::mLogger [static, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::LogicOp Class Reference

vl::LogicOp

vl::LogicOp Class Reference

Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::LogicOp:

vl::RenderState vl::Object

List of all members.

Public Member Functions

LogicOp (ELogicOp logicop=LO_COPY)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (ELogicOp logicop)
ELogicOp | logicOp () const

Protected Attributes

ELogicOp mLogicOp

Detailed Description

Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_COLOR_LOGIC_OP

Constructor & Destructor Documentation

vl::LogicOp::LogicOp ( ELogicOp logicop = LO_COPY ) [inline]

Member Function Documentation

virtual const char* vl::LogicOp::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::LogicOp::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void LogicOp::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::LogicOp::set ( ELogicOp logicop ) [inline]

ELogicOp vl::LogicOp::logicOp ( ) const [inline]

Member Data Documentation

ELogicOp vl::LogicOp::mLogicOp [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Material Class Reference

vl::Material

vl::Material Class Reference

Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::Material:

vl::RenderState vl::Object

List of all members.

Public Member Functions

Material ()
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | setTransparency (float alpha)
void | setFrontTransparency (float alpha)
void | setBackTransparency (float alpha)
void | setFrontFlatColor (const fvec4 &color)
void | setBackFlatColor (const fvec4 &color)
void | setFlatColor (const fvec4 &color)
void | setAmbient (fvec4 color)
void | setDiffuse (fvec4 color)
void | setSpecular (fvec4 color)
void | setEmission (fvec4 color)
void | setShininess (float shininess)
void | setFrontAmbient (fvec4 color)
void | setFrontDiffuse (fvec4 color)
void | setFrontSpecular (fvec4 color)
void | setFrontEmission (fvec4 color)
void | setFrontShininess (float shininess)
fvec4 | frontAmbient () const
fvec4 | frontDiffuse () const
fvec4 | frontSpecular () const
fvec4 | frontEmission () const
float | frontShininess () const
void | setBackAmbient (fvec4 color)
void | setBackDiffuse (fvec4 color)
void | setBackSpecular (fvec4 color)
void | setBackEmission (fvec4 color)
void | setBackShininess (float shininess)
fvec4 | backAmbient () const
fvec4 | backDiffuse () const
fvec4 | backSpecular () const
fvec4 | backEmission () const
float | backShininess () const
void | setColorMaterial (EPolygonFace face, EColorMaterial color)
EPolygonFace | colorMaterialFace () const
EColorMaterial | colorMaterial () const
void | setColorMaterialEnabled (bool enabled)
bool | colorMaterialEnabled () const

Protected Attributes

fvec4 mFrontAmbient
fvec4 mFrontDiffuse
fvec4 mFrontSpecular
fvec4 mFrontEmission
fvec4 mBackAmbient
fvec4 mBackDiffuse
fvec4 mBackSpecular
fvec4 mBackEmission
float | mBackShininess
float | mFrontShininess
EPolygonFace mColorMaterialFace
EColorMaterial mColorMaterial
bool | mColorMaterialEnabled

Detailed Description

Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_LIGHTING

Constructor & Destructor Documentation

Material::Material ( )

Member Function Documentation

virtual const char* vl::Material::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::Material::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void Material::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void Material::setTransparency ( float alpha )

void Material::setFrontTransparency ( float alpha )

void Material::setBackTransparency ( float alpha )

void Material::setFrontFlatColor ( const fvec4 & color )

void Material::setBackFlatColor ( const fvec4 & color )

void Material::setFlatColor ( const fvec4 & color )

void vl::Material::setAmbient ( fvec4 color ) [inline]

void vl::Material::setDiffuse ( fvec4 color ) [inline]

void vl::Material::setSpecular ( fvec4 color ) [inline]

void vl::Material::setEmission ( fvec4 color ) [inline]

void vl::Material::setShininess ( float shininess ) [inline]

void vl::Material::setFrontAmbient ( fvec4 color ) [inline]

void vl::Material::setFrontDiffuse ( fvec4 color ) [inline]

void vl::Material::setFrontSpecular ( fvec4 color ) [inline]

void vl::Material::setFrontEmission ( fvec4 color ) [inline]

void vl::Material::setFrontShininess ( float shininess ) [inline]

fvec4 vl::Material::frontAmbient ( ) const [inline]

fvec4 vl::Material::frontDiffuse ( ) const [inline]

fvec4 vl::Material::frontSpecular ( ) const [inline]

fvec4 vl::Material::frontEmission ( ) const [inline]

float vl::Material::frontShininess ( ) const [inline]

void vl::Material::setBackAmbient ( fvec4 color ) [inline]

void vl::Material::setBackDiffuse ( fvec4 color ) [inline]

void vl::Material::setBackSpecular ( fvec4 color ) [inline]

void vl::Material::setBackEmission ( fvec4 color ) [inline]

void vl::Material::setBackShininess ( float shininess ) [inline]

fvec4 vl::Material::backAmbient ( ) const [inline]

fvec4 vl::Material::backDiffuse ( ) const [inline]

fvec4 vl::Material::backSpecular ( ) const [inline]

fvec4 vl::Material::backEmission ( ) const [inline]

float vl::Material::backShininess ( ) const [inline]

void vl::Material::setColorMaterial | ( | EPolygonFace | face,
 |  | EColorMaterial | color |
 | ) |  |  | [inline]

EPolygonFace vl::Material::colorMaterialFace ( ) const [inline]

EColorMaterial vl::Material::colorMaterial ( ) const [inline]

void vl::Material::setColorMaterialEnabled ( bool enabled ) [inline]

bool vl::Material::colorMaterialEnabled ( ) const [inline]

Member Data Documentation

fvec4 vl::Material::mFrontAmbient [protected]

fvec4 vl::Material::mFrontDiffuse [protected]

fvec4 vl::Material::mFrontSpecular [protected]

fvec4 vl::Material::mFrontEmission [protected]

fvec4 vl::Material::mBackAmbient [protected]

fvec4 vl::Material::mBackDiffuse [protected]

fvec4 vl::Material::mBackSpecular [protected]

fvec4 vl::Material::mBackEmission [protected]

float vl::Material::mBackShininess [protected]

float vl::Material::mFrontShininess [protected]

EPolygonFace vl::Material::mColorMaterialFace [protected]

EColorMaterial vl::Material::mColorMaterial [protected]

bool vl::Material::mColorMaterialEnabled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Matrix2< scalar_type > Class Template Reference

vl::Matrix2

vl::Matrix2< scalar_type > Class Template Reference

The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2. More...

#include <Matrix2.hpp>

List of all members.

Public Member Functions

template<typename T >
Matrix2 (const T &m)
Matrix2 ()
Matrix2 (scalar_type n)
Matrix2 (scalar_type e00, scalar_type e01, scalar_type e10, scalar_type e11)
const Vector2< scalar_type > & | operator[] (unsigned int i) const
Vector2< scalar_type > & | operator[] (unsigned int i)
bool | operator== (const Matrix2 &m) const
bool | operator!= (const Matrix2 &m) const
Matrix2 & | operator= (const Matrix2 &m)
Matrix2 | operator+ (const Matrix2 &m) const
Matrix2 & | operator+= (const Matrix2 &m)
Matrix2 | operator- (const Matrix2 &m) const
Matrix2 & | operator-= (const Matrix2 &m)
Matrix2 & | operator*= (const Matrix2 &m)
Matrix2 | operator- () const
Matrix2 | operator+ (scalar_type d) const
Matrix2 & | operator+= (scalar_type d)
Matrix2 | operator- (scalar_type d) const
Matrix2 & | operator-= (scalar_type d)
Matrix2 | operator* (scalar_type d) const
Matrix2 & | operator*= (scalar_type d)
Matrix2 | operator/ (scalar_type d) const
Matrix2 & | operator/= (scalar_type d)
bool | isIdentity () const
scalar_type * | ptr ()
const scalar_type * | ptr () const
Matrix2 & transpose ()
bool | isNull () const
void | setIdentity ()
Matrix2 | inverse (bool *invertible=NULL) const
Matrix2 & | invert (bool *invertible=NULL)
const scalar_type & | e (int i, int j) const
scalar_type & | e (int i, int j)

Protected Attributes

Vector2< scalar_type > | mVec [2]

Detailed Description

template<typename scalar_type>
class vl::Matrix2< scalar_type >

The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2.

See also:
Vector4, Vector3, Vector2, Matrix4, Matrix3

Constructor & Destructor Documentation

template<typename scalar_type >
template<typename T >
vl::Matrix2< scalar_type >::Matrix2 ( const T & m ) [inline, explicit]

template<typename scalar_type >
vl::Matrix2< scalar_type >::Matrix2 ( ) [inline]

template<typename scalar_type >
vl::Matrix2< scalar_type >::Matrix2 ( scalar_type n ) [inline]

template<typename scalar_type >
vl::Matrix2< scalar_type >::Matrix2 | ( | scalar_type | e00,
 |  | scalar_type | e01,
 |  | scalar_type | e10,
 |  | scalar_type | e11 |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type >
const Vector2<scalar_type>& vl::Matrix2< scalar_type >::operator[] ( unsigned int i ) const [inline]

template<typename scalar_type >
Vector2<scalar_type>& vl::Matrix2< scalar_type >::operator[] ( unsigned int i ) [inline]

template<typename scalar_type >
bool vl::Matrix2< scalar_type >::operator== ( const Matrix2< scalar_type > & m ) const [inline]

template<typename scalar_type >
bool vl::Matrix2< scalar_type >::operator!= ( const Matrix2< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator= ( const Matrix2< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator+ ( const Matrix2< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator+= ( const Matrix2< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator- ( const Matrix2< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator-= ( const Matrix2< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator*= ( const Matrix2< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator+ ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator+= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator- ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator-= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator* ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator*= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::operator/ ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::operator/= ( scalar_type d ) [inline]

template<typename scalar_type >
bool vl::Matrix2< scalar_type >::isIdentity ( ) const [inline]

template<typename scalar_type >
scalar_type* vl::Matrix2< scalar_type >::ptr ( ) [inline]

template<typename scalar_type >
const scalar_type* vl::Matrix2< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::transpose ( ) [inline]

template<typename scalar_type >
bool vl::Matrix2< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type >
void vl::Matrix2< scalar_type >::setIdentity ( ) [inline]

template<typename scalar_type >
Matrix2 vl::Matrix2< scalar_type >::inverse ( bool * invertible = NULL ) const [inline]

template<typename scalar_type >
Matrix2& vl::Matrix2< scalar_type >::invert ( bool * invertible = NULL ) [inline]

template<typename scalar_type >
const scalar_type& vl::Matrix2< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | const [inline]

template<typename scalar_type >
scalar_type& vl::Matrix2< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | [inline]

Member Data Documentation

template<typename scalar_type >
Vector2<scalar_type> vl::Matrix2< scalar_type >::mVec[2] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix2.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::Matrix3< scalar_type > Class Template Reference

vl::Matrix3

vl::Matrix3< scalar_type > Class Template Reference

The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3. More...

#include <Matrix3.hpp>

List of all members.

Public Member Functions

template<typename T >
Matrix3 (const T &m)
Matrix3 ()
Matrix3 (scalar_type n)
Matrix3 (scalar_type e00, scalar_type e01, scalar_type e02, scalar_type e10, scalar_type e11, scalar_type e12, scalar_type e20, scalar_type e21, scalar_type e22)
const Vector3< scalar_type > & | operator[] (unsigned int i) const
Vector3< scalar_type > & | operator[] (unsigned int i)
Vector2< scalar_type > | getX () const
Vector2< scalar_type > | getY () const
Vector2< scalar_type > | getT () const
Matrix3 & | setX (const Vector2< scalar_type > &v)
Matrix3 & | setY (const Vector2< scalar_type > &v)
Matrix3 & | setT (const Vector2< scalar_type > &v)
bool | operator== (const Matrix3 &m) const
bool | operator!= (const Matrix3 &m) const
Matrix3 & | operator= (const Matrix3 &m)
Matrix3 | operator+ (const Matrix3 &m) const
Matrix3 & | operator+= (const Matrix3 &m)
Matrix3 | operator- (const Matrix3 &m) const
Matrix3 & | operator-= (const Matrix3 &m)
Matrix3 & | operator*= (const Matrix3 &m)
Matrix3 | operator- () const
Matrix3 | operator+ (scalar_type d) const
Matrix3 & | operator+= (scalar_type d)
Matrix3 | operator- (scalar_type d) const
Matrix3 & | operator-= (scalar_type d)
Matrix3 | operator* (scalar_type d) const
Matrix3 & | operator*= (scalar_type d)
Matrix3 | operator/ (scalar_type d) const
Matrix3 & | operator/= (scalar_type d)
bool | isIdentity () const
Matrix2< scalar_type > | get2x2 () const
void | set2x2 (const Matrix2< scalar_type > &m)
This writes only on the upper 2x2 part of the matrix without touching the last row and column.
scalar_type * | ptr ()
const scalar_type * | ptr () const
Matrix3 & transpose ()
bool | isNull () const
void | setIdentity ()
Matrix3 | inverse (bool *invertible=NULL) const
Matrix3 & | invert (bool *invertible=NULL)
const scalar_type & | e (int i, int j) const
scalar_type & | e (int i, int j)
Matrix3 & | rotate (scalar_type degrees)
Matrix3 & | translate (scalar_type x, scalar_type y)
Matrix3 & | translate (const Vector2< scalar_type > &v)
Matrix3 & | scale (scalar_type x, scalar_type y)

Static Public Member Functions

static Matrix3 | rotation (scalar_type degrees)
static Matrix3 | translation (const Vector2< scalar_type > &v)
static Matrix3 | translation (scalar_type x, scalar_type y)
static Matrix3 | scaling (scalar_type x, scalar_type y)

Protected Attributes

Vector3< scalar_type > | mVec [3]

Detailed Description

template<typename scalar_type>
class vl::Matrix3< scalar_type >

The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3.

See also:
Vector4, Vector3, Vector2, Matrix4, Matrix2

Constructor & Destructor Documentation

template<typename scalar_type >
template<typename T >
vl::Matrix3< scalar_type >::Matrix3 ( const T & m ) [inline, explicit]

template<typename scalar_type >
vl::Matrix3< scalar_type >::Matrix3 ( ) [inline]

template<typename scalar_type >
vl::Matrix3< scalar_type >::Matrix3 ( scalar_type n ) [inline]

template<typename scalar_type >
vl::Matrix3< scalar_type >::Matrix3 | ( | scalar_type | e00,
 |  | scalar_type | e01,
 |  | scalar_type | e02,
 |  | scalar_type | e10,
 |  | scalar_type | e11,
 |  | scalar_type | e12,
 |  | scalar_type | e20,
 |  | scalar_type | e21,
 |  | scalar_type | e22 |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type >
const Vector3<scalar_type>& vl::Matrix3< scalar_type >::operator[] ( unsigned int i ) const [inline]

template<typename scalar_type >
Vector3<scalar_type>& vl::Matrix3< scalar_type >::operator[] ( unsigned int i ) [inline]

template<typename scalar_type >
Vector2<scalar_type> vl::Matrix3< scalar_type >::getX ( ) const [inline]

template<typename scalar_type >
Vector2<scalar_type> vl::Matrix3< scalar_type >::getY ( ) const [inline]

template<typename scalar_type >
Vector2<scalar_type> vl::Matrix3< scalar_type >::getT ( ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::setX ( const Vector2< scalar_type > & v ) [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::setY ( const Vector2< scalar_type > & v ) [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::setT ( const Vector2< scalar_type > & v ) [inline]

template<typename scalar_type >
bool vl::Matrix3< scalar_type >::operator== ( const Matrix3< scalar_type > & m ) const [inline]

template<typename scalar_type >
bool vl::Matrix3< scalar_type >::operator!= ( const Matrix3< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator= ( const Matrix3< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator+ ( const Matrix3< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator+= ( const Matrix3< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator- ( const Matrix3< scalar_type > & m ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator-= ( const Matrix3< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator*= ( const Matrix3< scalar_type > & m ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator+ ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator+= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator- ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator-= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator* ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator*= ( scalar_type d ) [inline]

template<typename scalar_type >
Matrix3 vl::Matrix3< scalar_type >::operator/ ( scalar_type d ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::operator/= ( scalar_type d ) [inline]

template<typename scalar_type >
bool vl::Matrix3< scalar_type >::isIdentity ( ) const [inline]

template<typename scalar_type >
Matrix2<scalar_type> vl::Matrix3< scalar_type >::get2x2 ( ) const [inline]

template<typename scalar_type >
void vl::Matrix3< scalar_type >::set2x2 ( const Matrix2< scalar_type > & m ) [inline]

This writes only on the upper 2x2 part of the matrix without touching the last row and column.

template<typename scalar_type >
scalar_type* vl::Matrix3< scalar_type >::ptr ( ) [inline]

template<typename scalar_type >
const scalar_type* vl::Matrix3< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::transpose ( ) [inline]

template<typename scalar_type >
bool vl::Matrix3< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type >
void vl::Matrix3< scalar_type >::setIdentity ( ) [inline]

template<typename scalar_type >
Matrix3< scalar_type > vl::Matrix3< scalar_type >::inverse ( bool * invertible = NULL ) const [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::invert ( bool * invertible = NULL ) [inline]

template<typename scalar_type >
const scalar_type& vl::Matrix3< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | const [inline]

template<typename scalar_type >
scalar_type& vl::Matrix3< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix3< scalar_type > vl::Matrix3< scalar_type >::rotation ( scalar_type degrees ) [inline, static]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::rotate ( scalar_type degrees ) [inline]

template<typename scalar_type >
static Matrix3 vl::Matrix3< scalar_type >::translation ( const Vector2< scalar_type > & v ) [inline, static]

template<typename scalar_type >
static Matrix3 vl::Matrix3< scalar_type >::translation | ( | scalar_type | x,
 |  | scalar_type | y |
 | ) |  |  | [inline, static]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::translate | ( | scalar_type | x,
 |  | scalar_type | y |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::translate ( const Vector2< scalar_type > & v ) [inline]

template<typename scalar_type >
static Matrix3 vl::Matrix3< scalar_type >::scaling | ( | scalar_type | x,
 |  | scalar_type | y |
 | ) |  |  | [inline, static]

template<typename scalar_type >
Matrix3& vl::Matrix3< scalar_type >::scale | ( | scalar_type | x,
 |  | scalar_type | y |
 | ) |  |  | [inline]

Member Data Documentation

template<typename scalar_type >
Vector3<scalar_type> vl::Matrix3< scalar_type >::mVec[3] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix3.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::Matrix4< scalar_type > Class Template Reference

vl::Matrix4

vl::Matrix4< scalar_type > Class Template Reference

The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4. More...

#include <Matrix4.hpp>

List of all members.

Public Member Functions

template<typename T >
Matrix4 (const T &m)
Matrix4 ()
Matrix4 (scalar_type n)
Matrix4 (scalar_type e00, scalar_type e01, scalar_type e02, scalar_type e03, scalar_type e10, scalar_type e11, scalar_type e12, scalar_type e13, scalar_type e20, scalar_type e21, scalar_type e22, scalar_type e23, scalar_type e30, scalar_type e31, scalar_type e32, scalar_type e33)
const scalar_type & | e (unsigned i, unsigned j) const
scalar_type & | e (unsigned i, unsigned j)
const Vector4< scalar_type > & | operator[] (unsigned int i) const
Vector4< scalar_type > & | operator[] (unsigned int i)
Vector3< scalar_type > | getX () const
Vector3< scalar_type > | getY () const
Vector3< scalar_type > | getZ () const
Vector3< scalar_type > | getT () const
Matrix4 & | setX (const Vector3< scalar_type > &v)
Matrix4 & | setY (const Vector3< scalar_type > &v)
Matrix4 & | setZ (const Vector3< scalar_type > &v)
Matrix4 & | setT (const Vector3< scalar_type > &v)
bool | operator== (const Matrix4 &m) const
bool | operator!= (const Matrix4 &m) const
Matrix4 & | operator= (const Matrix4 &m)
Matrix4 | operator+ (const Matrix4 &m) const
Matrix4 & | operator+= (const Matrix4 &m)
Matrix4 | operator- (const Matrix4 &m) const
Matrix4 & | operator-= (const Matrix4 &m)
Matrix4 & | operator*= (const Matrix4 &m)
Matrix4 | operator- () const
Matrix4 | operator+ (scalar_type d) const
Matrix4 & | operator+= (scalar_type d)
Matrix4 | operator- (scalar_type d) const
Matrix4 & | operator-= (scalar_type d)
Matrix4 | operator* (scalar_type d) const
Matrix4 & | operator*= (scalar_type d)
Matrix4 | operator/ (scalar_type d) const
Matrix4 & | operator/= (scalar_type d)
bool | isIdentity () const
Matrix4 | as3x3 () const
Matrix3< scalar_type > | get3x3 () const
void | set3x3 (const Matrix3< scalar_type > &m)
This writes only on the upper 3x3 part of the matrix without touching the last row and column.
scalar_type * | ptr ()
const scalar_type * | ptr () const
Matrix4 & transpose ()
bool | isNull () const
void | setIdentity ()
Matrix4 | inverse (bool *invertible=NULL) const
Matrix4 & | invert (bool *invertible=NULL)
const scalar_type & | e (int i, int j) const
scalar_type & | e (int i, int j)
void | getAsLookAt (Vector3< scalar_type > &eye, Vector3< scalar_type > &look, Vector3< scalar_type > &up, Vector3< scalar_type > &right) const
Matrix4 & | rotate (scalar_type degrees, const Vector3< scalar_type > &v)
Matrix4 & | rotate (scalar_type degrees, scalar_type x, scalar_type y, scalar_type z)
Matrix4 & | rotate (scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2)
void | getYXRotationAngles (scalar_type &degrees_y, scalar_type &degrees_x) const
If this matrix can be represented as RY(degrees_y) * RX(degrees_x), where RX and RY are rotation matrices around the X and Y axis respectively, this function returns the rotation angles degrees_y and degrees_x.
Matrix4 & | rotate (scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2, scalar_type degrees3, const Vector3< scalar_type > &v3)
Matrix4 & | rotateXYZ (scalar_type degX, scalar_type degY, scalar_type degZ)
Matrix4 & | rotateZYX (scalar_type degZ, scalar_type degY, scalar_type degX)
Matrix4 & | rotate (const Vector4< scalar_type > &from, const Vector4< scalar_type > &to)
Matrix4 & | rotate (const Vector3< scalar_type > &from, const Vector3< scalar_type > &to)
Matrix4 & | translate (scalar_type x, scalar_type y, scalar_type z)
Matrix4 & | translate (const Vector3< scalar_type > &v)
Matrix4 & | scale (scalar_type x, scalar_type y, scalar_type z)

Static Public Member Functions

static Matrix4 | perspective (scalar_type fovy, scalar_type aspect_ratio, scalar_type znear, scalar_type zfar)
static Matrix4 | frustum (scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop, scalar_type pnear, scalar_type pfar)
static Matrix4 | ortho (scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop, scalar_type pnear, scalar_type pfar)
static Matrix4 | ortho2D (scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop)
static Matrix4 | lookAt (const Vector3< scalar_type > &eye, const Vector3< scalar_type > &look, const Vector3< scalar_type > &up)
static Matrix4 | rotation (scalar_type degrees, scalar_type x, scalar_type y, scalar_type z)
static Matrix4 | rotation (scalar_type degrees, const Vector3< scalar_type > &v)
static Matrix4 | rotation (scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2)
static Matrix4 | rotation (scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2, scalar_type degrees3, const Vector3< scalar_type > &v3)
static Matrix4 | rotationXYZ (scalar_type degX, scalar_type degY, scalar_type degZ)
static Matrix4 | rotationZYX (scalar_type degZ, scalar_type degY, scalar_type degX)
static Matrix4 | rotation (const Vector4< scalar_type > &from, const Vector4< scalar_type > &to)
static Matrix4 | rotation (const Vector3< scalar_type > &from, const Vector3< scalar_type > &to)
static Matrix4 | translation (const Vector3< scalar_type > &v)
static Matrix4 | translation (scalar_type x, scalar_type y, scalar_type z)
static Matrix4 | scaling (const Vector3< scalar_type > &v)
static Matrix4 | scaling (scalar_type x, scalar_type y, scalar_type z)

Protected Attributes

Vector4< scalar_type > | mVec [4]

Detailed Description

template<typename scalar_type>
class vl::Matrix4< scalar_type >

The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4.

See also:
Vector4, Vector3, Vector2, Matrix3, Matrix2

Constructor & Destructor Documentation

template<typename scalar_type>
template<typename T >
vl::Matrix4< scalar_type >::Matrix4 ( const T & m ) [inline, explicit]

template<typename scalar_type>
vl::Matrix4< scalar_type >::Matrix4 ( ) [inline]

template<typename scalar_type>
vl::Matrix4< scalar_type >::Matrix4 ( scalar_type n ) [inline]

template<typename scalar_type>
vl::Matrix4< scalar_type >::Matrix4 | ( | scalar_type | e00,
 |  | scalar_type | e01,
 |  | scalar_type | e02,
 |  | scalar_type | e03,
 |  | scalar_type | e10,
 |  | scalar_type | e11,
 |  | scalar_type | e12,
 |  | scalar_type | e13,
 |  | scalar_type | e20,
 |  | scalar_type | e21,
 |  | scalar_type | e22,
 |  | scalar_type | e23,
 |  | scalar_type | e30,
 |  | scalar_type | e31,
 |  | scalar_type | e32,
 |  | scalar_type | e33 |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type>
const scalar_type& vl::Matrix4< scalar_type >::e | ( | unsigned | i,
 |  | unsigned | j |
 | ) |  |  | const [inline]

template<typename scalar_type>
scalar_type& vl::Matrix4< scalar_type >::e | ( | unsigned | i,
 |  | unsigned | j |
 | ) |  |  | [inline]

template<typename scalar_type>
const Vector4<scalar_type>& vl::Matrix4< scalar_type >::operator[] ( unsigned int i ) const [inline]

template<typename scalar_type>
Vector4<scalar_type>& vl::Matrix4< scalar_type >::operator[] ( unsigned int i ) [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Matrix4< scalar_type >::getX ( ) const [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Matrix4< scalar_type >::getY ( ) const [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Matrix4< scalar_type >::getZ ( ) const [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Matrix4< scalar_type >::getT ( ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::setX ( const Vector3< scalar_type > & v ) [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::setY ( const Vector3< scalar_type > & v ) [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::setZ ( const Vector3< scalar_type > & v ) [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::setT ( const Vector3< scalar_type > & v ) [inline]

template<typename scalar_type>
bool vl::Matrix4< scalar_type >::operator== ( const Matrix4< scalar_type > & m ) const [inline]

template<typename scalar_type>
bool vl::Matrix4< scalar_type >::operator!= ( const Matrix4< scalar_type > & m ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator= ( const Matrix4< scalar_type > & m ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator+ ( const Matrix4< scalar_type > & m ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator+= ( const Matrix4< scalar_type > & m ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator- ( const Matrix4< scalar_type > & m ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator-= ( const Matrix4< scalar_type > & m ) [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator*= ( const Matrix4< scalar_type > & m ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator+ ( scalar_type d ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator+= ( scalar_type d ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator- ( scalar_type d ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator-= ( scalar_type d ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator* ( scalar_type d ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator*= ( scalar_type d ) [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::operator/ ( scalar_type d ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::operator/= ( scalar_type d ) [inline]

template<typename scalar_type>
bool vl::Matrix4< scalar_type >::isIdentity ( ) const [inline]

template<typename scalar_type>
Matrix4 vl::Matrix4< scalar_type >::as3x3 ( ) const [inline]

template<typename scalar_type>
Matrix3<scalar_type> vl::Matrix4< scalar_type >::get3x3 ( ) const [inline]

template<typename scalar_type>
void vl::Matrix4< scalar_type >::set3x3 ( const Matrix3< scalar_type > & m ) [inline]

This writes only on the upper 3x3 part of the matrix without touching the last row and column.

template<typename scalar_type>
scalar_type* vl::Matrix4< scalar_type >::ptr ( ) [inline]

template<typename scalar_type>
const scalar_type* vl::Matrix4< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::transpose ( ) [inline]

template<typename scalar_type>
bool vl::Matrix4< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type>
void vl::Matrix4< scalar_type >::setIdentity ( ) [inline]

template<typename scalar_type >
Matrix4< scalar_type > vl::Matrix4< scalar_type >::inverse ( bool * invertible = NULL ) const [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::invert ( bool * invertible = NULL ) [inline]

template<typename scalar_type>
const scalar_type& vl::Matrix4< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | const [inline]

template<typename scalar_type>
scalar_type& vl::Matrix4< scalar_type >::e | ( | int | i,
 |  | int | j |
 | ) |  |  | [inline]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::perspective | ( | scalar_type | fovy,
 |  | scalar_type | aspect_ratio,
 |  | scalar_type | znear,
 |  | scalar_type | zfar |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::frustum | ( | scalar_type | pleft,
 |  | scalar_type | pright,
 |  | scalar_type | pbottom,
 |  | scalar_type | ptop,
 |  | scalar_type | pnear,
 |  | scalar_type | pfar |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::ortho | ( | scalar_type | pleft,
 |  | scalar_type | pright,
 |  | scalar_type | pbottom,
 |  | scalar_type | ptop,
 |  | scalar_type | pnear,
 |  | scalar_type | pfar |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::ortho2D | ( | scalar_type | pleft,
 |  | scalar_type | pright,
 |  | scalar_type | pbottom,
 |  | scalar_type | ptop |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::lookAt | ( | const Vector3< scalar_type > & | eye,
 |  | const Vector3< scalar_type > & | look,
 |  | const Vector3< scalar_type > & | up |
 | ) |  |  | [inline, static]

template<typename scalar_type>
void vl::Matrix4< scalar_type >::getAsLookAt | ( | Vector3< scalar_type > & | eye,
 |  | Vector3< scalar_type > & | look,
 |  | Vector3< scalar_type > & | up,
 |  | Vector3< scalar_type > & | right |
 | ) |  |  | const [inline]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::rotation | ( | scalar_type | degrees,
 |  | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline, static]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotation | ( | scalar_type | degrees,
 |  | const Vector3< scalar_type > & | v |
 | ) |  |  | [inline, static]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotation | ( | scalar_type | degrees1,
 |  | const Vector3< scalar_type > & | v1,
 |  | scalar_type | degrees2,
 |  | const Vector3< scalar_type > & | v2 |
 | ) |  |  | [inline, static]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotation | ( | scalar_type | degrees1,
 |  | const Vector3< scalar_type > & | v1,
 |  | scalar_type | degrees2,
 |  | const Vector3< scalar_type > & | v2,
 |  | scalar_type | degrees3,
 |  | const Vector3< scalar_type > & | v3 |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | scalar_type | degrees,
 |  | const Vector3< scalar_type > & | v |
 | ) |  |  | [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | scalar_type | degrees,
 |  | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | scalar_type | degrees1,
 |  | const Vector3< scalar_type > & | v1,
 |  | scalar_type | degrees2,
 |  | const Vector3< scalar_type > & | v2 |
 | ) |  |  | [inline]

template<typename scalar_type>
void vl::Matrix4< scalar_type >::getYXRotationAngles | ( | scalar_type & | degrees_y,
 |  | scalar_type & | degrees_x |
 | ) |  |  | const [inline]

If this matrix can be represented as RY(degrees_y) * RX(degrees_x), where RX and RY are rotation matrices around the X and Y axis respectively, this function returns the rotation angles degrees_y and degrees_x.

Note:
This function can only retrieve angles that satisfy the following conditions:
  • -180 <= degrees_y <= 180
  • -180 <= degrees_x <= 180 and degrees_x != 90

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | scalar_type | degrees1,
 |  | const Vector3< scalar_type > & | v1,
 |  | scalar_type | degrees2,
 |  | const Vector3< scalar_type > & | v2,
 |  | scalar_type | degrees3,
 |  | const Vector3< scalar_type > & | v3 |
 | ) |  |  | [inline]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotationXYZ | ( | scalar_type | degX,
 |  | scalar_type | degY,
 |  | scalar_type | degZ |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotateXYZ | ( | scalar_type | degX,
 |  | scalar_type | degY,
 |  | scalar_type | degZ |
 | ) |  |  | [inline]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotationZYX | ( | scalar_type | degZ,
 |  | scalar_type | degY,
 |  | scalar_type | degX |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotateZYX | ( | scalar_type | degZ,
 |  | scalar_type | degY,
 |  | scalar_type | degX |
 | ) |  |  | [inline]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::rotation | ( | const Vector4< scalar_type > & | from,
 |  | const Vector4< scalar_type > & | to |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4< scalar_type > vl::Matrix4< scalar_type >::rotation | ( | const Vector3< scalar_type > & | from,
 |  | const Vector3< scalar_type > & | to |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | const Vector4< scalar_type > & | from,
 |  | const Vector4< scalar_type > & | to |
 | ) |  |  | [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::rotate | ( | const Vector3< scalar_type > & | from,
 |  | const Vector3< scalar_type > & | to |
 | ) |  |  | [inline]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::translation ( const Vector3< scalar_type > & v ) [inline, static]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::translation | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::translate | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::translate ( const Vector3< scalar_type > & v ) [inline]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::scaling ( const Vector3< scalar_type > & v ) [inline, static]

template<typename scalar_type>
static Matrix4 vl::Matrix4< scalar_type >::scaling | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline, static]

template<typename scalar_type>
Matrix4& vl::Matrix4< scalar_type >::scale | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline]

Member Data Documentation

template<typename scalar_type>
Vector4<scalar_type> vl::Matrix4< scalar_type >::mVec[4] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix4.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::MD5CheckSum Class Reference

vl::MD5CheckSum

vl::MD5CheckSum Class Reference

Computes the MD5 of a given buffer or VirtualFile. More...

#include <MD5CheckSum.hpp>

List of all members.

Public Member Functions

MD5CheckSum ()
virtual const char * | className ()
const unsigned char * | md5 () const
std::string | toStdString () const
void | compute (void *buffer, int len)
void | compute (VirtualFile *file)
bool | operator== (const MD5CheckSum &other) const
bool | operator!= (const MD5CheckSum &other) const
bool | operator< (const MD5CheckSum &other) const

Protected Attributes

unsigned char | mMD5 [16]

Detailed Description

Computes the MD5 of a given buffer or VirtualFile.

Constructor & Destructor Documentation

vl::MD5CheckSum::MD5CheckSum ( ) [inline]

Member Function Documentation

virtual const char* vl::MD5CheckSum::className ( ) [inline, virtual]

const unsigned char* vl::MD5CheckSum::md5 ( ) const [inline]

std::string MD5CheckSum::toStdString ( ) const

void MD5CheckSum::compute | ( | void * | buffer,
 |  | int | len
 | ) |  |

void MD5CheckSum::compute ( VirtualFile * file )

bool vl::MD5CheckSum::operator== ( const MD5CheckSum & other ) const [inline]

bool vl::MD5CheckSum::operator!= ( const MD5CheckSum & other ) const [inline]

bool vl::MD5CheckSum::operator< ( const MD5CheckSum & other ) const [inline]

Member Data Documentation

unsigned char vl::MD5CheckSum::mMD5[16] [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::MemoryDirectory Class Reference

vl::MemoryDirectory

vl::MemoryDirectory Class Reference

A VirtualDirectory to manipulate directories stored in memory. More...

#include <MemoryDirectory.hpp>

Inheritance diagram for vl::MemoryDirectory:

vl::VirtualDirectory vl::Object

List of all members.

Public Member Functions

MemoryDirectory (const String &path=".")
virtual const char * | className ()
Returns the name of the class.
virtual bool | setPath (const String &name)
Changes the path name of a VirtualDirectory. Must not be an empty string.
bool | addFile (MemoryFile *file)
The string file->path() must contain the full path including the MemoryDirectory's path().
bool | removeFile (MemoryFile *file)
The string file->path() must contain the full path including the MemoryDirectory's path().
bool | removeFile (const String &name)
void | eraseAllFiles ()
virtual ref< VirtualFile > | file (const String &name) const
Returns the VirtualFile with the given name if any, NULL otherwise.
ref< MemoryFile > | memoryFile (const String &name) const
void | listFilesRecursive (std::vector< String > &file_list) const
Returns the list of files contained in the VirtualDirectory.
void | listSubDirs (std::vector< String > &dirs, bool append=false) const
ref< MemoryDirectory > | memorySubDir (const String &subdir_name) const
ref< VirtualDirectory > | subDir (const String &subdir_name) const
void | listFiles (std::vector< String > &file_list, bool append=false) const
void | clone (VirtualDirectory *directory, const String &match="*")
Clones the content of another directory (empty directories are never cloned).

Protected Attributes

std::map< String, ref
< MemoryFile > > 		mFiles

Detailed Description

A VirtualDirectory to manipulate directories stored in memory.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • ZippedFile

Constructor & Destructor Documentation

vl::MemoryDirectory::MemoryDirectory ( const String & path = "." ) [inline]

Member Function Documentation

virtual const char* vl::MemoryDirectory::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualDirectory.

bool MemoryDirectory::setPath ( const String & path ) [virtual]

Changes the path name of a VirtualDirectory. Must not be an empty string.

Reimplemented from vl::VirtualDirectory.

bool MemoryDirectory::addFile ( MemoryFile * file )

The string file->path() must contain the full path including the MemoryDirectory's path().

bool MemoryDirectory::removeFile ( MemoryFile * file )

The string file->path() must contain the full path including the MemoryDirectory's path().

bool MemoryDirectory::removeFile ( const String & name )

void vl::MemoryDirectory::eraseAllFiles ( ) [inline]

virtual ref<VirtualFile> vl::MemoryDirectory::file ( const String & name ) const [inline, virtual]

Returns the VirtualFile with the given name if any, NULL otherwise.

Implements vl::VirtualDirectory.

ref< MemoryFile > MemoryDirectory::memoryFile ( const String & name ) const

void MemoryDirectory::listFilesRecursive ( std::vector< String > & file_list ) const [virtual]

Returns the list of files contained in the VirtualDirectory.

If there are subdirectories the files will be searched recursively.

Implements vl::VirtualDirectory.

void MemoryDirectory::listSubDirs | ( | std::vector< String > & | dirs,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

ref< MemoryDirectory > MemoryDirectory::memorySubDir ( const String & subdir_name ) const

ref<VirtualDirectory> vl::MemoryDirectory::subDir ( const String & subdir_name ) const [inline, virtual]

Implements vl::VirtualDirectory.

void MemoryDirectory::listFiles | ( | std::vector< String > & | file_list,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

void MemoryDirectory::clone | ( | VirtualDirectory * | directory,
 |  | const String & | match = "*"
 | ) |  |

Clones the content of another directory (empty directories are never cloned).

Member Data Documentation

std::map< String, ref<MemoryFile> > vl::MemoryDirectory::mFiles [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::MemoryFile Class Reference

vl::MemoryFile

vl::MemoryFile Class Reference

A VirtualFile to manipulate files stored in memory. More...

#include <MemoryFile.hpp>

Inheritance diagram for vl::MemoryFile:

vl::VirtualFile vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
MemoryFile ()
const Buffer * | buffer () const
Buffer * buffer ()
void | setBuffer (Buffer *buffer)
This is useful when you want to point more MemoryFiles to the same Buffer object.
unsigned char * | ptr ()
virtual bool | exists () const
A MemoryFile always exists.
virtual bool | open (EOpenMode mode)
virtual bool | isOpen () const
virtual void | close ()
void | allocateBuffer (long long byte_count)
virtual long long | size () const
void | copy (VirtualFile *file)
Copies the data of any kind of VirtualFile.
MemoryFile & | operator= (const MemoryFile &other)
ref< VirtualFile > | clone () const

Protected Member Functions

virtual long long | position_Implementation () const
virtual long long | read_Implementation (void *buffer, long long byte_count)
virtual long long | write_Implementation (const void *, long long)
virtual bool | seekSet_Implementation (long long offset)

Protected Attributes

ref< Buffer > mBuffer
long long | mPtr
bool | mIsOpen

Detailed Description

A VirtualFile to manipulate files stored in memory.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • ZippedFile

Constructor & Destructor Documentation

MemoryFile::MemoryFile ( )

Member Function Documentation

virtual const char* vl::MemoryFile::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualFile.

const Buffer* vl::MemoryFile::buffer ( ) const [inline]

Buffer* vl::MemoryFile::buffer ( ) [inline]

void vl::MemoryFile::setBuffer ( Buffer * buffer ) [inline]

This is useful when you want to point more MemoryFiles to the same Buffer object.

unsigned char* vl::MemoryFile::ptr ( ) [inline]

virtual bool vl::MemoryFile::exists ( ) const [inline, virtual]

A MemoryFile always exists.

Implements vl::VirtualFile.

bool MemoryFile::open ( EOpenMode mode ) [virtual]

Implements vl::VirtualFile.

virtual bool vl::MemoryFile::isOpen ( ) const [inline, virtual]

Implements vl::VirtualFile.

virtual void vl::MemoryFile::close ( ) [inline, virtual]

Implements vl::VirtualFile.

void vl::MemoryFile::allocateBuffer ( long long byte_count ) [inline]

virtual long long vl::MemoryFile::size ( ) const [inline, virtual]

Implements vl::VirtualFile.

void MemoryFile::copy ( VirtualFile * file )

Copies the data of any kind of VirtualFile.

MemoryFile& vl::MemoryFile::operator= ( const MemoryFile & other ) [inline]

ref< VirtualFile > MemoryFile::clone ( ) const [virtual]

Implements vl::VirtualFile.

long long MemoryFile::position_Implementation ( ) const [protected, virtual]

Implements vl::VirtualFile.

long long MemoryFile::read_Implementation | ( | void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

virtual long long vl::MemoryFile::write_Implementation | ( | const void * | ,
 |  | long long |  |
 | ) |  |  | [inline, protected, virtual]

Implements vl::VirtualFile.

bool MemoryFile::seekSet_Implementation ( long long offset ) [protected, virtual]

Implements vl::VirtualFile.

Member Data Documentation

ref<Buffer> vl::MemoryFile::mBuffer [protected]

long long vl::MemoryFile::mPtr [protected]

bool vl::MemoryFile::mIsOpen [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::MorphingActor Class Reference

vl::MorphingActor

vl::MorphingActor Class Reference

The MorphingActor class animates a Geometry by interpolating its position and normal array. More...

#include <MorphingActor.hpp>

Inheritance diagram for vl::MorphingActor:

vl::Actor vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
MorphingActor ()
void | init (ResourceDatabase *res_db)
Initializes a MorphingActor from a ResourceDatabase.
void | blendFrames (int a, int b, float t)
virtual void | update (int lod, Camera *, Real delta_t)
Virtual function used to update or animate an Actor during the rendering.
void | setAnimation (int start, int end, float period)
void | startAnimation (Real time=-1)
void | stopAnimation ()
void | initFrom (MorphingActor *morph_act)
void | resetGLSLBindings ()
bool | glslVertexBlendEnabled () const
void | setGLSLVertexBlendEnabled (bool enable)
Geometry * geometry ()
const Geometry * | geometry () const
bool | animationStarted () const

Public Attributes

ref< Geometry > mGeometry
ref< ArrayFVec3 > mVertices
ref< ArrayFVec3 > mNormals
std::vector< ref< ArrayFVec3 > > | mVertexFrames
std::vector< ref< ArrayFVec3 > > | mNormalFrames

Protected Attributes

Real mLastUpdate
Real mElapsedTime
Real mAnimationStartTime
int | mAnimationStart
int | mAnimationEnd
float | mAnimationPeriod
bool | mAnimationStarted
int | mFrame1
int | mFrame2
bool | mGLSLVertexBlendEnabled
int | mVertex2_Binding
int | mNormal2_Binding
int | mAnim_t_Binding
float | mAnim_t

Friends

class | MorphingCallback

Detailed Description

The MorphingActor class animates a Geometry by interpolating its position and normal array.

Constructor & Destructor Documentation

MorphingActor::MorphingActor ( )

Member Function Documentation

virtual const char* vl::MorphingActor::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Actor.

void MorphingActor::init ( ResourceDatabase * res_db )

Initializes a MorphingActor from a ResourceDatabase.

The given ResourceDatabase must contain a Geometry with all the desired DrawCalls and vertex attributes setup with the exception of the vertex position array and vertex normal array since they are automatically generated in realtime time during the rendering from the vertex and normal frames specified below. In addition ResourceDatabase must contain:

  • N ArrayFVec3 objects named 'vertex_frame' containing the vertex position for every frame
  • N ArrayFVec3 objects named 'normal_frame' containing the vertex normal for every frame where N is the number of animation frames.

void MorphingActor::blendFrames | ( | int | a,
 |  | int | b,
 |  | float | t
 | ) |  |

void MorphingActor::update | ( | int | ,
 |  | Camera * | ,
 |  | Real |  |
 | ) |  |  | [virtual]

Virtual function used to update or animate an Actor during the rendering.

Parameters:
lod | the LOD (level of detail) currently selected for the rendering.
camera | the camera used for the current rendering.
cur_t | the current animation time.
Note:
  • is called after the actor resulted to be visible
  • is called only once per frame
  • is called before setting up the rendering states
See also:
  • ActorRenderingCallback
  • renderingCallbacks()

Reimplemented from vl::Actor.

void MorphingActor::setAnimation | ( | int | start,
 |  | int | end,
 |  | float | period
 | ) |  |

void MorphingActor::startAnimation ( Real time = -1 )

void MorphingActor::stopAnimation ( )

void MorphingActor::initFrom ( MorphingActor * morph_act )

void MorphingActor::resetGLSLBindings ( )

bool vl::MorphingActor::glslVertexBlendEnabled ( ) const [inline]

void vl::MorphingActor::setGLSLVertexBlendEnabled ( bool enable ) [inline]

Geometry* vl::MorphingActor::geometry ( ) [inline]

const Geometry* vl::MorphingActor::geometry ( ) const [inline]

bool vl::MorphingActor::animationStarted ( ) const [inline]

Friends And Related Function Documentation

friend class MorphingCallback [friend]

Member Data Documentation

ref<Geometry> vl::MorphingActor::mGeometry

ref<ArrayFVec3> vl::MorphingActor::mVertices

ref<ArrayFVec3> vl::MorphingActor::mNormals

std::vector< ref<ArrayFVec3> > vl::MorphingActor::mVertexFrames

std::vector< ref<ArrayFVec3> > vl::MorphingActor::mNormalFrames

Real vl::MorphingActor::mLastUpdate [protected]

Real vl::MorphingActor::mElapsedTime [protected]

Real vl::MorphingActor::mAnimationStartTime [protected]

int vl::MorphingActor::mAnimationStart [protected]

int vl::MorphingActor::mAnimationEnd [protected]

float vl::MorphingActor::mAnimationPeriod [protected]

bool vl::MorphingActor::mAnimationStarted [protected]

int vl::MorphingActor::mFrame1 [protected]

int vl::MorphingActor::mFrame2 [protected]

bool vl::MorphingActor::mGLSLVertexBlendEnabled [protected]

int vl::MorphingActor::mVertex2_Binding [protected]

int vl::MorphingActor::mNormal2_Binding [protected]

int vl::MorphingActor::mAnim_t_Binding [protected]

float vl::MorphingActor::mAnim_t [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::MorphingCallback Class Reference

vl::MorphingCallback

vl::MorphingCallback Class Reference

The MorphingCallback class is used by MorphingActor to implement the morphing animation on the GPU. More...

#include <MorphingActor.hpp>

Inheritance diagram for vl::MorphingCallback:

vl::ActorRenderingCallback vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
virtual void | operator() (const Camera *cam, Actor *actor, Renderable *renderable, const Shader *, int pass)
Called upon callback execution.

Detailed Description

The MorphingCallback class is used by MorphingActor to implement the morphing animation on the GPU.

Member Function Documentation

virtual const char* vl::MorphingCallback::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void MorphingCallback::operator() | ( | const Camera * | cam,
 |  | Actor * | actor,
 |  | Renderable * | renderable,
 |  | const Shader * | shader,
 |  | int | pass |
 | ) |  |  | [virtual]

Called upon callback execution.

Parameters:
cam | The camera used for the current rendering.
actor | The Actor bound to this rendering callback.
renderable | The currently selected Actor LOD.
shader | The currently active Shader.
pass | The current Actor[s] rendering pass.

Implements vl::ActorRenderingCallback.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::Object Class Reference

vl::Object

vl::Object Class Reference

The base class for all the reference counted objects. More...

#include <Object.hpp>

Inheritance diagram for vl::Object:

vl::BufferedStream< unsigned char, 128 *1024 > vl::Collection< Shader > vl::Actor vl::ActorRenderingCallback vl::ActorTreeAbstract vl::ArrayAbstract vl::BezierPatch vl::Buffer vl::BufferedStream< Element_Type, Chunk_Size > vl::Camera vl::CatmullRomInterpolator< T > vl::Collection< T > vl::DrawPixels::Pixels vl::EdgeExtractor vl::Effect vl::EnableSet vl::Extrusion vl::FBOAttachmentAbstract vl::FileSystem vl::Font vl::FontManager vl::Frustum vl::GLSLShader vl::Glyph vl::Image vl::Interpolator vl::KeyValues vl::LinearInterpolator< T > vl::LoadCallback vl::LoadWriterManager vl::LODEvaluator vl::Log vl::ObjMaterial vl::ObjMesh vl::OpenGLContext vl::Plane vl::PlyLoader::PlyElement vl::PlyLoader::PlyPropertyAbstract vl::PolygonSimplifier vl::Portal vl::Primitives vl::RayIntersection vl::RayIntersector vl::Renderable vl::Renderer vl::RenderingAbstract vl::RenderingCallback vl::RenderQueue vl::RenderQueueSorter vl::RenderState vl::RenderStateSet vl::RenderTarget vl::RenderToken vl::ResourceDatabase vl::ResourceLoadWriter vl::SceneManager vl::Scissor vl::Sector vl::Sector::VisibilityCallback vl::Shader vl::ShaderNode vl::Tessellator vl::TexParameter vl::Texture vl::Texture::SetupParams vl::Time vl::Transform vl::UIEventListener vl::Uniform vl::UniformSet vl::VertexAttributeArray vl::VertexMapper vl::Viewport vl::VirtualDirectory vl::VirtualFile vl::WriteCallback vl::ZippedFileInfo vlMolecule::Atom vlMolecule::Bond vlMolecule::Molecule vlVG::VectorGraphics vlVolume::Volume vlVolume::VolumeInfo vlVolume::VolumePlot

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Object ()
Object (const Object &other)
Object & | operator= (const Object &other)
const std::string & | name () const
void | setName (const std::string &name)
int | referenceCount () const
void | incReference ()
void | decReference ()
void | setAutomaticDelete (bool autodel_on)
If set to true the Object is deleted when its reference count reaches 0.
bool | automaticDelete () const
If set to true the Object is deleted when its reference count reaches 0.
template<class T >
T * | as ()
Casts an Object to the specified class.
template<class T >
const T * | as () const
Casts an Object to the specified class.

Protected Member Functions

virtual | ~Object ()

Protected Attributes

std::string | mName

Detailed Description

The base class for all the reference counted objects.

See also vl::ref.

Constructor & Destructor Documentation

vl::Object::Object ( ) [inline]

vl::Object::Object ( const Object & other ) [inline]

Object::~Object ( ) [protected, virtual]

Member Function Documentation

virtual const char* vl::Object::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented in vl::Actor, vl::ActorKdTree, vl::ActorTree, vl::ActorTreeAbstract, vl::ArrayAbstract, vl::Array< vector_type, scalar_type, gl_size, gl_type >, vl::BezierPatch, vl::BezierSurface, vl::Billboard, vl::BlitFramebuffer, vl::Buffer, vl::BufferedStream< Element_Type, Chunk_Size >, vl::Camera, vl::Clear, vl::ClipPlane, vl::Collection< T >, vl::CopyTexSubImage1D, vl::CopyTexSubImage2D, vl::CopyTexSubImage3D, vl::DepthSortCallback, vl::DiskDirectory, vl::DiskFile, vl::DistanceLODEvaluator, vl::VertexMapper, vl::DoubleVertexRemover, vl::DrawArrays, vl::DrawElements< index_type, Tgltype, arr_type >, vl::DrawPixels, vl::EdgeExtractor, vl::EdgeRenderer, vl::EdgeUpdateCallback, vl::ShaderSequence, vl::Effect, vl::FileSystem, vl::Glyph, vl::Font, vl::FontManager, vl::FBOAttachmentAbstract, vl::FBORenderbufferAttachment, vl::FBOColorBufferAttachment, vl::FBODepthBufferAttachment, vl::FBOStencilBufferAttachment, vl::FBODepthStencilBufferAttachment, vl::FBOTexture1DAttachment, vl::FBOTexture2DAttachment, vl::FBOTextureAttachment, vl::FBOTexture3DAttachment, vl::FBOTextureLayerAttachment, vl::FBORenderTarget, vl::Frustum, vl::Geometry, vl::GeometryLoadCallback, vl::GhostCameraManipulator, vl::GLBufferObject, vl::GLSLShader, vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader, vl::GLSLProgram, vl::GZipCodec, vl::Image, vl::Light, vl::LoadWriterManager, vl::LODEvaluator, vl::Log, vl::StandardLog, vl::MemoryDirectory, vl::MemoryFile, vl::MorphingCallback, vl::MorphingActor, vl::OpenGLContext, vl::PixelLODEvaluator, vl::Plane, vl::PolygonSimplifier, vl::Primitives, vl::RayIntersection, vl::RayIntersectionGeometry, vl::RayIntersector, vl::ReadPixels, vl::Renderable, vl::Renderer, vl::Rendering, vl::RenderingCallback, vl::RenderingTree, vl::RenderQueue, vl::RenderQueueSorter, vl::RenderQueueSorterByShader, vl::RenderQueueSorterByRenderable, vl::RenderQueueSorterBasic, vl::RenderQueueSorterStandard, vl::RenderQueueSorterOcclusion, vl::RenderQueueSorterAggressive, vl::RenderState, vl::RenderTarget, vl::RenderToken, vl::ResourceDatabase, vl::ResourceLoadWriter, vl::SceneManager, vl::SceneManagerActorKdTree, vl::SceneManagerActorTree, vl::SceneManagerBVH< T >, vl::Scissor, vl::PixelTransfer, vl::Hint, vl::CullFace, vl::FrontFace, vl::DepthFunc, vl::DepthMask, vl::PolygonMode, vl::ShadeModel, vl::BlendFunc, vl::BlendEquation, vl::SampleCoverage, vl::AlphaFunc, vl::Material, vl::LightModel, vl::Fog, vl::PolygonOffset, vl::LogicOp, vl::DepthRange, vl::LineWidth, vl::PointSize, vl::PolygonStipple, vl::LineStipple, vl::PointParameter, vl::StencilFunc, vl::StencilOp, vl::StencilMask, vl::BlendColor, vl::ColorMask, vl::TextureMatrix, vl::TexEnv, vl::TexGen, vl::TextureUnit, vl::RenderStateSet, vl::EnableSet, vl::Shader, vl::ShaderNode, vl::Terrain, vl::Text, vl::TextStream, vl::TexParameter, vl::Texture, vl::Time, vl::TrackballManipulator, vl::Transform, vl::UIEventListener, vl::Uniform, vl::UniformSet, vl::VertexAttributeArray, vl::Viewport, vl::VirtualDirectory, vl::VirtualFile, vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::ObjMaterial, vl::ObjMesh, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, vl::LoadWriterTIFF, vl::ZippedDirectory, vl::ZippedFileInfo, vl::ZippedFile, vlut::Applet, vlVG::SceneManagerVectorGraphics, vlVG::VectorGraphics, vlVolume::Volume, vlVolume::VolumeInfo, vl::BufferedStream< unsigned char, 128 *1024 >, vl::Collection< LoadCallback >, vl::Collection< WriteCallback >, vl::Collection< VolumeInfo >, vl::Collection< Actor >, vl::Collection< VertexAttributeArray >, vl::Collection< TextureArray >, vl::Collection< ResourceLoadWriter >, vl::Collection< Primitives >, vl::Collection< Pixels >, vl::Collection< VirtualDirectory >, vl::Collection< Shader >, vl::Collection< SceneManager >, vl::Collection< VectorGraphics >, vl::Collection< RenderingAbstract >, vl::Collection< RenderingCallback >, vl::Collection< ActorRenderingCallback >, vl::SceneManagerBVH< ActorKdTree >, and vl::SceneManagerBVH< ActorTree >.

Object& vl::Object::operator= ( const Object & other ) [inline]

const std::string& vl::Object::name ( ) const [inline]

Reimplemented in vl::PlyLoader::PlyPropertyAbstract, and vl::PlyLoader::PlyElement.

void vl::Object::setName ( const std::string & name ) [inline]

int vl::Object::referenceCount ( ) const [inline]

void vl::Object::incReference ( ) [inline]

void vl::Object::decReference ( ) [inline]

void vl::Object::setAutomaticDelete ( bool autodel_on ) [inline]

If set to true the Object is deleted when its reference count reaches 0.

bool vl::Object::automaticDelete ( ) const [inline]

If set to true the Object is deleted when its reference count reaches 0.

template<class T >
T* vl::Object::as ( ) [inline]

Casts an Object to the specified class.

template<class T >
const T* vl::Object::as ( ) const [inline]

Casts an Object to the specified class.

Member Data Documentation

std::string vl::Object::mName [protected]

Reimplemented in vl::PlyLoader::PlyPropertyAbstract, and vl::PlyLoader::PlyElement.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::ObjLoader Class Reference

vl::ObjLoader

vl::ObjLoader Class Reference

Loads a Wavefront OBJ file. More...

#include <vlOBJ.hpp>

List of all members.

Public Member Functions

const std::vector< fvec4 > & | vertexArray () const
const std::vector< fvec3 > & | normalArray () const
const std::vector< fvec3 > & | texCoordsArray () const
const std::map< std::string,
ref< ObjMaterial > > & 		materials () const
const std::vector< ref
< ObjMesh > > & 		meshes () const
std::vector< fvec4 > & | vertexArray ()
std::vector< fvec3 > & | normalArray ()
std::vector< fvec3 > & | texCoordsArray ()
std::map< std::string, ref
< ObjMaterial > > & 		materials ()
std::vector< ref< ObjMesh > > & | meshes ()
ref< ResourceDatabase > | loadOBJ (VirtualFile *file)
Loads a Wavefront OBJ file.
void | loadObjMaterials (VirtualFile *file, std::vector< ObjMaterial > &materials)
Loads a Wavefront MTL file.

Protected Attributes

std::vector< fvec4 > | mCoords
std::vector< fvec3 > | mNormals
std::vector< fvec3 > | mTexCoords
std::map< std::string, ref
< ObjMaterial > > 		mMaterials
std::vector< ref< ObjMesh > > | mMeshes

Detailed Description

Loads a Wavefront OBJ file.

Member Function Documentation

const std::vector<fvec4>& vl::ObjLoader::vertexArray ( ) const [inline]

const std::vector<fvec3>& vl::ObjLoader::normalArray ( ) const [inline]

const std::vector<fvec3>& vl::ObjLoader::texCoordsArray ( ) const [inline]

const std::map< std::string, ref<ObjMaterial> >& vl::ObjLoader::materials ( ) const [inline]

const std::vector< ref<ObjMesh> >& vl::ObjLoader::meshes ( ) const [inline]

std::vector<fvec4>& vl::ObjLoader::vertexArray ( ) [inline]

std::vector<fvec3>& vl::ObjLoader::normalArray ( ) [inline]

std::vector<fvec3>& vl::ObjLoader::texCoordsArray ( ) [inline]

std::map< std::string, ref<ObjMaterial> >& vl::ObjLoader::materials ( ) [inline]

std::vector< ref<ObjMesh> >& vl::ObjLoader::meshes ( ) [inline]

ref< ResourceDatabase > ObjLoader::loadOBJ ( VirtualFile * file )

Loads a Wavefront OBJ file.

Parameters:
file The OBJ file to be loaded

void ObjLoader::loadObjMaterials | ( | VirtualFile * | file,
 |  | std::vector< ObjMaterial > & | materials
 | ) |  |

Loads a Wavefront MTL file.

Parameters:
file | The MTL file to be loaded
materials | Is filled with the loaded materials

Member Data Documentation

std::vector<fvec4> vl::ObjLoader::mCoords [protected]

std::vector<fvec3> vl::ObjLoader::mNormals [protected]

std::vector<fvec3> vl::ObjLoader::mTexCoords [protected]

std::map< std::string, ref<ObjMaterial> > vl::ObjLoader::mMaterials [protected]

std::vector< ref<ObjMesh> > vl::ObjLoader::mMeshes [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::ObjMaterial Class Reference

vl::ObjMaterial

vl::ObjMaterial Class Reference

Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader. More...

#include <vlOBJ.hpp>

Inheritance diagram for vl::ObjMaterial:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ObjMaterial ()
const fvec3 & | ka () const
Ka - ambient color.
const fvec3 & | kd () const
Kd - diffuse color.
const fvec3 & | ks () const
Ks - specular color.
float | tr () const
Tr/d - transparency.
float | ns () const
Ns - specular exponent.
int | illum () const
illum - illumination model
float | ni () const
Ni - optical density / index of refraction.
const ObjTexture & | map_Kd () const
map_Kd - ambient diffuse
const ObjTexture & | map_Ka () const
map_Ka - ambient color map
const ObjTexture & | map_Ks () const
map_Ks - specular color map
const ObjTexture & | map_Ns () const
map_Ns - specular exponent map
const ObjTexture & | map_d () const
map_d - transparency map
const ObjTexture & | map_Decal () const
decal - decal map
const ObjTexture & | map_Disp () const
disp - displace map
const ObjTexture & | map_Bump () const
bump - bump map
void | setKa (const fvec3 &ka)
Ka - ambient color.
void | setKd (const fvec3 &kd)
Kd - diffuse color.
void | setKs (const fvec3 &ks)
Ks - specular color.
void | setTr (float tr)
Tr/d - transparency.
void | setNs (float ns)
Ns - specular exponent.
void | setIllum (int illum)
illum - illumination model
void | setNi (float ni)
Ni - optical density / index of refraction.
void | setMap_Kd (const ObjTexture &map_kd)
map_Kd - ambient diffuse
void | setMap_Ka (const ObjTexture &map_ka)
map_Ka - ambient color map
void | setMap_Ks (const ObjTexture &map_ks)
map_Ks - specular color map
void | setMap_Ns (const ObjTexture &map_ns)
map_Ns - specular exponent map
void | setMap_d (const ObjTexture &map_d)
map_d - transparency map
void | setMap_Decal (const ObjTexture &map_decal)
decal - decal map
void | setMap_Disp (const ObjTexture &map_disp)
disp - displace map
void | setMap_Bump (const ObjTexture &map_bump)
bump - bump map

Protected Attributes

fvec3 mKa
Ka - ambient color.
fvec3 mKd
Kd - diffuse color.
fvec3 mKs
Ks - specular color.
float | mTr
Tr/d - transparency.
float | mNs
Ns - specular exponent.
int | mIllum
illum - illumination model
float | mNi
Ni - optical density / index of refraction.
ObjTexture mMap_Kd
map_Kd - ambient diffuse
ObjTexture mMap_Ka
map_Ka - ambient color map
ObjTexture mMap_Ks
map_Ks - specular color map
ObjTexture mMap_Ns
map_Ns - specular exponent map
ObjTexture mMap_d
map_d - transparency map
ObjTexture mMap_Decal
decal - decal map
ObjTexture mMap_Disp
disp - displace map
ObjTexture mMap_Bump
bump - bump map

Detailed Description

Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader.

Constructor & Destructor Documentation

vl::ObjMaterial::ObjMaterial ( ) [inline]

Member Function Documentation

virtual const char* vl::ObjMaterial::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

const fvec3& vl::ObjMaterial::ka ( ) const [inline]

Ka - ambient color.

const fvec3& vl::ObjMaterial::kd ( ) const [inline]

Kd - diffuse color.

const fvec3& vl::ObjMaterial::ks ( ) const [inline]

Ks - specular color.

float vl::ObjMaterial::tr ( ) const [inline]

Tr/d - transparency.

float vl::ObjMaterial::ns ( ) const [inline]

Ns - specular exponent.

int vl::ObjMaterial::illum ( ) const [inline]

illum - illumination model

float vl::ObjMaterial::ni ( ) const [inline]

Ni - optical density / index of refraction.

const ObjTexture& vl::ObjMaterial::map_Kd ( ) const [inline]

map_Kd - ambient diffuse

const ObjTexture& vl::ObjMaterial::map_Ka ( ) const [inline]

map_Ka - ambient color map

const ObjTexture& vl::ObjMaterial::map_Ks ( ) const [inline]

map_Ks - specular color map

const ObjTexture& vl::ObjMaterial::map_Ns ( ) const [inline]

map_Ns - specular exponent map

const ObjTexture& vl::ObjMaterial::map_d ( ) const [inline]

map_d - transparency map

const ObjTexture& vl::ObjMaterial::map_Decal ( ) const [inline]

decal - decal map

const ObjTexture& vl::ObjMaterial::map_Disp ( ) const [inline]

disp - displace map

const ObjTexture& vl::ObjMaterial::map_Bump ( ) const [inline]

bump - bump map

void vl::ObjMaterial::setKa ( const fvec3 & ka ) [inline]

Ka - ambient color.

void vl::ObjMaterial::setKd ( const fvec3 & kd ) [inline]

Kd - diffuse color.

void vl::ObjMaterial::setKs ( const fvec3 & ks ) [inline]

Ks - specular color.

void vl::ObjMaterial::setTr ( float tr ) [inline]

Tr/d - transparency.

void vl::ObjMaterial::setNs ( float ns ) [inline]

Ns - specular exponent.

void vl::ObjMaterial::setIllum ( int illum ) [inline]

illum - illumination model

void vl::ObjMaterial::setNi ( float ni ) [inline]

Ni - optical density / index of refraction.

void vl::ObjMaterial::setMap_Kd ( const ObjTexture & map_kd ) [inline]

map_Kd - ambient diffuse

void vl::ObjMaterial::setMap_Ka ( const ObjTexture & map_ka ) [inline]

map_Ka - ambient color map

void vl::ObjMaterial::setMap_Ks ( const ObjTexture & map_ks ) [inline]

map_Ks - specular color map

void vl::ObjMaterial::setMap_Ns ( const ObjTexture & map_ns ) [inline]

map_Ns - specular exponent map

void vl::ObjMaterial::setMap_d ( const ObjTexture & map_d ) [inline]

map_d - transparency map

void vl::ObjMaterial::setMap_Decal ( const ObjTexture & map_decal ) [inline]

decal - decal map

void vl::ObjMaterial::setMap_Disp ( const ObjTexture & map_disp ) [inline]

disp - displace map

void vl::ObjMaterial::setMap_Bump ( const ObjTexture & map_bump ) [inline]

bump - bump map

Member Data Documentation

fvec3 vl::ObjMaterial::mKa [protected]

Ka - ambient color.

fvec3 vl::ObjMaterial::mKd [protected]

Kd - diffuse color.

fvec3 vl::ObjMaterial::mKs [protected]

Ks - specular color.

float vl::ObjMaterial::mTr [protected]

Tr/d - transparency.

float vl::ObjMaterial::mNs [protected]

Ns - specular exponent.

int vl::ObjMaterial::mIllum [protected]

illum - illumination model

float vl::ObjMaterial::mNi [protected]

Ni - optical density / index of refraction.

ObjTexture vl::ObjMaterial::mMap_Kd [protected]

map_Kd - ambient diffuse

ObjTexture vl::ObjMaterial::mMap_Ka [protected]

map_Ka - ambient color map

ObjTexture vl::ObjMaterial::mMap_Ks [protected]

map_Ks - specular color map

ObjTexture vl::ObjMaterial::mMap_Ns [protected]

map_Ns - specular exponent map

ObjTexture vl::ObjMaterial::mMap_d [protected]

map_d - transparency map

ObjTexture vl::ObjMaterial::mMap_Decal [protected]

decal - decal map

ObjTexture vl::ObjMaterial::mMap_Disp [protected]

disp - displace map

ObjTexture vl::ObjMaterial::mMap_Bump [protected]

bump - bump map

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::ObjMesh Class Reference

vl::ObjMesh

vl::ObjMesh Class Reference

Represents a Wavefront OBJ mesh. See also ObjLoader. More...

#include <vlOBJ.hpp>

Inheritance diagram for vl::ObjMesh:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
void | setMaterial (ObjMaterial *mat)
The material associated to this mesh.
const ObjMaterial * | material () const
The material associated to this mesh.
const std::vector< int > & | facePositionIndex () const
Index into ObjLoader::vertexArray() vector.
const std::vector< int > & | faceNormalIndex () const
Index into ObjLoader::normalArray() vector.
const std::vector< int > & | faceTexCoordIndex () const
Index into ObjLoader::texCoordsArray() vector.
const std::vector< int > & | face_type () const
Each entry represents a face, the number represents how many vertices the face has.
ObjMaterial * material ()
The material associated to this mesh.
std::vector< int > & | facePositionIndex ()
Index into ObjLoader::vertexArray() vector.
std::vector< int > & | faceNormalIndex ()
Index into ObjLoader::normalArray() vector.
std::vector< int > & | faceTexCoordIndex ()
Index into ObjLoader::texCoordsArray() vector.
std::vector< int > & | face_type ()
Each entry represents a face, the number represents how many vertices the face has.

Protected Attributes

ref< ObjMaterial > mMaterial
std::vector< int > | mFace_icoords
std::vector< int > | mFace_inormals
std::vector< int > | mFace_itexcoords
std::vector< int > | mFace_type

Detailed Description

Represents a Wavefront OBJ mesh. See also ObjLoader.

Member Function Documentation

virtual const char* vl::ObjMesh::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::ObjMesh::setMaterial ( ObjMaterial * mat ) [inline]

The material associated to this mesh.

const ObjMaterial* vl::ObjMesh::material ( ) const [inline]

The material associated to this mesh.

const std::vector<int>& vl::ObjMesh::facePositionIndex ( ) const [inline]

Index into ObjLoader::vertexArray() vector.

const std::vector<int>& vl::ObjMesh::faceNormalIndex ( ) const [inline]

Index into ObjLoader::normalArray() vector.

const std::vector<int>& vl::ObjMesh::faceTexCoordIndex ( ) const [inline]

Index into ObjLoader::texCoordsArray() vector.

const std::vector<int>& vl::ObjMesh::face_type ( ) const [inline]

Each entry represents a face, the number represents how many vertices the face has.

The for each vertex of each face there is an index in facePositionIndex(), faceNormalIndex(), faceTexCoordIndex()

ObjMaterial* vl::ObjMesh::material ( ) [inline]

The material associated to this mesh.

std::vector<int>& vl::ObjMesh::facePositionIndex ( ) [inline]

Index into ObjLoader::vertexArray() vector.

std::vector<int>& vl::ObjMesh::faceNormalIndex ( ) [inline]

Index into ObjLoader::normalArray() vector.

std::vector<int>& vl::ObjMesh::faceTexCoordIndex ( ) [inline]

Index into ObjLoader::texCoordsArray() vector.

std::vector<int>& vl::ObjMesh::face_type ( ) [inline]

Each entry represents a face, the number represents how many vertices the face has.

The for each vertex of each face there is an index in facePositionIndex(), faceNormalIndex(), faceTexCoordIndex()

Member Data Documentation

ref<ObjMaterial> vl::ObjMesh::mMaterial [protected]

std::vector<int> vl::ObjMesh::mFace_icoords [protected]

std::vector<int> vl::ObjMesh::mFace_inormals [protected]

std::vector<int> vl::ObjMesh::mFace_itexcoords [protected]

std::vector<int> vl::ObjMesh::mFace_type [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::ObjTexture Class Reference

vl::ObjTexture

vl::ObjTexture Class Reference

Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader. More...

#include <vlOBJ.hpp>

List of all members.

Public Member Functions

ObjTexture ()
const ObjTexture & | parseLine (const String &line, const String &file)
bool | valid () const
void | print ()
Prints the content of the material. Used for debugging purposes.
const String & | path () const
Texture file name.
bool | blendU () const
-blendu on | off
bool | blendV () const
-blendv on | off
bool | cc () const
-cc on | off
bool | clamp () const
-clamp on | off
float | mm_Base () const
-mm base gain
float | mm_Gain () const
-mm base gain
const fvec3 & | o_UVW () const
-o u v w
const fvec3 & | s_UVW () const
-s u v w
const fvec3 & | t_UVW () const
-t u v w
float | texres_Value () const
-texres value
char | imfchan () const
-imfchan r | g | b | m | l | z
float | bm () const
-bm mult
void | setPath (const String &filename)
Texture file name.
void | setBlendU (bool on)
-blendu on | off
void | setBlendV (bool on)
-blendv on | off
void | setCC (bool on)
-cc on | off
void | setClamp (bool on)
-clamp on | off
void | setMM_Base (float base)
-mm base gain
void | setMM_Gain (float gain)
-mm base gain
void | setO_UVW (const fvec3 &o_uvw)
-o u v w
void | setS_UVW (const fvec3 &s_uvw)
-s u v w
void | setT_UVW (const fvec3 &t_uvw)
-t u v w
void | setTexres_Value (float value)
-texres value
void | setImfchan (char val)
-imfchan r | g | b | m | l | z
void | setBM (float bm)
-bm mult

Protected Attributes

String mFileName
Texture file name.
bool | mBlendU
-blendu on | off
bool | mBlendV
-blendv on | off
bool | mCC
-cc on | off
bool | mClamp
-clamp on | off
float | mMM_Base
-mm base gain
float | mMM_Gain
-mm base gain
fvec3 mO_UVW
-o u v w
fvec3 mS_UVW
-s u v w
fvec3 mT_UVW
-t u v w
float | mTexres_Value
-texres value
char | mImfchan
-imfchan r | g | b | m | l | z
float | mBM
-bm mult

Detailed Description

Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader.

Constructor & Destructor Documentation

ObjTexture::ObjTexture ( )

Member Function Documentation

const ObjTexture & ObjTexture::parseLine | ( | const String & | line,
 |  | const String & | file
 | ) |  |

bool vl::ObjTexture::valid ( ) const [inline]

void ObjTexture::print ( )

Prints the content of the material. Used for debugging purposes.

const String& vl::ObjTexture::path ( ) const [inline]

Texture file name.

bool vl::ObjTexture::blendU ( ) const [inline]

-blendu on | off

bool vl::ObjTexture::blendV ( ) const [inline]

-blendv on | off

bool vl::ObjTexture::cc ( ) const [inline]

-cc on | off

bool vl::ObjTexture::clamp ( ) const [inline]

-clamp on | off

float vl::ObjTexture::mm_Base ( ) const [inline]

-mm base gain

float vl::ObjTexture::mm_Gain ( ) const [inline]

-mm base gain

const fvec3& vl::ObjTexture::o_UVW ( ) const [inline]

-o u v w

const fvec3& vl::ObjTexture::s_UVW ( ) const [inline]

-s u v w

const fvec3& vl::ObjTexture::t_UVW ( ) const [inline]

-t u v w

float vl::ObjTexture::texres_Value ( ) const [inline]

-texres value

char vl::ObjTexture::imfchan ( ) const [inline]

-imfchan r | g | b | m | l | z

float vl::ObjTexture::bm ( ) const [inline]

-bm mult

void vl::ObjTexture::setPath ( const String & filename ) [inline]

Texture file name.

void vl::ObjTexture::setBlendU ( bool on ) [inline]

-blendu on | off

void vl::ObjTexture::setBlendV ( bool on ) [inline]

-blendv on | off

void vl::ObjTexture::setCC ( bool on ) [inline]

-cc on | off

void vl::ObjTexture::setClamp ( bool on ) [inline]

-clamp on | off

void vl::ObjTexture::setMM_Base ( float base ) [inline]

-mm base gain

void vl::ObjTexture::setMM_Gain ( float gain ) [inline]

-mm base gain

void vl::ObjTexture::setO_UVW ( const fvec3 & o_uvw ) [inline]

-o u v w

void vl::ObjTexture::setS_UVW ( const fvec3 & s_uvw ) [inline]

-s u v w

void vl::ObjTexture::setT_UVW ( const fvec3 & t_uvw ) [inline]

-t u v w

void vl::ObjTexture::setTexres_Value ( float value ) [inline]

-texres value

void vl::ObjTexture::setImfchan ( char val ) [inline]

-imfchan r | g | b | m | l | z

void vl::ObjTexture::setBM ( float bm ) [inline]

-bm mult

Member Data Documentation

String vl::ObjTexture::mFileName [protected]

Texture file name.

bool vl::ObjTexture::mBlendU [protected]

-blendu on | off

bool vl::ObjTexture::mBlendV [protected]

-blendv on | off

bool vl::ObjTexture::mCC [protected]

-cc on | off

bool vl::ObjTexture::mClamp [protected]

-clamp on | off

float vl::ObjTexture::mMM_Base [protected]

-mm base gain

float vl::ObjTexture::mMM_Gain [protected]

-mm base gain

fvec3 vl::ObjTexture::mO_UVW [protected]

-o u v w

fvec3 vl::ObjTexture::mS_UVW [protected]

-s u v w

fvec3 vl::ObjTexture::mT_UVW [protected]

-t u v w

float vl::ObjTexture::mTexres_Value [protected]

-texres value

char vl::ObjTexture::mImfchan [protected]

-imfchan r | g | b | m | l | z

float vl::ObjTexture::mBM [protected]

-bm mult

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::OpenGLContext Class Reference

vl::OpenGLContext

vl::OpenGLContext Class Reference

Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent. More...

#include <OpenGLContext.hpp>

Inheritance diagram for vl::OpenGLContext:

vl::Object vlGLUT::GLUTWindow vlQt4::Qt4Widget vlSDL::SDLWindow vlWin32::Win32Context vlWX::vlWXGLCanvas vlMFC::MFCWindow vlWin32::Win32Window

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
OpenGLContext (int w=0, int h=0)
Constructor.
~OpenGLContext ()
Destructor.
void | initExtensions (bool log=true)
Initializes the supported OpenGL extensions.
void | logOpenGLInfo ()
Logs some information about the OpenGL context.
bool | isExtensionSupported (const char *ext_name)
Returns true if the given extension is supported.
void * | getProcAddress (const char *function_name)
Returns the address of an OpenGL extension function.
RenderTarget * renderTarget ()
The render target representing this OpenGL context.
const RenderTarget * | renderTarget () const
The render target representing this OpenGL context.
ref< FBORenderTarget > | createFBORenderTarget (int width, int height)
Creates a new FBORenderTarget (framebuffer object RenderTarget).
ref< FBORenderTarget > createFBORenderTarget ()
Equivalent to "createFBORenderTarget(0,0);".
void | destroyFBORenderTarget (FBORenderTarget *fbort)
void | destroyAllFBORenderTargets ()
virtual void | quitApplication ()
Asks to the windowing system that is managing the OpenGLContext to quit the application.
virtual void | destroy ()
virtual void | update ()
virtual void | setWindowTitle (const String &)
virtual bool | setFullscreen (bool)
virtual void | show ()
virtual void | hide ()
virtual void | setPosition (int, int)
virtual void | setSize (int, int)
virtual ivec2 | position () const
virtual ivec2 | size () const
virtual bool | mouseVisible () const
virtual bool | fullscreen () const
virtual void | setMouseVisible (bool)
virtual void | getFocus ()
virtual void | swapBuffers ()
virtual void | makeCurrent ()
virtual void | setMousePosition (int, int)
void | setVSyncEnabled (bool enable)
bool | vsyncEnabled () const
virtual void | setContinuousUpdate (bool continuous)
bool | continuousUpdate () const
void | sortEventListeners ()
void | addEventListener (UIEventListener *el)
void | removeEventListener (UIEventListener *el)
void | eraseAllEventListeners ()
const std::vector< ref
< UIEventListener > > & 		eventListeners () const
UIEventListener * | eventListener (int i) const
int | eventListenerCount () const
const OpenGLContextFormat & | openglContextInfo () const
void | setOpenGLContextInfo (const OpenGLContextFormat &info)
void | ignoreNextMouseMoveEvent ()
int | width () const
int | height () const
void | dispatchResizeEvent (int w, int h)
void | dispatchMouseMoveEvent (int x, int y)
void | dispatchMouseUpEvent (EMouseButton button, int x, int y)
void | dispatchMouseDownEvent (EMouseButton button, int x, int y)
void | dispatchMouseWheelEvent (int n)
void | dispatchKeyPressEvent (unsigned short unicode_ch, EKey key)
void | dispatchKeyReleaseEvent (unsigned short unicode_ch, EKey key)
void | dispatchDestroyEvent ()
void | dispatchRunEvent ()
void | dispatchVisibilityEvent (bool visible)
void | dispatchInitEvent ()
Dispatches the init event.
void | dispatchFileDroppedEvent (const std::vector< String > &files)
int | textureUnitCount () const
const std::set< EKey > & | keyboard () const
Returns the std::set containing the currently pressed keys.
bool | isKeyPressed (EKey key) const
Returns true if the given key is pressed.
void | keyPress (EKey key)
For internal use only.
void | keyRelease (EKey key)
For internal use only.

Protected Attributes

ref< RenderTarget > mRenderTarget
std::vector< ref
< FBORenderTarget > > 		mFBORenderTarget
std::vector< ref
< UIEventListener > > 		mEventListeners
std::set< EKey > | mKeyboard
OpenGLContextFormat mGLContextInfo
bool | mMouseVisible
bool | mContinuousUpdate
bool | mIgnoreNextMouseMoveEvent
bool | mFullscreen
int | mTextureUnitCount

Detailed Description

Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent.

OpenGLContext is an abstract class that wraps a minimal common subset of GUI APIs like Win32, Qt, wxWidgets, SDL, GLUT, etc.
In order to respond to the events generated by the OpenGLContext you must subclass an UIEventListener and bind it to the OpenGLContext using the functions addEventListener(ref<UIEventListener>) and removeEventListener(ref<UIEventListener>).

OpenGLContext custom implementation
  • Key_Alt/Ctrl/Shift events must always be notified before Key_Left/Right-Alt/Ctrl/Shift events.
  • Always update the mKeyboard structure appropriately especially with respect to Key_[Left/Right]-Alt/Ctrl/Shift events.
  • When cycling through EventListeners to dispatch the events you must do it on a temporary copy of mEventListeners so that the EventListeners can safely add/remove themselves or other EventListeners to the OpenGLContext itself.

Constructor & Destructor Documentation

vl::OpenGLContext::OpenGLContext | ( | int | w = 0,
 |  | int | h = 0 |
 | ) |  |  | [inline]

Constructor.

vl::OpenGLContext::~OpenGLContext ( ) [inline]

Destructor.

Dispatches also destroyEvent() to its event listeners.

Member Function Documentation

virtual const char* vl::OpenGLContext::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void OpenGLContext::initExtensions ( bool log = true )

Initializes the supported OpenGL extensions.

void OpenGLContext::logOpenGLInfo ( )

Logs some information about the OpenGL context.

bool OpenGLContext::isExtensionSupported ( const char * ext_name )

Returns true if the given extension is supported.

Note:
This is a relatively slow function, don't use it inside loops and similar.

void * OpenGLContext::getProcAddress ( const char * function_name )

Returns the address of an OpenGL extension function.

RenderTarget* vl::OpenGLContext::renderTarget ( ) [inline]

The render target representing this OpenGL context.

The returned RenderTarget's dimensions will be automatically updated to the OpenGLContext's dimensions.

const RenderTarget* vl::OpenGLContext::renderTarget ( ) const [inline]

The render target representing this OpenGL context.

The returned RenderTarget's dimensions will be automatically updated to the OpenGLContext's dimensions.

ref<FBORenderTarget> vl::OpenGLContext::createFBORenderTarget | ( | int | width,
 |  | int | height |
 | ) |  |  | [inline]

Creates a new FBORenderTarget (framebuffer object RenderTarget).

Note:
A framebuffer object always belongs to an OpenGL context and in order to render on it the appropriate OpenGL context must be active.

ref<FBORenderTarget> vl::OpenGLContext::createFBORenderTarget ( ) [inline]

Equivalent to "createFBORenderTarget(0,0);".

void vl::OpenGLContext::destroyFBORenderTarget ( FBORenderTarget * fbort ) [inline]

void vl::OpenGLContext::destroyAllFBORenderTargets ( ) [inline]

virtual void vl::OpenGLContext::quitApplication ( ) [inline, virtual]

Asks to the windowing system that is managing the OpenGLContext to quit the application.

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::destroy ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWin32::Win32Window, vlMFC::MFCWindow, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::update ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::setWindowTitle ( const String & ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual bool vl::OpenGLContext::setFullscreen ( bool ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual void vl::OpenGLContext::show ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual void vl::OpenGLContext::hide ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual void vl::OpenGLContext::setPosition | ( | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::setSize | ( | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual ivec2 vl::OpenGLContext::position ( ) const [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual ivec2 vl::OpenGLContext::size ( ) const [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual bool vl::OpenGLContext::mouseVisible ( ) const [inline, virtual]

virtual bool vl::OpenGLContext::fullscreen ( ) const [inline, virtual]

virtual void vl::OpenGLContext::setMouseVisible ( bool ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::getFocus ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, and vlGLUT::GLUTWindow.

virtual void vl::OpenGLContext::swapBuffers ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::makeCurrent ( ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

virtual void vl::OpenGLContext::setMousePosition | ( | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vlQt4::Qt4Widget, vlWX::vlWXGLCanvas, vlWin32::Win32Context, vlGLUT::GLUTWindow, and vlSDL::SDLWindow.

void OpenGLContext::setVSyncEnabled ( bool enable )

bool OpenGLContext::vsyncEnabled ( ) const

virtual void vl::OpenGLContext::setContinuousUpdate ( bool continuous ) [inline, virtual]

Reimplemented in vlQt4::Qt4Widget.

bool vl::OpenGLContext::continuousUpdate ( ) const [inline]

void OpenGLContext::sortEventListeners ( )

void OpenGLContext::addEventListener ( UIEventListener * el )

Note:
An UIEventListener can be associated only to one OpenGLContext at a time.

void OpenGLContext::removeEventListener ( UIEventListener * el )

void OpenGLContext::eraseAllEventListeners ( )

const std::vector< ref<UIEventListener> >& vl::OpenGLContext::eventListeners ( ) const [inline]

UIEventListener* vl::OpenGLContext::eventListener ( int i ) const [inline]

int vl::OpenGLContext::eventListenerCount ( ) const [inline]

const OpenGLContextFormat& vl::OpenGLContext::openglContextInfo ( ) const [inline]

void vl::OpenGLContext::setOpenGLContextInfo ( const OpenGLContextFormat & info ) [inline]

void vl::OpenGLContext::ignoreNextMouseMoveEvent ( ) [inline]

int vl::OpenGLContext::width ( ) const [inline]

int vl::OpenGLContext::height ( ) const [inline]

void vl::OpenGLContext::dispatchResizeEvent | ( | int | w,
 |  | int | h |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchMouseMoveEvent | ( | int | x,
 |  | int | y |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchMouseUpEvent | ( | EMouseButton | button,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchMouseDownEvent | ( | EMouseButton | button,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchMouseWheelEvent ( int n ) [inline]

void vl::OpenGLContext::dispatchKeyPressEvent | ( | unsigned short | unicode_ch,
 |  | EKey | key |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchKeyReleaseEvent | ( | unsigned short | unicode_ch,
 |  | EKey | key |
 | ) |  |  | [inline]

void vl::OpenGLContext::dispatchDestroyEvent ( ) [inline]

void vl::OpenGLContext::dispatchRunEvent ( ) [inline]

void vl::OpenGLContext::dispatchVisibilityEvent ( bool visible ) [inline]

void vl::OpenGLContext::dispatchInitEvent ( ) [inline]

Dispatches the init event.

void vl::OpenGLContext::dispatchFileDroppedEvent ( const std::vector< String > & files ) [inline]

int vl::OpenGLContext::textureUnitCount ( ) const [inline]

const std::set<EKey>& vl::OpenGLContext::keyboard ( ) const [inline]

Returns the std::set containing the currently pressed keys.

bool vl::OpenGLContext::isKeyPressed ( EKey key ) const [inline]

Returns true if the given key is pressed.

void vl::OpenGLContext::keyPress ( EKey key ) [inline]

For internal use only.

void vl::OpenGLContext::keyRelease ( EKey key ) [inline]

For internal use only.

Member Data Documentation

ref<RenderTarget> vl::OpenGLContext::mRenderTarget [protected]

std::vector< ref<FBORenderTarget> > vl::OpenGLContext::mFBORenderTarget [protected]

std::vector< ref<UIEventListener> > vl::OpenGLContext::mEventListeners [protected]

std::set<EKey> vl::OpenGLContext::mKeyboard [protected]

OpenGLContextFormat vl::OpenGLContext::mGLContextInfo [protected]

bool vl::OpenGLContext::mMouseVisible [protected]

bool vl::OpenGLContext::mContinuousUpdate [protected]

bool vl::OpenGLContext::mIgnoreNextMouseMoveEvent [protected]

bool vl::OpenGLContext::mFullscreen [protected]

int vl::OpenGLContext::mTextureUnitCount [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::OpenGLContextFormat Class Reference

vl::OpenGLContextFormat

vl::OpenGLContextFormat Class Reference

The OpenGLContextFormat class encapsulates the settings of an OpenGL rendering context. More...

#include <OpenGLContext.hpp>

List of all members.

Public Member Functions

OpenGLContextFormat ()
virtual const char * | className ()
void | setRGBABits (int r, int g, int b, int a)
void | setAccumRGBABits (int r, int g, int b, int a)
void | setDoubleBuffer (bool double_buffer_on)
void | setDepthBufferBits (int bits)
void | setStencilBufferBits (int bits)
void | setMultisample (bool multisample_on)
void | setMultisampleSamples (int samples)
void | setStereo (bool stereo_on)
void | setFullscreen (bool fullscreent)
void | setVSync (bool vsync_on)
const ivec4 & | rgbaBits () const
const ivec4 & | accumRGBABits () const
bool | doubleBuffer () const
int | depthBufferBits () const
int | stencilBufferBits () const
bool | multisample () const
int | multisampleSamples () const
bool | stereo () const
bool | fullscreen () const
bool | vSync () const
int | bitsPerPixel () const
Returns rgbaBits().r() + rgbaBits().g() + rgbaBits().b() + rgbaBits().a().

Protected Attributes

ivec4 mRGBABits
ivec4 mAccumRGBABits
bool | mHasDoubleBuffer
int | mZBufferBits
int | mStencilBufferBits
bool | mHasMultisample
int | mMultisampleSamples
bool | mStereo
bool | mFullscreen
bool | mVSync

Detailed Description

The OpenGLContextFormat class encapsulates the settings of an OpenGL rendering context.

Constructor & Destructor Documentation

vl::OpenGLContextFormat::OpenGLContextFormat ( ) [inline]

Member Function Documentation

virtual const char* vl::OpenGLContextFormat::className ( ) [inline, virtual]

void vl::OpenGLContextFormat::setRGBABits | ( | int | r,
 |  | int | g,
 |  | int | b,
 |  | int | a |
 | ) |  |  | [inline]

void vl::OpenGLContextFormat::setAccumRGBABits | ( | int | r,
 |  | int | g,
 |  | int | b,
 |  | int | a |
 | ) |  |  | [inline]

void vl::OpenGLContextFormat::setDoubleBuffer ( bool double_buffer_on ) [inline]

void vl::OpenGLContextFormat::setDepthBufferBits ( int bits ) [inline]

void vl::OpenGLContextFormat::setStencilBufferBits ( int bits ) [inline]

void vl::OpenGLContextFormat::setMultisample ( bool multisample_on ) [inline]

void vl::OpenGLContextFormat::setMultisampleSamples ( int samples ) [inline]

void vl::OpenGLContextFormat::setStereo ( bool stereo_on ) [inline]

void vl::OpenGLContextFormat::setFullscreen ( bool fullscreent ) [inline]

void vl::OpenGLContextFormat::setVSync ( bool vsync_on ) [inline]

const ivec4& vl::OpenGLContextFormat::rgbaBits ( ) const [inline]

const ivec4& vl::OpenGLContextFormat::accumRGBABits ( ) const [inline]

bool vl::OpenGLContextFormat::doubleBuffer ( ) const [inline]

int vl::OpenGLContextFormat::depthBufferBits ( ) const [inline]

int vl::OpenGLContextFormat::stencilBufferBits ( ) const [inline]

bool vl::OpenGLContextFormat::multisample ( ) const [inline]

int vl::OpenGLContextFormat::multisampleSamples ( ) const [inline]

bool vl::OpenGLContextFormat::stereo ( ) const [inline]

bool vl::OpenGLContextFormat::fullscreen ( ) const [inline]

bool vl::OpenGLContextFormat::vSync ( ) const [inline]

int vl::OpenGLContextFormat::bitsPerPixel ( ) const [inline]

Returns rgbaBits().r() + rgbaBits().g() + rgbaBits().b() + rgbaBits().a().

Member Data Documentation

ivec4 vl::OpenGLContextFormat::mRGBABits [protected]

ivec4 vl::OpenGLContextFormat::mAccumRGBABits [protected]

bool vl::OpenGLContextFormat::mHasDoubleBuffer [protected]

int vl::OpenGLContextFormat::mZBufferBits [protected]

int vl::OpenGLContextFormat::mStencilBufferBits [protected]

bool vl::OpenGLContextFormat::mHasMultisample [protected]

int vl::OpenGLContextFormat::mMultisampleSamples [protected]

bool vl::OpenGLContextFormat::mStereo [protected]

bool vl::OpenGLContextFormat::mFullscreen [protected]

bool vl::OpenGLContextFormat::mVSync [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::PixelLODEvaluator Class Reference

vl::PixelLODEvaluator

vl::PixelLODEvaluator Class Reference

A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen. More...

#include <PixelLODEvaluator.hpp>

Inheritance diagram for vl::PixelLODEvaluator:

vl::LODEvaluator vl::Object

List of all members.

Public Member Functions

PixelLODEvaluator ()
virtual const char * | className ()
Returns the name of the class.
virtual int | evaluate (Actor *actor, Camera *camera)
const std::vector< float > & | distanceRangeSet ()
void | clearPixelRangeSet ()
int | distanceRangeCount () const
float | distanceRange (int index) const
void | setPixelRangeSet (const std::vector< float > &distance_set)
void | addPixelRange (float distance)
void | setPixelRange (int index, float distance)

Protected Attributes

std::vector< float > | mPixelRangeSet

Detailed Description

A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen.

See also:
  • LODEvaluator
  • PixelLODEvaluator

Constructor & Destructor Documentation

vl::PixelLODEvaluator::PixelLODEvaluator ( ) [inline]

Member Function Documentation

virtual const char* vl::PixelLODEvaluator::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::LODEvaluator.

int PixelLODEvaluator::evaluate | ( | Actor * | actor,
 |  | Camera * | camera |
 | ) |  |  | [virtual]

Implements vl::LODEvaluator.

const std::vector<float>& vl::PixelLODEvaluator::distanceRangeSet ( ) [inline]

void vl::PixelLODEvaluator::clearPixelRangeSet ( ) [inline]

int vl::PixelLODEvaluator::distanceRangeCount ( ) const [inline]

float vl::PixelLODEvaluator::distanceRange ( int index ) const [inline]

void PixelLODEvaluator::setPixelRangeSet ( const std::vector< float > & distance_set )

void PixelLODEvaluator::addPixelRange ( float distance )

void PixelLODEvaluator::setPixelRange | ( | int | index,
 |  | float | distance
 | ) |  |

Member Data Documentation

std::vector<float> vl::PixelLODEvaluator::mPixelRangeSet [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::PixelTransfer Class Reference

vl::PixelTransfer

vl::PixelTransfer Class Reference

Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PixelTransfer:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PixelTransfer ()
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
bool | mapColor () const
bool | mapStencil () const
int | indexShift () const
int | indexOffset () const
float | redScale () const
float | greenScale () const
float | blueScale () const
float | alphaScale () const
float | depthScale () const
float | redBias () const
float | greenBias () const
float | blueBias () const
float | alphaBias () const
float | depthBias () const
float | postColorMatrixRedScale () const
float | postColorMatrixGreenScale () const
float | postColorMatrixBlueScale () const
float | postColorMatrixAlphaScale () const
float | postColorMatrixRedBias () const
float | postColorMatrixGreenBias () const
float | postColorMatrixBlueBias () const
float | postColorMatrixAlphaBias () const
float | postConvolutionRedScale () const
float | postConvolutionGreenScale () const
float | postConvolutionBlueScale () const
float | postConvolutionAlphaScale () const
float | postConvolutionRedBias () const
float | postConvolutionGreenBias () const
float | postConvolutionBlueBias () const
float | postConvolutionAlphaBias () const
void | setMapColor (bool map_color)
void | setMapStencil (bool map_stencil)
void | setIndexShift (int index_shift)
void | setIndexOffset (int index_offset)
void | setRedScale (float red_scale)
void | setGreenScale (float green_scale)
void | setBlueScale (float blue_scale)
void | setAlphaScale (float alpha_scale)
void | setDepthScale (float depth_scale)
void | setRedBias (float red_bias)
void | setGreenBias (float green_bias)
void | setBlueBias (float blue_bias)
void | setAlphaBias (float alpha_bias)
void | setDepthBias (float depth_bias)
void | setPostColorMatrixRedScale (float scale)
void | setPostColorMatrixGreenScale (float scale)
void | setPostColorMatrixBlueScale (float scale)
void | setPostColorMatrixAlphaScale (float scale)
void | setPostColorMatrixRedBias (float bias)
void | setPostColorMatrixGreenBias (float bias)
void | setPostColorMatrixBlueBias (float bias)
void | setPostColorMatrixAlphaBias (float bias)
void | setPostConvolutionRedScale (float scale)
void | setPostConvolutionGreenScale (float scale)
void | setPostConvolutionBlueScale (float scale)
void | setPostConvolutionAlphaScale (float scale)
void | setPostConvolutionRedBias (float bias)
void | setPostConvolutionGreenBias (float bias)
void | setPostConvolutionBlueBias (float bias)
void | setPostConvolutionAlphaBias (float bias)

Protected Attributes

bool | mMapColor
bool | mMapStencil
int | mIndexShift
int | mIndexOffset
float | mRedScale
float | mGreenScale
float | mBlueScale
float | mAlphaScale
float | mDepthScale
float | mRedBias
float | mGreenBias
float | mBlueBias
float | mAlphaBias
float | mDepthBias
float | mPostColorMatrixRedScale
float | mPostColorMatrixGreenScale
float | mPostColorMatrixBlueScale
float | mPostColorMatrixAlphaScale
float | mPostColorMatrixRedBias
float | mPostColorMatrixGreenBias
float | mPostColorMatrixBlueBias
float | mPostColorMatrixAlphaBias
float | mPostConvolutionRedScale
float | mPostConvolutionGreenScale
float | mPostConvolutionBlueScale
float | mPostConvolutionAlphaScale
float | mPostConvolutionRedBias
float | mPostConvolutionGreenBias
float | mPostConvolutionBlueBias
float | mPostConvolutionAlphaBias

Detailed Description

Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::PixelTransfer::PixelTransfer ( ) [inline]

Member Function Documentation

virtual const char* vl::PixelTransfer::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PixelTransfer::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PixelTransfer::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

bool vl::PixelTransfer::mapColor ( ) const [inline]

bool vl::PixelTransfer::mapStencil ( ) const [inline]

int vl::PixelTransfer::indexShift ( ) const [inline]

int vl::PixelTransfer::indexOffset ( ) const [inline]

float vl::PixelTransfer::redScale ( ) const [inline]

float vl::PixelTransfer::greenScale ( ) const [inline]

float vl::PixelTransfer::blueScale ( ) const [inline]

float vl::PixelTransfer::alphaScale ( ) const [inline]

float vl::PixelTransfer::depthScale ( ) const [inline]

float vl::PixelTransfer::redBias ( ) const [inline]

float vl::PixelTransfer::greenBias ( ) const [inline]

float vl::PixelTransfer::blueBias ( ) const [inline]

float vl::PixelTransfer::alphaBias ( ) const [inline]

float vl::PixelTransfer::depthBias ( ) const [inline]

float vl::PixelTransfer::postColorMatrixRedScale ( ) const [inline]

float vl::PixelTransfer::postColorMatrixGreenScale ( ) const [inline]

float vl::PixelTransfer::postColorMatrixBlueScale ( ) const [inline]

float vl::PixelTransfer::postColorMatrixAlphaScale ( ) const [inline]

float vl::PixelTransfer::postColorMatrixRedBias ( ) const [inline]

float vl::PixelTransfer::postColorMatrixGreenBias ( ) const [inline]

float vl::PixelTransfer::postColorMatrixBlueBias ( ) const [inline]

float vl::PixelTransfer::postColorMatrixAlphaBias ( ) const [inline]

float vl::PixelTransfer::postConvolutionRedScale ( ) const [inline]

float vl::PixelTransfer::postConvolutionGreenScale ( ) const [inline]

float vl::PixelTransfer::postConvolutionBlueScale ( ) const [inline]

float vl::PixelTransfer::postConvolutionAlphaScale ( ) const [inline]

float vl::PixelTransfer::postConvolutionRedBias ( ) const [inline]

float vl::PixelTransfer::postConvolutionGreenBias ( ) const [inline]

float vl::PixelTransfer::postConvolutionBlueBias ( ) const [inline]

float vl::PixelTransfer::postConvolutionAlphaBias ( ) const [inline]

void vl::PixelTransfer::setMapColor ( bool map_color ) [inline]

void vl::PixelTransfer::setMapStencil ( bool map_stencil ) [inline]

void vl::PixelTransfer::setIndexShift ( int index_shift ) [inline]

void vl::PixelTransfer::setIndexOffset ( int index_offset ) [inline]

void vl::PixelTransfer::setRedScale ( float red_scale ) [inline]

void vl::PixelTransfer::setGreenScale ( float green_scale ) [inline]

void vl::PixelTransfer::setBlueScale ( float blue_scale ) [inline]

void vl::PixelTransfer::setAlphaScale ( float alpha_scale ) [inline]

void vl::PixelTransfer::setDepthScale ( float depth_scale ) [inline]

void vl::PixelTransfer::setRedBias ( float red_bias ) [inline]

void vl::PixelTransfer::setGreenBias ( float green_bias ) [inline]

void vl::PixelTransfer::setBlueBias ( float blue_bias ) [inline]

void vl::PixelTransfer::setAlphaBias ( float alpha_bias ) [inline]

void vl::PixelTransfer::setDepthBias ( float depth_bias ) [inline]

void vl::PixelTransfer::setPostColorMatrixRedScale ( float scale ) [inline]

void vl::PixelTransfer::setPostColorMatrixGreenScale ( float scale ) [inline]

void vl::PixelTransfer::setPostColorMatrixBlueScale ( float scale ) [inline]

void vl::PixelTransfer::setPostColorMatrixAlphaScale ( float scale ) [inline]

void vl::PixelTransfer::setPostColorMatrixRedBias ( float bias ) [inline]

void vl::PixelTransfer::setPostColorMatrixGreenBias ( float bias ) [inline]

void vl::PixelTransfer::setPostColorMatrixBlueBias ( float bias ) [inline]

void vl::PixelTransfer::setPostColorMatrixAlphaBias ( float bias ) [inline]

void vl::PixelTransfer::setPostConvolutionRedScale ( float scale ) [inline]

void vl::PixelTransfer::setPostConvolutionGreenScale ( float scale ) [inline]

void vl::PixelTransfer::setPostConvolutionBlueScale ( float scale ) [inline]

void vl::PixelTransfer::setPostConvolutionAlphaScale ( float scale ) [inline]

void vl::PixelTransfer::setPostConvolutionRedBias ( float bias ) [inline]

void vl::PixelTransfer::setPostConvolutionGreenBias ( float bias ) [inline]

void vl::PixelTransfer::setPostConvolutionBlueBias ( float bias ) [inline]

void vl::PixelTransfer::setPostConvolutionAlphaBias ( float bias ) [inline]

Member Data Documentation

bool vl::PixelTransfer::mMapColor [protected]

bool vl::PixelTransfer::mMapStencil [protected]

int vl::PixelTransfer::mIndexShift [protected]

int vl::PixelTransfer::mIndexOffset [protected]

float vl::PixelTransfer::mRedScale [protected]

float vl::PixelTransfer::mGreenScale [protected]

float vl::PixelTransfer::mBlueScale [protected]

float vl::PixelTransfer::mAlphaScale [protected]

float vl::PixelTransfer::mDepthScale [protected]

float vl::PixelTransfer::mRedBias [protected]

float vl::PixelTransfer::mGreenBias [protected]

float vl::PixelTransfer::mBlueBias [protected]

float vl::PixelTransfer::mAlphaBias [protected]

float vl::PixelTransfer::mDepthBias [protected]

float vl::PixelTransfer::mPostColorMatrixRedScale [protected]

float vl::PixelTransfer::mPostColorMatrixGreenScale [protected]

float vl::PixelTransfer::mPostColorMatrixBlueScale [protected]

float vl::PixelTransfer::mPostColorMatrixAlphaScale [protected]

float vl::PixelTransfer::mPostColorMatrixRedBias [protected]

float vl::PixelTransfer::mPostColorMatrixGreenBias [protected]

float vl::PixelTransfer::mPostColorMatrixBlueBias [protected]

float vl::PixelTransfer::mPostColorMatrixAlphaBias [protected]

float vl::PixelTransfer::mPostConvolutionRedScale [protected]

float vl::PixelTransfer::mPostConvolutionGreenScale [protected]

float vl::PixelTransfer::mPostConvolutionBlueScale [protected]

float vl::PixelTransfer::mPostConvolutionAlphaScale [protected]

float vl::PixelTransfer::mPostConvolutionRedBias [protected]

float vl::PixelTransfer::mPostConvolutionGreenBias [protected]

float vl::PixelTransfer::mPostConvolutionBlueBias [protected]

float vl::PixelTransfer::mPostConvolutionAlphaBias [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Plane Class Reference

vl::Plane

vl::Plane Class Reference

The Plane class defines a plane using a normal and an origin. More...

#include <Plane.hpp>

Inheritance diagram for vl::Plane:

vl::Object

List of all members.

Public Member Functions

Plane (Real o=0.0f, vec3 n=vec3(0, 0, 0))
Plane (const vec3 &o, const vec3 &n)
virtual const char * | className ()
Returns the name of the class.
Real | distance (const vec3 &v) const
int | classify (const AABB &) const
returns 0 if the AABB intersects the plane, 1 if it's in the positive side, -1 if it's in the negative side.
bool | isOutside (const AABB &) const
const vec3 & | normal () const
Real | origin () const
void | setNormal (const vec3 &normal)
void | setOrigin (Real origin)

Protected Attributes

vec3 mNormal
Real mOrigin

Detailed Description

The Plane class defines a plane using a normal and an origin.

Constructor & Destructor Documentation

vl::Plane::Plane | ( | Real | o = 0.0f,
 |  | vec3 | n = vec3(0,0,0) |
 | ) |  |  | [inline]

vl::Plane::Plane | ( | const vec3 & | o,
 |  | const vec3 & | n |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::Plane::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Real Plane::distance ( const vec3 & v ) const

int Plane::classify ( const AABB & aabb ) const

returns 0 if the AABB intersects the plane, 1 if it's in the positive side, -1 if it's in the negative side.

bool Plane::isOutside ( const AABB & aabb ) const

const vec3& vl::Plane::normal ( ) const [inline]

Real vl::Plane::origin ( ) const [inline]

void vl::Plane::setNormal ( const vec3 & normal ) [inline]

void vl::Plane::setOrigin ( Real origin ) [inline]

Member Data Documentation

vec3 vl::Plane::mNormal [protected]

Real vl::Plane::mOrigin [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::PlyLoader Class Reference

vl::PlyLoader

vl::PlyLoader Class Reference

Loads a PLY file. More...

#include <vlPLY.hpp>

List of all members.

Classes

class | PlyElement
Used by PlyLoader. More...
class | PlyPropertyAbstract
Used by PlyLoader. More...
class | PlyScalar
Used by PlyLoader. More...
class | PlyScalarList
Used by PlyLoader. More...

Public Types

enum EType {
PlyError, PlyChar, PlyUChar, PlyShort,
PlyUShort, PlyInt, PlyUInt, PlyFloat,
PlyDouble
}

Public Member Functions

PlyLoader ()
Constructor.
ref< ResourceDatabase > | loadPly (VirtualFile *file)
Loads a PLY file.
const std::vector< ref
< PlyElement > > & 		elements () const
std::vector< ref< PlyElement > > & | elements ()
bool | binary () const
bool | littleEndian () const
void | readElements (VirtualFile *file)
void | readElements (TextStream *text)
void | newElement (PlyElement *el)
EType | translateType (const String &type)
void | analyzeHeader ()
bool | readHeader (TextStream *line_reader)

Protected Attributes

std::vector< ref< PlyElement > > | mElements
ref< ArrayFVec3 > mVerts
ref< ArrayFVec3 > mNormals
ref< ArrayUBVec4 > mColors
std::vector< unsigned int > | mIndices
int | mVertexIndex
bool | mBinary
bool | mLittleEndian

Detailed Description

Loads a PLY file.

Member Enumeration Documentation

enum vl::PlyLoader::EType

Enumerator:
PlyError
PlyChar
PlyUChar
PlyShort
PlyUShort
PlyInt
PlyUInt
PlyFloat
PlyDouble

Constructor & Destructor Documentation

vl::PlyLoader::PlyLoader ( ) [inline]

Constructor.

Member Function Documentation

ref< ResourceDatabase > PlyLoader::loadPly ( VirtualFile * file )

Loads a PLY file.

const std::vector< ref<PlyElement> >& vl::PlyLoader::elements ( ) const [inline]

std::vector< ref<PlyElement> >& vl::PlyLoader::elements ( ) [inline]

bool vl::PlyLoader::binary ( ) const [inline]

bool vl::PlyLoader::littleEndian ( ) const [inline]

void PlyLoader::readElements ( VirtualFile * file )

void PlyLoader::readElements ( TextStream * text )

void PlyLoader::newElement ( PlyElement * el )

PlyLoader::EType PlyLoader::translateType ( const String & type )

void PlyLoader::analyzeHeader ( )

bool PlyLoader::readHeader ( TextStream * line_reader )

Member Data Documentation

std::vector< ref<PlyElement> > vl::PlyLoader::mElements [protected]

ref<ArrayFVec3> vl::PlyLoader::mVerts [protected]

ref<ArrayFVec3> vl::PlyLoader::mNormals [protected]

ref<ArrayUBVec4> vl::PlyLoader::mColors [protected]

std::vector<unsigned int> vl::PlyLoader::mIndices [protected]

int vl::PlyLoader::mVertexIndex [protected]

bool vl::PlyLoader::mBinary [protected]

bool vl::PlyLoader::mLittleEndian [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::PlyLoader::PlyElement Class Reference

vl::PlyLoader::PlyElement

vl::PlyLoader::PlyElement Class Reference

Used by PlyLoader. More...

#include <vlPLY.hpp>

Inheritance diagram for vl::PlyLoader::PlyElement:

vl::Object

List of all members.

Public Member Functions

PlyElement ()
const String & | name () const
void | setName (const String &name)
const std::vector< ref
< PlyPropertyAbstract > > & 		properties () const
std::vector< ref
< PlyPropertyAbstract > > & 		properties ()
int | elemCount () const
void | setElemCount (int count)
virtual void | read (VirtualFile *file, bool le)
virtual void | read (TextStream *text)
fvec3 | getVertex () const
fvec3 | getNormal () const
ubvec4 | getColor () const
void | analyze ()

Protected Attributes

std::vector< ref
< PlyPropertyAbstract > > 		mProperties
std::vector< ref< PlyScalar > > | mVertex
std::vector< ref< PlyScalar > > | mNormal
std::vector< ref< PlyScalar > > | mColor
String mName
int | mElemCount

Detailed Description

Used by PlyLoader.

Constructor & Destructor Documentation

vl::PlyLoader::PlyElement::PlyElement ( ) [inline]

Member Function Documentation

const String& vl::PlyLoader::PlyElement::name ( ) const [inline]

Reimplemented from vl::Object.

void vl::PlyLoader::PlyElement::setName ( const String & name ) [inline]

const std::vector< ref<PlyPropertyAbstract> >& vl::PlyLoader::PlyElement::properties ( ) const [inline]

std::vector< ref<PlyPropertyAbstract> >& vl::PlyLoader::PlyElement::properties ( ) [inline]

int vl::PlyLoader::PlyElement::elemCount ( ) const [inline]

void vl::PlyLoader::PlyElement::setElemCount ( int count ) [inline]

virtual void vl::PlyLoader::PlyElement::read | ( | VirtualFile * | file,
 |  | bool | le |
 | ) |  |  | [inline, virtual]

virtual void vl::PlyLoader::PlyElement::read ( TextStream * text ) [inline, virtual]

fvec3 vl::PlyLoader::PlyElement::getVertex ( ) const [inline]

fvec3 vl::PlyLoader::PlyElement::getNormal ( ) const [inline]

ubvec4 vl::PlyLoader::PlyElement::getColor ( ) const [inline]

void PlyLoader::PlyElement::analyze ( )

Member Data Documentation

std::vector< ref<PlyPropertyAbstract> > vl::PlyLoader::PlyElement::mProperties [protected]

std::vector< ref<PlyScalar> > vl::PlyLoader::PlyElement::mVertex [protected]

std::vector< ref<PlyScalar> > vl::PlyLoader::PlyElement::mNormal [protected]

std::vector< ref<PlyScalar> > vl::PlyLoader::PlyElement::mColor [protected]

String vl::PlyLoader::PlyElement::mName [protected]

Reimplemented from vl::Object.

int vl::PlyLoader::PlyElement::mElemCount [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::PlyLoader::PlyPropertyAbstract Class Reference

vl::PlyLoader::PlyPropertyAbstract

vl::PlyLoader::PlyPropertyAbstract Class Reference

Used by PlyLoader. More...

#include <vlPLY.hpp>

Inheritance diagram for vl::PlyLoader::PlyPropertyAbstract:

vl::Object vl::PlyLoader::PlyScalar vl::PlyLoader::PlyScalarList

List of all members.

Public Member Functions

const String & | name () const
void | setName (const String &name)
virtual void | read (VirtualFile *, bool le)=0
virtual void | read (TextStream *text)=0

Protected Attributes

String mName

Detailed Description

Used by PlyLoader.

Member Function Documentation

const String& vl::PlyLoader::PlyPropertyAbstract::name ( ) const [inline]

Reimplemented from vl::Object.

void vl::PlyLoader::PlyPropertyAbstract::setName ( const String & name ) [inline]

virtual void vl::PlyLoader::PlyPropertyAbstract::read | ( | VirtualFile * | ,
 |  | bool | le |
 | ) |  |  | [pure virtual]

Implemented in vl::PlyLoader::PlyScalar, and vl::PlyLoader::PlyScalarList.

virtual void vl::PlyLoader::PlyPropertyAbstract::read ( TextStream * text ) [pure virtual]

Implemented in vl::PlyLoader::PlyScalar, and vl::PlyLoader::PlyScalarList.

Member Data Documentation

String vl::PlyLoader::PlyPropertyAbstract::mName [protected]

Reimplemented from vl::Object.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::PlyLoader::PlyScalar Class Reference

vl::PlyLoader::PlyScalar

vl::PlyLoader::PlyScalar Class Reference

Used by PlyLoader. More...

#include <vlPLY.hpp>

Inheritance diagram for vl::PlyLoader::PlyScalar:

vl::PlyLoader::PlyPropertyAbstract vl::Object

List of all members.

Public Member Functions

PlyScalar ()
void | setScalarType (EType type)
EType | scalarType () const
virtual void | read (VirtualFile *file, bool le)
virtual void | read (TextStream *text)
float | getAsFloat () const
int | getAsInt () const

Protected Attributes

union {
char mChar
unsigned char mUChar
short mShort
unsigned short mUShort
int mInt
unsigned int mUInt
float mFloat
double mDouble
} mData
EType mScalarType

Detailed Description

Used by PlyLoader.

Constructor & Destructor Documentation

vl::PlyLoader::PlyScalar::PlyScalar ( ) [inline]

Member Function Documentation

void vl::PlyLoader::PlyScalar::setScalarType ( EType type ) [inline]

EType vl::PlyLoader::PlyScalar::scalarType ( ) const [inline]

void PlyLoader::PlyScalar::read | ( | VirtualFile * | file,
 |  | bool | le |
 | ) |  |  | [virtual]

Implements vl::PlyLoader::PlyPropertyAbstract.

void PlyLoader::PlyScalar::read ( TextStream * text ) [virtual]

Implements vl::PlyLoader::PlyPropertyAbstract.

float PlyLoader::PlyScalar::getAsFloat ( ) const

int PlyLoader::PlyScalar::getAsInt ( ) const

Member Data Documentation

char vl::PlyLoader::PlyScalar::mChar

unsigned char vl::PlyLoader::PlyScalar::mUChar

short vl::PlyLoader::PlyScalar::mShort

unsigned short vl::PlyLoader::PlyScalar::mUShort

int vl::PlyLoader::PlyScalar::mInt

unsigned int vl::PlyLoader::PlyScalar::mUInt

float vl::PlyLoader::PlyScalar::mFloat

double vl::PlyLoader::PlyScalar::mDouble

union { ... } vl::PlyLoader::PlyScalar::mData [protected]

EType vl::PlyLoader::PlyScalar::mScalarType [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::PlyLoader::PlyScalarList Class Reference

vl::PlyLoader::PlyScalarList

vl::PlyLoader::PlyScalarList Class Reference

Used by PlyLoader. More...

#include <vlPLY.hpp>

Inheritance diagram for vl::PlyLoader::PlyScalarList:

vl::PlyLoader::PlyPropertyAbstract vl::Object

List of all members.

Public Member Functions

PlyScalarList ()
void | setCountType (EType type)
EType | countType () const
void | setScalarType (EType type)
EType | scalarType () const
const std::vector< PlyScalar > & | scalars () const
std::vector< PlyScalar > & | scalars ()
virtual void | read (VirtualFile *file, bool le)
virtual void | read (TextStream *text)

Protected Attributes

std::vector< PlyScalar > | mScalars
EType mScalarType
EType mCountType

Detailed Description

Used by PlyLoader.

Constructor & Destructor Documentation

vl::PlyLoader::PlyScalarList::PlyScalarList ( ) [inline]

Member Function Documentation

void vl::PlyLoader::PlyScalarList::setCountType ( EType type ) [inline]

EType vl::PlyLoader::PlyScalarList::countType ( ) const [inline]

void vl::PlyLoader::PlyScalarList::setScalarType ( EType type ) [inline]

EType vl::PlyLoader::PlyScalarList::scalarType ( ) const [inline]

const std::vector<PlyScalar>& vl::PlyLoader::PlyScalarList::scalars ( ) const [inline]

std::vector<PlyScalar>& vl::PlyLoader::PlyScalarList::scalars ( ) [inline]

virtual void vl::PlyLoader::PlyScalarList::read | ( | VirtualFile * | file,
 |  | bool | le |
 | ) |  |  | [inline, virtual]

Implements vl::PlyLoader::PlyPropertyAbstract.

virtual void vl::PlyLoader::PlyScalarList::read ( TextStream * text ) [inline, virtual]

Implements vl::PlyLoader::PlyPropertyAbstract.

Member Data Documentation

std::vector<PlyScalar> vl::PlyLoader::PlyScalarList::mScalars [protected]

EType vl::PlyLoader::PlyScalarList::mScalarType [protected]

EType vl::PlyLoader::PlyScalarList::mCountType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::PointParameter Class Reference

vl::PointParameter

vl::PointParameter Class Reference

Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PointParameter:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PointParameter (float sizemin=0, float sizemax=1024.0f, float fadethresholdsize=1.0f, fvec3 distanceattenuation=fvec3(1, 0, 0))
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (float sizemin, float sizemax, float fadethresholdsize, fvec3 distanceattenuation)
void | setDistanceAttenuation (fvec3 attenuation)
void | setSizeMin (float sizemin)
void | setSizeMax (float sizemax)
void | setFadeThresholdSize (float threshold)
fvec3 | distanceAttenuation () const
float | sizeMin () const
float | sizeMax () const
float | fadeThresholdSize () const

Protected Attributes

fvec3 mDistanceAttenuation
float | mSizeMin
float | mSizeMax
float | mFadeThresholdSize

Detailed Description

Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::PointParameter::PointParameter | ( | float | sizemin = 0,
 |  | float | sizemax = 1024.0f,
 |  | float | fadethresholdsize = 1.0f,
 |  | fvec3 | distanceattenuation = fvec3(1,0,0) |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::PointParameter::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PointParameter::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PointParameter::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::PointParameter::set | ( | float | sizemin,
 |  | float | sizemax,
 |  | float | fadethresholdsize,
 |  | fvec3 | distanceattenuation |
 | ) |  |  | [inline]

void vl::PointParameter::setDistanceAttenuation ( fvec3 attenuation ) [inline]

void vl::PointParameter::setSizeMin ( float sizemin ) [inline]

void vl::PointParameter::setSizeMax ( float sizemax ) [inline]

void vl::PointParameter::setFadeThresholdSize ( float threshold ) [inline]

fvec3 vl::PointParameter::distanceAttenuation ( ) const [inline]

float vl::PointParameter::sizeMin ( ) const [inline]

float vl::PointParameter::sizeMax ( ) const [inline]

float vl::PointParameter::fadeThresholdSize ( ) const [inline]

Member Data Documentation

fvec3 vl::PointParameter::mDistanceAttenuation [protected]

float vl::PointParameter::mSizeMin [protected]

float vl::PointParameter::mSizeMax [protected]

float vl::PointParameter::mFadeThresholdSize [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::PointSize Class Reference

vl::PointSize

vl::PointSize Class Reference

Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PointSize:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PointSize (float pointsize=1.0f)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (float pointsize)
float | pointSize () const

Protected Attributes

float | mPointSize

Detailed Description

Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_POINT_SMOOTH, vl::EN_POINT_SPRITE

Constructor & Destructor Documentation

vl::PointSize::PointSize ( float pointsize = 1.0f ) [inline]

Member Function Documentation

virtual const char* vl::PointSize::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PointSize::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PointSize::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::PointSize::set ( float pointsize ) [inline]

float vl::PointSize::pointSize ( ) const [inline]

Member Data Documentation

float vl::PointSize::mPointSize [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::PolygonMode Class Reference

vl::PolygonMode

vl::PolygonMode Class Reference

Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PolygonMode:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PolygonMode (EPolygonMode frontface=PM_FILL, EPolygonMode backface=PM_FILL)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EPolygonMode frontface, EPolygonMode backface)
void | setFrontFace (EPolygonMode frontface)
void | setBackFace (EPolygonMode backface)
EPolygonMode | frontFace () const
EPolygonMode | backFace () const

Protected Attributes

EPolygonMode mFrontFace
EPolygonMode mBackFace

Detailed Description

Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::PolygonMode::PolygonMode | ( | EPolygonMode | frontface = PM_FILL,
 |  | EPolygonMode | backface = PM_FILL |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::PolygonMode::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PolygonMode::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PolygonMode::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::PolygonMode::set | ( | EPolygonMode | frontface,
 |  | EPolygonMode | backface |
 | ) |  |  | [inline]

void vl::PolygonMode::setFrontFace ( EPolygonMode frontface ) [inline]

void vl::PolygonMode::setBackFace ( EPolygonMode backface ) [inline]

EPolygonMode vl::PolygonMode::frontFace ( ) const [inline]

EPolygonMode vl::PolygonMode::backFace ( ) const [inline]

Member Data Documentation

EPolygonMode vl::PolygonMode::mFrontFace [protected]

EPolygonMode vl::PolygonMode::mBackFace [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::PolygonOffset Class Reference

vl::PolygonOffset

vl::PolygonOffset Class Reference

Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PolygonOffset:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PolygonOffset ()
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
PolygonOffset (float factor, float units)
virtual void | apply (const Camera *) const
void | set (float factor, float units)
void | setFactor (float factor)
void | setUnits (float units)
float | factor () const
float | units () const

Protected Attributes

float | mFactor
float | mUnits

Detailed Description

Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_POLYGON_OFFSET_FILL, vl::EN_POLYGON_OFFSET_LINE, vl::EN_POLYGON_OFFSET_POINT

Constructor & Destructor Documentation

vl::PolygonOffset::PolygonOffset ( ) [inline]

vl::PolygonOffset::PolygonOffset | ( | float | factor,
 |  | float | units |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::PolygonOffset::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PolygonOffset::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PolygonOffset::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::PolygonOffset::set | ( | float | factor,
 |  | float | units |
 | ) |  |  | [inline]

void vl::PolygonOffset::setFactor ( float factor ) [inline]

void vl::PolygonOffset::setUnits ( float units ) [inline]

float vl::PolygonOffset::factor ( ) const [inline]

float vl::PolygonOffset::units ( ) const [inline]

Member Data Documentation

float vl::PolygonOffset::mFactor [protected]

float vl::PolygonOffset::mUnits [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::PolygonSimplifier Class Reference

vl::PolygonSimplifier

vl::PolygonSimplifier Class Reference

The PolygonSimplifier class reduces the amount of polygons present in a Geometry using a quadric error metric. More...

#include <PolygonSimplifier.hpp>

Inheritance diagram for vl::PolygonSimplifier:

vl::Object

List of all members.

Classes

class | QErr
The quadric error metric as defined by PolygonSimplifier. More...
class | Triangle
A Triangle as defined by PolygonSimplifier. More...
class | Vertex
A Vertex as defined by PolygonSimplifier. More...

Public Member Functions

PolygonSimplifier ()
virtual const char * | className ()
Returns the name of the class.
void | simplify (float simplification_ratio, Geometry *geom)
void | simplify (int target_vertex_count, Geometry *geom)
void | simplify (int target_vertex_count, std::vector< fvec3 > &in_out_verts, std::vector< int > &in_out_tris)
void | setProtectedVertices (const std::vector< int > &protected_verts)
int | simplifiedVerticesCount () const
Vertex * | simplifiedVertices (int index) const
int | simplifiedTrianglesCount () const
Triangle * | simplifiedTriangles (int index) const
void | clearTrianglesAndVertices ()
bool | removeDoubles () const
void | setRemoveDoubles (bool remove_doubles)
bool | verbose () const
void | setVerbose (bool verbose)
bool | quick () const
void | setQuick (bool quick)

Protected Member Functions

void | collapse (Vertex *v)
void | computeCollapseInfo (Vertex *v)

Protected Attributes

std::vector< Vertex * > | mSimplifiedVertices
std::vector< Triangle * > | mSimplifiedTriangles
std::vector< int > | mProtectedVerts
bool | mRemoveDoubles
bool | mVerbose
bool | mQuick

Detailed Description

The PolygonSimplifier class reduces the amount of polygons present in a Geometry using a quadric error metric.

The algorithm simplifies only the position array of the Geometry all the other vertex attributes will be discarded.

Constructor & Destructor Documentation

vl::PolygonSimplifier::PolygonSimplifier ( ) [inline]

Member Function Documentation

virtual const char* vl::PolygonSimplifier::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void PolygonSimplifier::simplify | ( | float | simplification_ratio,
 |  | Geometry * | geom
 | ) |  |

void PolygonSimplifier::simplify | ( | int | target_vertex_count,
 |  | Geometry * | geom
 | ) |  |

void PolygonSimplifier::simplify | ( | int | target_vertex_count,
 |  | std::vector< fvec3 > & | in_out_verts,
 |  | std::vector< int > & | in_out_tris
 | ) |  |

void vl::PolygonSimplifier::setProtectedVertices ( const std::vector< int > & protected_verts ) [inline]

int vl::PolygonSimplifier::simplifiedVerticesCount ( ) const [inline]

Vertex* vl::PolygonSimplifier::simplifiedVertices ( int index ) const [inline]

int vl::PolygonSimplifier::simplifiedTrianglesCount ( ) const [inline]

Triangle* vl::PolygonSimplifier::simplifiedTriangles ( int index ) const [inline]

void PolygonSimplifier::clearTrianglesAndVertices ( )

bool vl::PolygonSimplifier::removeDoubles ( ) const [inline]

void vl::PolygonSimplifier::setRemoveDoubles ( bool remove_doubles ) [inline]

bool vl::PolygonSimplifier::verbose ( ) const [inline]

void vl::PolygonSimplifier::setVerbose ( bool verbose ) [inline]

bool vl::PolygonSimplifier::quick ( ) const [inline]

void vl::PolygonSimplifier::setQuick ( bool quick ) [inline]

void vl::PolygonSimplifier::collapse ( Vertex * v ) [inline, protected]

void vl::PolygonSimplifier::computeCollapseInfo ( Vertex * v ) [inline, protected]

Member Data Documentation

std::vector<Vertex*> vl::PolygonSimplifier::mSimplifiedVertices [protected]

std::vector<Triangle*> vl::PolygonSimplifier::mSimplifiedTriangles [protected]

std::vector<int> vl::PolygonSimplifier::mProtectedVerts [protected]

bool vl::PolygonSimplifier::mRemoveDoubles [protected]

bool vl::PolygonSimplifier::mVerbose [protected]

bool vl::PolygonSimplifier::mQuick [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::PolygonSimplifier::QErr Class Reference

vl::PolygonSimplifier::QErr

vl::PolygonSimplifier::QErr Class Reference

The quadric error metric as defined by PolygonSimplifier. More...

#include <PolygonSimplifier.hpp>

List of all members.

Public Member Functions

QErr ()
QErr (const dvec3 &n, double d, double w=1.0)
dmat3 | matrix () const
dvec3 | vector () const
double | offset () const
double | evaluate (const dvec3 &v) const
bool | analyticSolution (dvec3 &v) const
QErr | operator+ (const QErr &other)
const QErr & | operator+= (const QErr &other)

Protected Attributes

double | a2
double | ab
double | ac
double | ad
double | b2
double | bc
double | bd
double | c2
double | cd
double | d2

Detailed Description

The quadric error metric as defined by PolygonSimplifier.

Constructor & Destructor Documentation

vl::PolygonSimplifier::QErr::QErr ( ) [inline]

vl::PolygonSimplifier::QErr::QErr | ( | const dvec3 & | n,
 |  | double | d,
 |  | double | w = 1.0 |
 | ) |  |  | [inline]

Member Function Documentation

dmat3 vl::PolygonSimplifier::QErr::matrix ( ) const [inline]

dvec3 vl::PolygonSimplifier::QErr::vector ( ) const [inline]

double vl::PolygonSimplifier::QErr::offset ( ) const [inline]

double vl::PolygonSimplifier::QErr::evaluate ( const dvec3 & v ) const [inline]

bool vl::PolygonSimplifier::QErr::analyticSolution ( dvec3 & v ) const [inline]

QErr vl::PolygonSimplifier::QErr::operator+ ( const QErr & other ) [inline]

const QErr& vl::PolygonSimplifier::QErr::operator+= ( const QErr & other ) [inline]

Member Data Documentation

double vl::PolygonSimplifier::QErr::a2 [protected]

double vl::PolygonSimplifier::QErr::ab [protected]

double vl::PolygonSimplifier::QErr::ac [protected]

double vl::PolygonSimplifier::QErr::ad [protected]

double vl::PolygonSimplifier::QErr::b2 [protected]

double vl::PolygonSimplifier::QErr::bc [protected]

double vl::PolygonSimplifier::QErr::bd [protected]

double vl::PolygonSimplifier::QErr::c2 [protected]

double vl::PolygonSimplifier::QErr::cd [protected]

double vl::PolygonSimplifier::QErr::d2 [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::PolygonSimplifier::Triangle Class Reference

vl::PolygonSimplifier::Triangle

vl::PolygonSimplifier::Triangle Class Reference

A Triangle as defined by PolygonSimplifier. More...

#include <PolygonSimplifier.hpp>

List of all members.

Public Member Functions

Triangle ()
void | replaceVertex (Vertex *oldv, Vertex *newv)
void | computeNormal ()
float | computeArea () const
float | computePotentialArea (const Vertex *oldv, const Vertex *newv) const
fvec3 | computePotentialNormal (const Vertex *oldv, const Vertex *newv) const
bool | hasVertex (const Vertex *v) const
bool | checkTriangle () const
QErr | computeQErr () const
const Vertex * | vertex (int index) const
vertices of the triangle
Vertex * | vertex (int index)
const fvec3 & | normal () const
normal of the triangle
bool | removed () const
ara of the triangle

Protected Attributes

Vertex * | mVertices [3]
generates the QErr
fvec3 mNormal
normal of the triangle
bool | mRemoved
ara of the triangle

Friends

class | PolygonSimplifier
class | Vertex

Detailed Description

A Triangle as defined by PolygonSimplifier.

Constructor & Destructor Documentation

vl::PolygonSimplifier::Triangle::Triangle ( ) [inline]

Member Function Documentation

void vl::PolygonSimplifier::Triangle::replaceVertex | ( | Vertex * | oldv,
 |  | Vertex * | newv |
 | ) |  |  | [inline]

void vl::PolygonSimplifier::Triangle::computeNormal ( ) [inline]

float vl::PolygonSimplifier::Triangle::computeArea ( ) const [inline]

float vl::PolygonSimplifier::Triangle::computePotentialArea | ( | const Vertex * | oldv,
 |  | const Vertex * | newv |
 | ) |  |  | const [inline]

fvec3 vl::PolygonSimplifier::Triangle::computePotentialNormal | ( | const Vertex * | oldv,
 |  | const Vertex * | newv |
 | ) |  |  | const [inline]

bool vl::PolygonSimplifier::Triangle::hasVertex ( const Vertex * v ) const [inline]

bool vl::PolygonSimplifier::Triangle::checkTriangle ( ) const [inline]

PolygonSimplifier::QErr vl::PolygonSimplifier::Triangle::computeQErr ( ) const [inline]

const Vertex* vl::PolygonSimplifier::Triangle::vertex ( int index ) const [inline]

vertices of the triangle

Vertex* vl::PolygonSimplifier::Triangle::vertex ( int index ) [inline]

const fvec3& vl::PolygonSimplifier::Triangle::normal ( ) const [inline]

normal of the triangle

bool vl::PolygonSimplifier::Triangle::removed ( ) const [inline]

ara of the triangle

has this triangle been removed?

Friends And Related Function Documentation

friend class PolygonSimplifier [friend]

friend class Vertex [friend]

Member Data Documentation

Vertex* vl::PolygonSimplifier::Triangle::mVertices[3] [protected]

generates the QErr

vertices of the triangle

fvec3 vl::PolygonSimplifier::Triangle::mNormal [protected]

normal of the triangle

bool vl::PolygonSimplifier::Triangle::mRemoved [protected]

ara of the triangle

has this triangle been removed?

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::PolygonSimplifier::Vertex Class Reference

vl::PolygonSimplifier::Vertex

vl::PolygonSimplifier::Vertex Class Reference

A Vertex as defined by PolygonSimplifier. More...

#include <PolygonSimplifier.hpp>

List of all members.

Public Member Functions

Vertex ()
void | addAdjacentVertex (Vertex *v)
void | removeAdjacentVertex (Vertex *v)
void | computeAdjacentVertices ()
bool | checkConnectivity ()
bool | isAdjacentVertex (Vertex *) const
bool | isIncidentTriangle (Triangle *) const
void | discardRemovedTriangles ()
void | removeIncidentTriangle (const Triangle *)
bool | checkTriangles () const
void | computeEdgePenalty ()
const fvec3 & | position () const
the position
int | adjacentVerticesCount () const
ajacent vertices
Vertex * | adjacentVertex (int index) const
int | incidentTrianglesCount () const
adjacent triangles
Triangle * | incidentTriangle (int index) const
Vertex * | collapseVertex () const
vertex to which collapse
float | collapseCost () const
cost of the collapse
const fvec3 & | collapsePosition () const
collapse position
void | setCollapsePosition (const fvec3 &pos)
int | removeOrder () const
when the vertex has collapsed
bool | removed () const
has the vertex been removed
bool | isProtected () const
is the vertex protected?
int | originalIndex () const
original index of this vertex
int | simplifiedIndex () const
Internally used to regenerated the index buffer.
bool | alreadyProcessed () const
Internally used.
const QErr & | qerr () const
Accumulated vertex error.
void | setQErr (const QErr &qerr)
void | addQErr (const QErr &qerr)

Protected Attributes

QErr mQErr
fvec3 mPosition
the position
std::vector< Vertex * > | mAdjacentVerts
ajacent vertices
std::vector< Triangle * > | mIncidentTriangles
adjacent triangles
Vertex * mCollapseVertex
vertex to which collapse
float | mCollapseCost
cost of the collapse
fvec3 mCollapsePosition
the collapse position
int | mOriginalIndex
original index of this vertex
int | mSimplifiedIndex
only used during index buffer regeneration
int | mRemoveOrder
when the vertex has collapsed
bool | mRemoved
has the vertex been removed
bool | mProtected
is the vertex protected?
bool | mAlreadyProcessed
internally used

Friends

class | Triangle
class | PolygonSimplifier

Detailed Description

A Vertex as defined by PolygonSimplifier.

Constructor & Destructor Documentation

vl::PolygonSimplifier::Vertex::Vertex ( ) [inline]

Member Function Documentation

void vl::PolygonSimplifier::Vertex::addAdjacentVertex ( Vertex * v ) [inline]

void vl::PolygonSimplifier::Vertex::removeAdjacentVertex ( Vertex * v ) [inline]

void vl::PolygonSimplifier::Vertex::computeAdjacentVertices ( ) [inline]

bool vl::PolygonSimplifier::Vertex::checkConnectivity ( ) [inline]

bool vl::PolygonSimplifier::Vertex::isAdjacentVertex ( Vertex * v ) const [inline]

bool vl::PolygonSimplifier::Vertex::isIncidentTriangle ( Triangle * t ) const [inline]

void vl::PolygonSimplifier::Vertex::discardRemovedTriangles ( ) [inline]

void vl::PolygonSimplifier::Vertex::removeIncidentTriangle ( const Triangle * tri ) [inline]

bool vl::PolygonSimplifier::Vertex::checkTriangles ( ) const [inline]

void vl::PolygonSimplifier::Vertex::computeEdgePenalty ( ) [inline]

const fvec3& vl::PolygonSimplifier::Vertex::position ( ) const [inline]

the position

int vl::PolygonSimplifier::Vertex::adjacentVerticesCount ( ) const [inline]

ajacent vertices

Vertex* vl::PolygonSimplifier::Vertex::adjacentVertex ( int index ) const [inline]

int vl::PolygonSimplifier::Vertex::incidentTrianglesCount ( ) const [inline]

adjacent triangles

Triangle* vl::PolygonSimplifier::Vertex::incidentTriangle ( int index ) const [inline]

Vertex* vl::PolygonSimplifier::Vertex::collapseVertex ( ) const [inline]

vertex to which collapse

float vl::PolygonSimplifier::Vertex::collapseCost ( ) const [inline]

cost of the collapse

const fvec3& vl::PolygonSimplifier::Vertex::collapsePosition ( ) const [inline]

collapse position

void vl::PolygonSimplifier::Vertex::setCollapsePosition ( const fvec3 & pos ) [inline]

int vl::PolygonSimplifier::Vertex::removeOrder ( ) const [inline]

when the vertex has collapsed

bool vl::PolygonSimplifier::Vertex::removed ( ) const [inline]

has the vertex been removed

bool vl::PolygonSimplifier::Vertex::isProtected ( ) const [inline]

is the vertex protected?

int vl::PolygonSimplifier::Vertex::originalIndex ( ) const [inline]

original index of this vertex

int vl::PolygonSimplifier::Vertex::simplifiedIndex ( ) const [inline]

Internally used to regenerated the index buffer.

bool vl::PolygonSimplifier::Vertex::alreadyProcessed ( ) const [inline]

Internally used.

const QErr& vl::PolygonSimplifier::Vertex::qerr ( ) const [inline]

Accumulated vertex error.

void vl::PolygonSimplifier::Vertex::setQErr ( const QErr & qerr ) [inline]

void vl::PolygonSimplifier::Vertex::addQErr ( const QErr & qerr ) [inline]

Friends And Related Function Documentation

friend class Triangle [friend]

friend class PolygonSimplifier [friend]

Member Data Documentation

QErr vl::PolygonSimplifier::Vertex::mQErr [protected]

fvec3 vl::PolygonSimplifier::Vertex::mPosition [protected]

the position

std::vector< Vertex* > vl::PolygonSimplifier::Vertex::mAdjacentVerts [protected]

ajacent vertices

std::vector< Triangle* > vl::PolygonSimplifier::Vertex::mIncidentTriangles [protected]

adjacent triangles

Vertex* vl::PolygonSimplifier::Vertex::mCollapseVertex [protected]

vertex to which collapse

float vl::PolygonSimplifier::Vertex::mCollapseCost [protected]

cost of the collapse

fvec3 vl::PolygonSimplifier::Vertex::mCollapsePosition [protected]

the collapse position

int vl::PolygonSimplifier::Vertex::mOriginalIndex [protected]

original index of this vertex

int vl::PolygonSimplifier::Vertex::mSimplifiedIndex [protected]

only used during index buffer regeneration

int vl::PolygonSimplifier::Vertex::mRemoveOrder [protected]

when the vertex has collapsed

bool vl::PolygonSimplifier::Vertex::mRemoved [protected]

has the vertex been removed

bool vl::PolygonSimplifier::Vertex::mProtected [protected]

is the vertex protected?

bool vl::PolygonSimplifier::Vertex::mAlreadyProcessed [protected]

internally used

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::PolygonStipple Class Reference

vl::PolygonStipple

vl::PolygonStipple Class Reference

Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::PolygonStipple:

vl::RenderState vl::Object

List of all members.

Public Member Functions

PolygonStipple ()
PolygonStipple (const unsigned char *mask)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (const unsigned char *mask)
const unsigned char * | mask () const

Protected Attributes

unsigned char | mMask [32 *32/8]

Detailed Description

Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_POLYGON_STIPPLE

Constructor & Destructor Documentation

PolygonStipple::PolygonStipple ( )

PolygonStipple::PolygonStipple ( const unsigned char * mask )

Member Function Documentation

virtual const char* vl::PolygonStipple::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::PolygonStipple::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void PolygonStipple::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void PolygonStipple::set ( const unsigned char * mask )

const unsigned char* vl::PolygonStipple::mask ( ) const [inline]

Member Data Documentation

unsigned char vl::PolygonStipple::mMask[32 *32/8] [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Portal Class Reference

vl::Portal

vl::Portal Class Reference

A planar convex polygon used to define the visibility from one Sector to another. More...

#include <SceneManagerPortals.hpp>

Inheritance diagram for vl::Portal:

vl::Object

List of all members.

Public Member Functions

Portal ()
Constructor.
std::vector< fvec3 > & | geometry ()
The set of points defining the shape of the portal. The points must define a planar convex polygon and must be in world coordinates.
const std::vector< fvec3 > & | geometry () const
The set of points defining the shape of the portal. The points must define a planar convex polygon and must be in world coordinates.
void | setTargetSector (Sector *sector)
The Sector that is behind the portal and that is seen through the portal.
Sector * targetSector ()
The Sector that is behind the portal and that is seen through the portal.
const Sector * | targetSector () const
The Sector that is behind the portal and that is seen through the portal.
bool | isOpen () const
If a Portal is closed or open. If the portal is closed then the camera cannot see the targetSector() through this portal.
void | setIsOpen (bool is_open)
If a Portal is closed or open. If the portal is closed then the camera cannot see the targetSector() through this portal.

Protected Member Functions

void | setNormal (const fvec3 &n)
Used internally.
const fvec3 & | normal () const
Used internally.
bool | computeNormal ()
Computes the normal of the portal polygon.

Protected Attributes

std::vector< fvec3 > | mPortalGeometry
ref< Sector > mTargetSector
fvec3 mNormal
unsigned int | mVisitTick
bool | mIsOpen

Friends

class | SceneManagerPortals

Detailed Description

A planar convex polygon used to define the visibility from one Sector to another.

See also:

  • SceneManagerPortals
  • Sector
  • Portal-Based Culling and Scene Management Tutorial

Constructor & Destructor Documentation

vl::Portal::Portal ( ) [inline]

Constructor.

Member Function Documentation

std::vector<fvec3>& vl::Portal::geometry ( ) [inline]

The set of points defining the shape of the portal. The points must define a planar convex polygon and must be in world coordinates.

const std::vector<fvec3>& vl::Portal::geometry ( ) const [inline]

The set of points defining the shape of the portal. The points must define a planar convex polygon and must be in world coordinates.

void vl::Portal::setTargetSector ( Sector * sector ) [inline]

The Sector that is behind the portal and that is seen through the portal.

Sector* vl::Portal::targetSector ( ) [inline]

The Sector that is behind the portal and that is seen through the portal.

const Sector* vl::Portal::targetSector ( ) const [inline]

The Sector that is behind the portal and that is seen through the portal.

bool vl::Portal::isOpen ( ) const [inline]

If a Portal is closed or open. If the portal is closed then the camera cannot see the targetSector() through this portal.

void vl::Portal::setIsOpen ( bool is_open ) [inline]

If a Portal is closed or open. If the portal is closed then the camera cannot see the targetSector() through this portal.

void vl::Portal::setNormal ( const fvec3 & n ) [inline, protected]

Used internally.

const fvec3& vl::Portal::normal ( ) const [inline, protected]

Used internally.

bool Portal::computeNormal ( ) [protected]

Computes the normal of the portal polygon.

Must be called after all the sectors have been setup, linked to their portal, and their AABB has been updated.

Friends And Related Function Documentation

friend class SceneManagerPortals [friend]

Member Data Documentation

std::vector<fvec3> vl::Portal::mPortalGeometry [protected]

ref<Sector> vl::Portal::mTargetSector [protected]

fvec3 vl::Portal::mNormal [protected]

unsigned int vl::Portal::mVisitTick [protected]

bool vl::Portal::mIsOpen [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::Primitives Class Reference

vl::Primitives

vl::Primitives Class Reference

This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays(). More...

#include <Primitives.hpp>

Inheritance diagram for vl::Primitives:

vl::Object vl::DrawArrays vl::DrawElements< index_type, Tgltype, arr_type >

List of all members.

Public Member Functions

Primitives ()
virtual const char * | className ()
Returns the name of the class.
virtual | ~Primitives ()
void | setPrimitiveType (EPrimitiveType type)
EPrimitiveType | primitiveType () const
virtual void | render (bool use_vbo=true) const =0
virtual ref< Primitives > | clone () const =0
virtual void | deleteVBOs ()=0
virtual void | updateVBOs (bool discard_local_data=false)=0
virtual unsigned int | handle () const =0
virtual unsigned int | indexCount () const =0
virtual unsigned int | index (int i) const =0
virtual int | triangleCount () const =0
virtual int | lineCount () const =0
virtual int | pointCount () const =0
virtual void | sortTriangles ()
Supported only by DrawElements.
int | instances () const
void | setInstances (int instances)
void | setEnabled (bool enable)
bool | isEnabled () const

Protected Attributes

EPrimitiveType mType
int | mInstances
bool | mEnabled

Detailed Description

This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays().

Constructor & Destructor Documentation

vl::Primitives::Primitives ( ) [inline]

virtual vl::Primitives::~Primitives ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::Primitives::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

void vl::Primitives::setPrimitiveType ( EPrimitiveType type ) [inline]

Reimplemented in vl::DrawElements< index_type, Tgltype, arr_type >.

EPrimitiveType vl::Primitives::primitiveType ( ) const [inline]

Reimplemented in vl::DrawElements< index_type, Tgltype, arr_type >.

virtual void vl::Primitives::render ( bool use_vbo = true ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual ref<Primitives> vl::Primitives::clone ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual void vl::Primitives::deleteVBOs ( ) [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual void vl::Primitives::updateVBOs ( bool discard_local_data = false ) [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual unsigned int vl::Primitives::handle ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual unsigned int vl::Primitives::indexCount ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual unsigned int vl::Primitives::index ( int i ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual int vl::Primitives::triangleCount ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual int vl::Primitives::lineCount ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual int vl::Primitives::pointCount ( ) const [pure virtual]

Implemented in vl::DrawArrays, and vl::DrawElements< index_type, Tgltype, arr_type >.

virtual void vl::Primitives::sortTriangles ( ) [inline, virtual]

Supported only by DrawElements.

Reimplemented in vl::DrawElements< index_type, Tgltype, arr_type >.

int vl::Primitives::instances ( ) const [inline]

void vl::Primitives::setInstances ( int instances ) [inline]

void vl::Primitives::setEnabled ( bool enable ) [inline]

bool vl::Primitives::isEnabled ( ) const [inline]

Member Data Documentation

EPrimitiveType vl::Primitives::mType [protected]

int vl::Primitives::mInstances [protected]

bool vl::Primitives::mEnabled [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Primitives.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::quat Class Reference

vl::quat

vl::quat Class Reference

The quat class implements a quaternion using vl::Real precision. More...

#include <quat.hpp>

List of all members.

Public Member Functions

quat ()
quat (const vec4 &v)
quat (Real x, Real y, Real z, Real w)
quat (Real degrees, const vec3 &axis)
bool | operator== (const quat &q) const
bool | operator!= (const quat &q) const
bool | operator< (const vec4 &v) const
lexicographic ordering
quat & setZero ()
quat & setNoRotation ()
quat & | fromVectors (const vec4 &from, const vec4 &to)
quat & | fromVectors (const vec3 &from, const vec3 &to)
quat & | fromMatrix (const mat4 &m)
Creates a quaternion representing the given rotation matrix.
quat & | fromEulerXYZ (Real degX, Real degY, Real degZ)
quat & | fromEulerZYX (Real degZ, Real degY, Real degX)
quat & | fromAxisAngle (Real degrees, const vec3 &axis)
void | toAxisAngle (vec4 &axis, Real &angle) const
Expects a unit length quaternion.
mat4 | toMatrix () const
Expects a unit length quaternion.
const vec4 & | xyzw () const
vec4 & xyzw ()
Real & x ()
Real & y ()
Real & z ()
Real & w ()
const Real & | x () const
const Real & | y () const
const Real & | z () const
const Real & | w () const
quat | operator* (Real real) const
quat & | operator*= (Real real)
quat | operator/ (Real real) const
quat & | operator/= (Real real)
quat | operator+ (const quat &q) const
quat & | operator+= (const quat &q)
quat | operator- (const quat &q) const
quat & | operator-= (const quat &q)
quat | operator- () const
Real | dot (const quat &q) const
Real | length () const
const quat & | normalize ()
quat | getNormalized () const
Real | lengthSquared () const
quat | conjugate () const
quat | inverse () const
quat | slerp (Real t, const quat &a, const quat &b) const
Spherical linear interpolation of two quaternions.
quat | squad (Real t, const quat &a, const quat &p, const quat &q, const quat &b) const
Spherical cubic interpolation of two quaternions.
quat | nlerp (Real t, const quat &a, const quat &b) const
Normalized spherical interpolation of two quaternions.

Protected Attributes

vec4 mXYZW

Detailed Description

The quat class implements a quaternion using vl::Real precision.

Constructor & Destructor Documentation

vl::quat::quat ( ) [inline]

vl::quat::quat ( const vec4 & v ) [inline, explicit]

vl::quat::quat | ( | Real | x,
 |  | Real | y,
 |  | Real | z,
 |  | Real | w |
 | ) |  |  | [inline, explicit]

vl::quat::quat | ( | Real | degrees,
 |  | const vec3 & | axis |
 | ) |  |  | [inline, explicit]

Member Function Documentation

bool vl::quat::operator== ( const quat & q ) const [inline]

bool vl::quat::operator!= ( const quat & q ) const [inline]

bool vl::quat::operator< ( const vec4 & v ) const [inline]

lexicographic ordering

quat& vl::quat::setZero ( ) [inline]

quat& vl::quat::setNoRotation ( ) [inline]

quat& vl::quat::fromVectors | ( | const vec4 & | from,
 |  | const vec4 & | to |
 | ) |  |  | [inline]

quat & quat::fromVectors | ( | const vec3 & | from,
 |  | const vec3 & | to
 | ) |  |

quat & quat::fromMatrix ( const mat4 & m )

Creates a quaternion representing the given rotation matrix.

see also http://www.gamasutra.com/features/19980703/quaternions_01.htm

quat & quat::fromEulerXYZ | ( | Real | degX,
 |  | Real | degY,
 |  | Real | degZ
 | ) |  |

quat & quat::fromEulerZYX | ( | Real | degZ,
 |  | Real | degY,
 |  | Real | degX
 | ) |  |

quat & quat::fromAxisAngle | ( | Real | degrees,
 |  | const vec3 & | axis
 | ) |  |

void quat::toAxisAngle | ( | vec4 & | axis,
 |  | Real & | angle |
 | ) |  |  | const

Expects a unit length quaternion.

mat4 quat::toMatrix ( ) const

Expects a unit length quaternion.

const vec4& vl::quat::xyzw ( ) const [inline]

vec4& vl::quat::xyzw ( ) [inline]

Real& vl::quat::x ( ) [inline]

Real& vl::quat::y ( ) [inline]

Real& vl::quat::z ( ) [inline]

Real& vl::quat::w ( ) [inline]

const Real& vl::quat::x ( ) const [inline]

const Real& vl::quat::y ( ) const [inline]

const Real& vl::quat::z ( ) const [inline]

const Real& vl::quat::w ( ) const [inline]

quat vl::quat::operator* ( Real real ) const [inline]

quat& vl::quat::operator*= ( Real real ) [inline]

quat vl::quat::operator/ ( Real real ) const [inline]

quat& vl::quat::operator/= ( Real real ) [inline]

quat vl::quat::operator+ ( const quat & q ) const [inline]

quat& vl::quat::operator+= ( const quat & q ) [inline]

quat vl::quat::operator- ( const quat & q ) const [inline]

quat& vl::quat::operator-= ( const quat & q ) [inline]

quat vl::quat::operator- ( ) const [inline]

Real vl::quat::dot ( const quat & q ) const [inline]

Real vl::quat::length ( ) const [inline]

const quat& vl::quat::normalize ( ) [inline]

quat vl::quat::getNormalized ( ) const [inline]

Real vl::quat::lengthSquared ( ) const [inline]

quat vl::quat::conjugate ( ) const [inline]

quat vl::quat::inverse ( ) const [inline]

quat quat::slerp | ( | Real | t,
 |  | const quat & | a,
 |  | const quat & | b |
 | ) |  |  | const

Spherical linear interpolation of two quaternions.

See also http://www.gamasutra.com/features/19980703/quaternions_01.htm
Properties: NO commutative, YES torque-minimal, YES constant velocity.

quat vl::quat::squad | ( | Real | t,
 |  | const quat & | a,
 |  | const quat & | p,
 |  | const quat & | q,
 |  | const quat & | b |
 | ) |  |  | const [inline]

Spherical cubic interpolation of two quaternions.

quat vl::quat::nlerp | ( | Real | t,
 |  | const quat & | a,
 |  | const quat & | b |
 | ) |  |  | const [inline]

Normalized spherical interpolation of two quaternions.

See also http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
Properties: YES commutative, YES torque-minimal, NO constant velocity.

Member Data Documentation

vec4 vl::quat::mXYZW [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::Ray Class Reference

vl::Ray

vl::Ray Class Reference

The Ray class defines a ray as an origin and direction using Real precision. More...

#include <Ray.hpp>

List of all members.

Public Member Functions

const vec3 & | direction () const
const vec3 & | origin () const
void | setDirection (const vec3 &dir)
void | setOrigin (const vec3 &orig)

Protected Attributes

vec3 mDirection
vec3 mOrigin

Detailed Description

The Ray class defines a ray as an origin and direction using Real precision.

Member Function Documentation

const vec3& vl::Ray::direction ( ) const [inline]

const vec3& vl::Ray::origin ( ) const [inline]

void vl::Ray::setDirection ( const vec3 & dir ) [inline]

void vl::Ray::setOrigin ( const vec3 & orig ) [inline]

Member Data Documentation

vec3 vl::Ray::mDirection [protected]

vec3 vl::Ray::mOrigin [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Ray.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RayIntersection Class Reference

vl::RayIntersection

vl::RayIntersection Class Reference

The RayIntersection encapsulates all the information relative to a Ray/Actor intersection. More...

#include <RayIntersector.hpp>

Inheritance diagram for vl::RayIntersection:

vl::Object vl::RayIntersectionGeometry

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RayIntersection ()
void | setActor (Actor *a)
The intersected Actor.
const Actor * | actor () const
The intersected Actor.
Actor * actor ()
The intersected Actor.
const vec3 & | intersectionPoint () const
The intersection point, in world coordinates.
void | setIntersectionPoint (const vec3 &v)
The intersection point, in world coordinates.
float | distance () const
The intersection distance.
void | setDistance (float dist)
The intersection distance.

Protected Attributes

vec3 mIntersectionPoint
Actor * mActor
float | mDistance

Detailed Description

The RayIntersection encapsulates all the information relative to a Ray/Actor intersection.

Constructor & Destructor Documentation

vl::RayIntersection::RayIntersection ( ) [inline]

Member Function Documentation

virtual const char* vl::RayIntersection::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::RayIntersectionGeometry.

void vl::RayIntersection::setActor ( Actor * a ) [inline]

The intersected Actor.

const Actor* vl::RayIntersection::actor ( ) const [inline]

The intersected Actor.

Actor* vl::RayIntersection::actor ( ) [inline]

The intersected Actor.

const vec3& vl::RayIntersection::intersectionPoint ( ) const [inline]

The intersection point, in world coordinates.

void vl::RayIntersection::setIntersectionPoint ( const vec3 & v ) [inline]

The intersection point, in world coordinates.

float vl::RayIntersection::distance ( ) const [inline]

The intersection distance.

void vl::RayIntersection::setDistance ( float dist ) [inline]

The intersection distance.

Member Data Documentation

vec3 vl::RayIntersection::mIntersectionPoint [protected]

Reimplemented in vl::RayIntersectionGeometry.

Actor* vl::RayIntersection::mActor [protected]

float vl::RayIntersection::mDistance [protected]

Reimplemented in vl::RayIntersectionGeometry.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RayIntersectionGeometry Class Reference

vl::RayIntersectionGeometry

vl::RayIntersectionGeometry Class Reference

The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor. More...

#include <RayIntersector.hpp>

Inheritance diagram for vl::RayIntersectionGeometry:

vl::RayIntersection vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RayIntersectionGeometry ()
Geometry * geometry ()
The intersected Geometry.
const Geometry * | geometry () const
The intersected Geometry.
Primitives * primitives ()
The intersected Primitives.
const Primitives * | primitives () const
The intersected Primitives.
int | primitiveIndex () const
The starting index of the intersected primitive inside primitives().
void | setGeometry (Geometry *g)
The intersected Geometry.
void | setPrimitives (Primitives *p)
The intersected Primitives.
void | setPrimitiveIndex (int p_idx)
The starting index of the intersected primitive inside primitives().

Protected Attributes

vec3 mIntersectionPoint
Geometry * mGeometry
Primitives * mPrimitives
int | mPrimitiveIndex
float | mDistance

Detailed Description

The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor.

Constructor & Destructor Documentation

vl::RayIntersectionGeometry::RayIntersectionGeometry ( ) [inline]

Member Function Documentation

virtual const char* vl::RayIntersectionGeometry::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RayIntersection.

Geometry* vl::RayIntersectionGeometry::geometry ( ) [inline]

The intersected Geometry.

const Geometry* vl::RayIntersectionGeometry::geometry ( ) const [inline]

The intersected Geometry.

Primitives* vl::RayIntersectionGeometry::primitives ( ) [inline]

The intersected Primitives.

const Primitives* vl::RayIntersectionGeometry::primitives ( ) const [inline]

The intersected Primitives.

int vl::RayIntersectionGeometry::primitiveIndex ( ) const [inline]

The starting index of the intersected primitive inside primitives().

void vl::RayIntersectionGeometry::setGeometry ( Geometry * g ) [inline]

The intersected Geometry.

void vl::RayIntersectionGeometry::setPrimitives ( Primitives * p ) [inline]

The intersected Primitives.

void vl::RayIntersectionGeometry::setPrimitiveIndex ( int p_idx ) [inline]

The starting index of the intersected primitive inside primitives().

Member Data Documentation

vec3 vl::RayIntersectionGeometry::mIntersectionPoint [protected]

Reimplemented from vl::RayIntersection.

Geometry* vl::RayIntersectionGeometry::mGeometry [protected]

Primitives* vl::RayIntersectionGeometry::mPrimitives [protected]

int vl::RayIntersectionGeometry::mPrimitiveIndex [protected]

float vl::RayIntersectionGeometry::mDistance [protected]

Reimplemented from vl::RayIntersection.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RayIntersector Class Reference

vl::RayIntersector

vl::RayIntersector Class Reference

The RayIntersector class is used to detect the intersection points between a Ray and a set of Actor[s]. More...

#include <RayIntersector.hpp>

Inheritance diagram for vl::RayIntersector:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RayIntersector ()
const ActorCollection * | actors () const
The Actors against which the intersection test is performed.
ActorCollection * actors ()
The Actors against which the intersection test is performed.
const Ray & | ray () const
The ray in world coordinates to be intersected with the actors().
void | setRay (const Ray &ray)
The ray in world coordinates to be intersected with the actors().
const Frustum & | frustum () const
The frustum in world coordinates used to cull the objects.
void | setFrustum (const Frustum &frustum)
The frustum in world coordinates used to cull the objects.
const std::vector< ref
< RayIntersection > > & 		intersections () const
The intersection points detected by the last intersect() call sorted according to their distance (the first one is the closest).
void | intersect ()
Executes the intersection test.
void | intersect (const Ray &ray, SceneManager *scene_manager)
Computes the intersections between the given ray and the Actor[s] contained in the given scene manager.

Protected Member Functions

void | intersect (Actor *act)
void | intersectGeometry (Actor *act, Geometry *geom)
void | intersectTriangle (const fvec3 &a, const fvec3 &b, const fvec3 &c, Actor *, Geometry *geom, Primitives *prim, int prim_idx)
void | intersectPolygon (const std::vector< fvec3 > &polygon, Actor *, Geometry *geom, Primitives *prim)
void | intersectQuad (const fvec3 &a, const fvec3 &b, const fvec3 &c, const fvec3 &d, Actor *, Geometry *geom, Primitives *prim, int prim_idx)

Static Protected Member Functions

static bool | sorter (const ref< RayIntersection > a, const ref< RayIntersection > b)

Protected Attributes

Frustum mFrustum
std::vector< ref
< RayIntersection > > 		mIntersections
ref< ActorCollection > mActors
Ray mRay

Detailed Description

The RayIntersector class is used to detect the intersection points between a Ray and a set of Actor[s].

Constructor & Destructor Documentation

vl::RayIntersector::RayIntersector ( ) [inline]

Member Function Documentation

virtual const char* vl::RayIntersector::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

const ActorCollection* vl::RayIntersector::actors ( ) const [inline]

The Actors against which the intersection test is performed.

ActorCollection* vl::RayIntersector::actors ( ) [inline]

The Actors against which the intersection test is performed.

const Ray& vl::RayIntersector::ray ( ) const [inline]

The ray in world coordinates to be intersected with the actors().

void vl::RayIntersector::setRay ( const Ray & ray ) [inline]

The ray in world coordinates to be intersected with the actors().

const Frustum& vl::RayIntersector::frustum ( ) const [inline]

The frustum in world coordinates used to cull the objects.

void vl::RayIntersector::setFrustum ( const Frustum & frustum ) [inline]

The frustum in world coordinates used to cull the objects.

const std::vector< ref<RayIntersection> >& vl::RayIntersector::intersections ( ) const [inline]

The intersection points detected by the last intersect() call sorted according to their distance (the first one is the closest).

void RayIntersector::intersect ( )

Executes the intersection test.

Note:
Before calling this function the transforms and the bounding volumes of the Actor[s] to be intersected must be updated, in this order.

All the intersections are mande on the Actor's LOD level #0.

void RayIntersector::intersect | ( | const Ray & | ray,
 |  | SceneManager * | scene_manager
 | ) |  |

Computes the intersections between the given ray and the Actor[s] contained in the given scene manager.

This is an utility function equivalent to:

 intersector->actors()->clear();
 scene_manager->appendActors( *intersector->actors() );
 intersector->setRay(ray);
 intersector->intersect();

static bool vl::RayIntersector::sorter | ( | const ref< RayIntersection > | a,
 |  | const ref< RayIntersection > | b |
 | ) |  |  | [inline, static, protected]

void RayIntersector::intersect ( Actor * act ) [protected]

void RayIntersector::intersectGeometry | ( | Actor * | act,
 |  | Geometry * | geom |
 | ) |  |  | [protected]

void RayIntersector::intersectTriangle | ( | const fvec3 & | a,
 |  | const fvec3 & | b,
 |  | const fvec3 & | c,
 |  | Actor * | act,
 |  | Geometry * | geom,
 |  | Primitives * | prim,
 |  | int | prim_idx |
 | ) |  |  | [protected]

void RayIntersector::intersectPolygon | ( | const std::vector< fvec3 > & | polygon,
 |  | Actor * | act,
 |  | Geometry * | geom,
 |  | Primitives * | prim |
 | ) |  |  | [protected]

void RayIntersector::intersectQuad | ( | const fvec3 & | a,
 |  | const fvec3 & | b,
 |  | const fvec3 & | c,
 |  | const fvec3 & | d,
 |  | Actor * | act,
 |  | Geometry * | geom,
 |  | Primitives * | prim,
 |  | int | prim_idx |
 | ) |  |  | [protected]

Member Data Documentation

Frustum vl::RayIntersector::mFrustum [protected]

std::vector< ref<RayIntersection> > vl::RayIntersector::mIntersections [protected]

ref<ActorCollection> vl::RayIntersector::mActors [protected]

Ray vl::RayIntersector::mRay [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::ReadPixels Class Reference

vl::ReadPixels

vl::ReadPixels Class Reference

A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering. More...

#include <ReadPixels.hpp>

Inheritance diagram for vl::ReadPixels:

vl::RenderingCallback vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ReadPixels ()
ReadPixels (int x, int y, int width, int height, EReadDrawBuffer read_buffer, Image *image, bool store_in_pbo)
virtual bool | renderingCallback (const RenderingAbstract *, ERenderingCallback reason)
Implements the actual code to be executed upon callback activation.
void | setup (int x, int y, int width, int height, EReadDrawBuffer read_buffer, bool store_in_pbo)
void | setX (int x)
void | setY (int y)
void | setWidth (int width)
void | setHeight (int height)
void | setReadBuffer (EReadDrawBuffer buffer)
void | setImage (Image *image)
void | setSavePath (const String &path)
int | x () const
int | y () const
int | width () const
int | height () const
EReadDrawBuffer | readBuffer () const
Image * image ()
const Image * | image () const
const String & | savePath () const
void | setStoreInPixelBufferObject (bool use_pbo)
bool | storeInPixelBufferObject () const

Protected Attributes

int | mX
int | mY
int | mWidth
int | mHeight
EReadDrawBuffer mReadBuffer
ref< Image > mImage
String mSavePath
bool | mStoreInPixelBufferObject

Detailed Description

A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering.

The actual copy is performed using the function Image::readPixels(). Using the function setSavePath() the Image will be saved on the specified location.

See also:
  • Image
  • Image::readPixels()
  • RenderingCallback

Constructor & Destructor Documentation

vl::ReadPixels::ReadPixels ( ) [inline]

vl::ReadPixels::ReadPixels | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height,
 |  | EReadDrawBuffer | read_buffer,
 |  | Image * | image,
 |  | bool | store_in_pbo |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::ReadPixels::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderingCallback.

virtual bool vl::ReadPixels::renderingCallback | ( | const RenderingAbstract * | rendering,
 |  | ERenderingCallback | reason |
 | ) |  |  | [inline, virtual]

Implements the actual code to be executed upon callback activation.

Returns:
true if the callback reacted to the given reason

Implements vl::RenderingCallback.

void vl::ReadPixels::setup | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height,
 |  | EReadDrawBuffer | read_buffer,
 |  | bool | store_in_pbo |
 | ) |  |  | [inline]

void vl::ReadPixels::setX ( int x ) [inline]

void vl::ReadPixels::setY ( int y ) [inline]

void vl::ReadPixels::setWidth ( int width ) [inline]

void vl::ReadPixels::setHeight ( int height ) [inline]

void vl::ReadPixels::setReadBuffer ( EReadDrawBuffer buffer ) [inline]

void vl::ReadPixels::setImage ( Image * image ) [inline]

void vl::ReadPixels::setSavePath ( const String & path ) [inline]

int vl::ReadPixels::x ( ) const [inline]

int vl::ReadPixels::y ( ) const [inline]

int vl::ReadPixels::width ( ) const [inline]

int vl::ReadPixels::height ( ) const [inline]

EReadDrawBuffer vl::ReadPixels::readBuffer ( ) const [inline]

Image* vl::ReadPixels::image ( ) [inline]

const Image* vl::ReadPixels::image ( ) const [inline]

const String& vl::ReadPixels::savePath ( ) const [inline]

void vl::ReadPixels::setStoreInPixelBufferObject ( bool use_pbo ) [inline]

bool vl::ReadPixels::storeInPixelBufferObject ( ) const [inline]

Member Data Documentation

int vl::ReadPixels::mX [protected]

int vl::ReadPixels::mY [protected]

int vl::ReadPixels::mWidth [protected]

int vl::ReadPixels::mHeight [protected]

EReadDrawBuffer vl::ReadPixels::mReadBuffer [protected]

ref<Image> vl::ReadPixels::mImage [protected]

String vl::ReadPixels::mSavePath [protected]

bool vl::ReadPixels::mStoreInPixelBufferObject [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ReadPixels.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::Rect< T > Class Template Reference

vl::Rect

vl::Rect< T > Class Template Reference

Implements the common functions of RectI and RectF. More...

#include <Rect.hpp>

List of all members.

Public Member Functions

virtual const char * | className ()
Rect (const Rect &other)
Rect ()
Rect (T x, T y, T width, T height)
T | x () const
T | y () const
T | width () const
T | height () const
T | bottom () const
T | left () const
T | top () const
T | right () const
void | setX (T x)
void | setY (T y)
void | setWidth (T w)
void | setHeight (T h)
bool | isNull () const
bool | isPoint () const
Rect | intersected (const Rect &other) const
Rect | united (const Rect &other) const
bool | operator< (const Rect &other) const
Defines a sort of lexicographic sorting that make possible the use of the Rect class with STL containers like std::set, std::map etc.

Protected Attributes

T | mX
T | mY
T | mWidth
T | mHeight

Detailed Description

template<typename T>
class vl::Rect< T >

Implements the common functions of RectI and RectF.

Constructor & Destructor Documentation

template<typename T>
vl::Rect< T >::Rect ( const Rect< T > & other ) [inline]

template<typename T>
vl::Rect< T >::Rect ( ) [inline]

template<typename T>
vl::Rect< T >::Rect | ( | T | x,
 |  | T | y,
 |  | T | width,
 |  | T | height |
 | ) |  |  | [inline]

Member Function Documentation

template<typename T>
virtual const char* vl::Rect< T >::className ( ) [inline, virtual]

Reimplemented in vl::RectI, and vl::RectF.

template<typename T>
T vl::Rect< T >::x ( ) const [inline]

template<typename T>
T vl::Rect< T >::y ( ) const [inline]

template<typename T>
T vl::Rect< T >::width ( ) const [inline]

template<typename T>
T vl::Rect< T >::height ( ) const [inline]

template<typename T>
T vl::Rect< T >::bottom ( ) const [inline]

template<typename T>
T vl::Rect< T >::left ( ) const [inline]

template<typename T>
T vl::Rect< T >::top ( ) const [inline]

Reimplemented in vl::RectI, and vl::RectF.

template<typename T>
T vl::Rect< T >::right ( ) const [inline]

Reimplemented in vl::RectI, and vl::RectF.

template<typename T>
void vl::Rect< T >::setX ( T x ) [inline]

template<typename T>
void vl::Rect< T >::setY ( T y ) [inline]

template<typename T>
void vl::Rect< T >::setWidth ( T w ) [inline]

template<typename T>
void vl::Rect< T >::setHeight ( T h ) [inline]

template<typename T>
bool vl::Rect< T >::isNull ( ) const [inline]

template<typename T>
bool vl::Rect< T >::isPoint ( ) const [inline]

template<typename T>
Rect vl::Rect< T >::intersected ( const Rect< T > & other ) const [inline]

template<typename T>
Rect vl::Rect< T >::united ( const Rect< T > & other ) const [inline]

template<typename T>
bool vl::Rect< T >::operator< ( const Rect< T > & other ) const [inline]

Defines a sort of lexicographic sorting that make possible the use of the Rect class with STL containers like std::set, std::map etc.

Member Data Documentation

template<typename T>
T vl::Rect< T >::mX [protected]

template<typename T>
T vl::Rect< T >::mY [protected]

template<typename T>
T vl::Rect< T >::mWidth [protected]

template<typename T>
T vl::Rect< T >::mHeight [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RectF Class Reference

vl::RectF

vl::RectF Class Reference

The RectF class represents a 2D rectangular area using float precision. More...

#include <Rect.hpp>

Inheritance diagram for vl::RectF:

vl::Rect< float >

List of all members.

Public Member Functions

virtual const char * | className ()
RectF ()
RectF (float x, float y, float width, float height)
RectF (const RectF &other)
RectF (const Rect< float > &other)
RectF & | operator= (const Rect< float > &other)
RectF & | operator= (const RectF &other)
float | top () const
float | right () const
fvec2 | bottomLeft () const
fvec2 | topRight () const
void | addPoint (const fvec2 &p)

Detailed Description

The RectF class represents a 2D rectangular area using float precision.

This class is mainly used to manipulate rectangles in real coordinates (as opposed to pixel coordinates). The RectI and RectF differ in the following way:

  • RectF dimensions are implemented using float precision, while RectI uses int precision.
  • RectF::right() returns x()+width(), while RectI::right() returns x()+width()-1
  • RectF::top() return y()+height(), while RectI::top() return y()+height()-1
    See also:
  • RectI

Constructor & Destructor Documentation

vl::RectF::RectF ( ) [inline]

vl::RectF::RectF | ( | float | x,
 |  | float | y,
 |  | float | width,
 |  | float | height |
 | ) |  |  | [inline]

vl::RectF::RectF ( const RectF & other ) [inline]

vl::RectF::RectF ( const Rect< float > & other ) [inline]

Member Function Documentation

virtual const char* vl::RectF::className ( ) [inline, virtual]

Reimplemented from vl::Rect< float >.

RectF& vl::RectF::operator= ( const Rect< float > & other ) [inline]

RectF& vl::RectF::operator= ( const RectF & other ) [inline]

float vl::RectF::top ( ) const [inline]

Reimplemented from vl::Rect< float >.

float vl::RectF::right ( ) const [inline]

Reimplemented from vl::Rect< float >.

fvec2 vl::RectF::bottomLeft ( ) const [inline]

fvec2 vl::RectF::topRight ( ) const [inline]

void vl::RectF::addPoint ( const fvec2 & p ) [inline]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RectI Class Reference

vl::RectI

vl::RectI Class Reference

The RectI class represents a 2D rectangular area using int precision. More...

#include <Rect.hpp>

Inheritance diagram for vl::RectI:

vl::Rect< int >

List of all members.

Public Member Functions

virtual const char * | className ()
RectI ()
RectI (int x, int y, int width, int height)
RectI (const Rect< int > &other)
RectI (const RectI &other)
RectI & | operator= (const Rect< int > &other)
RectI & | operator= (const RectI &other)
int | top () const
int | right () const
ivec2 | bottomLeft () const
ivec2 | topRight () const

Detailed Description

The RectI class represents a 2D rectangular area using int precision.

This class is mainly used to manipulate rectangles in pixel coordinates (as opposed to real coordinates). The RectI and RectF differ in the following way:

  • RectF dimensions are implemented using float precision, while RectI uses int precision.
  • RectF::right() returns x()+width(), while RectI::right() returns x()+width()-1
  • RectF::top() return y()+height(), while RectI::top() return y()+height()-1
    See also:
  • RectF

Constructor & Destructor Documentation

vl::RectI::RectI ( ) [inline]

vl::RectI::RectI | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height |
 | ) |  |  | [inline]

vl::RectI::RectI ( const Rect< int > & other ) [inline]

vl::RectI::RectI ( const RectI & other ) [inline]

Member Function Documentation

virtual const char* vl::RectI::className ( ) [inline, virtual]

Reimplemented from vl::Rect< int >.

RectI& vl::RectI::operator= ( const Rect< int > & other ) [inline]

RectI& vl::RectI::operator= ( const RectI & other ) [inline]

int vl::RectI::top ( ) const [inline]

Reimplemented from vl::Rect< int >.

int vl::RectI::right ( ) const [inline]

Reimplemented from vl::Rect< int >.

ivec2 vl::RectI::bottomLeft ( ) const [inline]

ivec2 vl::RectI::topRight ( ) const [inline]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::ref< T > Class Template Reference

vl::ref

vl::ref< T > Class Template Reference

The ref<> class is used to reference-count an Object. More...

#include <Object.hpp>

List of all members.

Public Member Functions

ref (T *object=NULL)
ref (const ref &other)
template<class T2 >
ref (const ref< T2 > &other)
~ref ()
ref & | operator= (const ref &other)
template<class T2 >
ref & | operator= (const ref< T2 > other)
ref & | operator= (T *other)
template<class T2 >
ref & | operator= (T2 *other)
void | swap (ref &other)
T * | get () const
T * | operator-> () const
T & | operator* () const
bool | operator< (const ref &other) const
operator bool () const

Protected Attributes

T * | mObject

Detailed Description

template<class T>
class vl::ref< T >

The ref<> class is used to reference-count an Object.

When the last ref<> that points to an Object is deallocated also the pointed Object is deallocated.

Constructor & Destructor Documentation

template<class T>
vl::ref< T >::ref ( T * object = NULL ) [inline]

template<class T>
vl::ref< T >::ref ( const ref< T > & other ) [inline]

template<class T>
template<class T2 >
vl::ref< T >::ref ( const ref< T2 > & other ) [inline]

template<class T>
vl::ref< T >::~ref ( ) [inline]

Member Function Documentation

template<class T>
ref& vl::ref< T >::operator= ( const ref< T > & other ) [inline]

template<class T>
template<class T2 >
ref& vl::ref< T >::operator= ( const ref< T2 > other ) [inline]

template<class T>
ref& vl::ref< T >::operator= ( T * other ) [inline]

template<class T>
template<class T2 >
ref& vl::ref< T >::operator= ( T2 * other ) [inline]

template<class T>
void vl::ref< T >::swap ( ref< T > & other ) [inline]

template<class T>
T* vl::ref< T >::get ( ) const [inline]

template<class T>
T* vl::ref< T >::operator-> ( ) const [inline]

template<class T>
T& vl::ref< T >::operator* ( ) const [inline]

template<class T>
bool vl::ref< T >::operator< ( const ref< T > & other ) const [inline]

template<class T>
vl::ref< T >::operator bool ( ) const [inline]

Member Data Documentation

template<class T>
T* vl::ref< T >::mObject [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::Renderable Class Reference

vl::Renderable

vl::Renderable Class Reference

An abstract class that represents all the objects that can be rendered. More...

#include <Renderable.hpp>

Inheritance diagram for vl::Renderable:

vl::Object vl::Clear vl::DrawPixels vl::Geometry vl::Text vl::BezierSurface

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Renderable ()
virtual | ~Renderable ()
virtual void | render (const Actor *actor, const OpenGLContext *, const Camera *camera) const =0
Renders the Renderable.
long long | boundsUpdateTick () const
void | computeBounds ()
void | setBoundsDirty (bool dirty)
bool | boundsDirty () const
void | setBoundingBox (const AABB &aabb)
const AABB & | boundingBox () const
void | setBoundingSphere (const Sphere &sphere)
const Sphere & | boundingSphere () const
unsigned int | displayList () const
void | setDisplayList (unsigned int disp_list)
bool | displayListEnabled () const
void | setDisplayListEnabled (bool enabled)
bool | displayListDirty () const
void | setDisplayListDirty (bool dirty)
bool | vboEnabled () const
void | setVBOEnabled (bool enabled)
bool | vboDirty () const
void | setVBODirty (bool dirty)
virtual void | updateVBOs (bool)
Uploads the data stored in the local buffers on the GPU memory.
virtual void | deleteVBOs ()
Destroyes the VBO (VertexBufferObjects) associated to this Geometry attributes.
void | deleteDisplayList ()
void | compileDisplayList (Actor *act, OpenGLContext *glctx, Camera *camera)
virtual int | triangleCount () const
virtual int | lineCount () const
virtual int | pointCount () const

Protected Member Functions

virtual void | computeBounds_Implementation ()=0

Detailed Description

An abstract class that represents all the objects that can be rendered.

In order to render a Renderable you have to bind it to an Actor. An Actor glues together a Renderable, an Effect and eventually a Transform. Note that the same Renderable can be associated to more than one Actor.

See also:
Actor, Effect, Transform, Geometry

Constructor & Destructor Documentation

vl::Renderable::Renderable ( ) [inline]

virtual vl::Renderable::~Renderable ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::Renderable::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::BezierSurface, vl::Clear, vl::DrawPixels, vl::Geometry, and vl::Text.

virtual void vl::Renderable::render | ( | const Actor * | actor,
 |  | const OpenGLContext * | ,
 |  | const Camera * | camera |
 | ) |  |  | const [pure virtual]

Renders the Renderable.

Implemented in vl::Clear, vl::DrawPixels, vl::Geometry, and vl::Text.

long long vl::Renderable::boundsUpdateTick ( ) const [inline]

void vl::Renderable::computeBounds ( ) [inline]

void vl::Renderable::setBoundsDirty ( bool dirty ) [inline]

bool vl::Renderable::boundsDirty ( ) const [inline]

void vl::Renderable::setBoundingBox ( const AABB & aabb ) [inline]

const AABB& vl::Renderable::boundingBox ( ) const [inline]

void vl::Renderable::setBoundingSphere ( const Sphere & sphere ) [inline]

const Sphere& vl::Renderable::boundingSphere ( ) const [inline]

unsigned int vl::Renderable::displayList ( ) const [inline]

void vl::Renderable::setDisplayList ( unsigned int disp_list ) [inline]

bool vl::Renderable::displayListEnabled ( ) const [inline]

void vl::Renderable::setDisplayListEnabled ( bool enabled ) [inline]

bool vl::Renderable::displayListDirty ( ) const [inline]

void vl::Renderable::setDisplayListDirty ( bool dirty ) [inline]

bool vl::Renderable::vboEnabled ( ) const [inline]

void vl::Renderable::setVBOEnabled ( bool enabled ) [inline]

bool vl::Renderable::vboDirty ( ) const [inline]

void vl::Renderable::setVBODirty ( bool dirty ) [inline]

virtual void vl::Renderable::updateVBOs ( bool ) [inline, virtual]

Uploads the data stored in the local buffers on the GPU memory.

If 'discard_local_data' is set to true the memory used by the local buffers is released.

Reimplemented in vl::Geometry.

virtual void vl::Renderable::deleteVBOs ( ) [inline, virtual]

Destroyes the VBO (VertexBufferObjects) associated to this Geometry attributes.

If 'clear_primitives' all the VBOs associated the Primitives objects are also deleted.

Note:
This function does not touch the local (non GPU) data stored in the buffers associated to the vertex attributes and Primitives.

Reimplemented in vl::Geometry.

void vl::Renderable::deleteDisplayList ( ) [inline]

void vl::Renderable::compileDisplayList | ( | Actor * | act,
 |  | OpenGLContext * | glctx,
 |  | Camera * | camera |
 | ) |  |  | [inline]

virtual int vl::Renderable::triangleCount ( ) const [inline, virtual]

Reimplemented in vl::Geometry.

virtual int vl::Renderable::lineCount ( ) const [inline, virtual]

Reimplemented in vl::Geometry.

virtual int vl::Renderable::pointCount ( ) const [inline, virtual]

Reimplemented in vl::Geometry.

virtual void vl::Renderable::computeBounds_Implementation ( ) [protected, pure virtual]

Implemented in vl::Clear, vl::DrawPixels, vl::Geometry, and vl::Text.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderable.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::Renderer Class Reference

vl::Renderer

vl::Renderer Class Reference

The Renderer class executes the actual rendering on the given RenderQueue. More...

#include <Renderer.hpp>

Inheritance diagram for vl::Renderer:

vl::Object vl::EdgeRenderer

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Renderer ()
virtual | ~Renderer ()
virtual void | render (const RenderQueue *render_queue, Camera *camera)
void | setCollectStatistics (bool on)
bool | collectStatistics () const
int | renderedRenderablesCount () const
int | renderedTrianglesCount () const
int | renderedLinesCount () const
int | renderedPointsCount () const
void | applyEnables (const EnableSet *prev, const EnableSet *cur)
void | applyRenderStates (const RenderStateSet *prev, const RenderStateSet *cur, const Camera *camera)
const OpenGLContext * | openglContext () const
void | setOpenGLContext (const OpenGLContext *ogl_context)
void | resetEnables ()
void | resetRenderStates ()
void | setOcclusionCullingEnabled (bool enabled)
Whether occlusion culling is enabled or not.
bool | occlusionCullingEnabled () const
Whether occlusion culling is enabled or not.
void | setOcclusionThreshold (int threshold)
The number of pixels visible for an actor to be considered occluded (default = 0).
int | occlusionThreshold () const
The number of pixels visible for an actor to be considered occluded (default = 0).

Protected Member Functions

void | setupDefaultRenderStates ()

Protected Attributes

bool | mCollectStatistics
int | mRenderedRenderableCount
int | mRenderedTriangleCount
int | mRenderedLineCount
int | mRenderedPointCount
int | mEnableTable [EN_EnableCount]
int | mRenderStateTable [RS_COUNT]
bool | mCurrentEnable [EN_EnableCount]
const RenderState * | mCurrentRenderState [RS_COUNT]
std::map< String, Uniform * > | mCurrentUniform
const RenderState * | mDefaultRenderStates [RS_COUNT]
const OpenGLContext * | mOpenGLContext
bool | mOcclusionCullingEnabled
ref< Shader > mOcclusionShader
int | mOcclusionThreshold
unsigned | mOcclusionQueryTick
unsigned | mOcclusionQueryTickPrev

Detailed Description

The Renderer class executes the actual rendering on the given RenderQueue.

See also:
Rendering

Constructor & Destructor Documentation

Renderer::Renderer ( )

virtual vl::Renderer::~Renderer ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::Renderer::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::EdgeRenderer.

void Renderer::render | ( | const RenderQueue * | render_queue,
 |  | Camera * | camera |
 | ) |  |  | [virtual]

Reimplemented in vl::EdgeRenderer.

void vl::Renderer::setCollectStatistics ( bool on ) [inline]

bool vl::Renderer::collectStatistics ( ) const [inline]

int vl::Renderer::renderedRenderablesCount ( ) const [inline]

int vl::Renderer::renderedTrianglesCount ( ) const [inline]

int vl::Renderer::renderedLinesCount ( ) const [inline]

int vl::Renderer::renderedPointsCount ( ) const [inline]

void Renderer::applyEnables | ( | const EnableSet * | prev,
 |  | const EnableSet * | cur
 | ) |  |

void Renderer::applyRenderStates | ( | const RenderStateSet * | prev,
 |  | const RenderStateSet * | cur,
 |  | const Camera * | camera
 | ) |  |

const OpenGLContext* vl::Renderer::openglContext ( ) const [inline]

void vl::Renderer::setOpenGLContext ( const OpenGLContext * ogl_context ) [inline]

void Renderer::resetEnables ( )

void Renderer::resetRenderStates ( )

void vl::Renderer::setOcclusionCullingEnabled ( bool enabled ) [inline]

Whether occlusion culling is enabled or not.

See also OpenGL-Accelerated Occlusion Culling Tutorial.

bool vl::Renderer::occlusionCullingEnabled ( ) const [inline]

Whether occlusion culling is enabled or not.

See also OpenGL-Accelerated Occlusion Culling Tutorial.

void vl::Renderer::setOcclusionThreshold ( int threshold ) [inline]

The number of pixels visible for an actor to be considered occluded (default = 0).

int vl::Renderer::occlusionThreshold ( ) const [inline]

The number of pixels visible for an actor to be considered occluded (default = 0).

void Renderer::setupDefaultRenderStates ( ) [protected]

Member Data Documentation

bool vl::Renderer::mCollectStatistics [protected]

int vl::Renderer::mRenderedRenderableCount [protected]

int vl::Renderer::mRenderedTriangleCount [protected]

int vl::Renderer::mRenderedLineCount [protected]

int vl::Renderer::mRenderedPointCount [protected]

int vl::Renderer::mEnableTable[EN_EnableCount] [protected]

int vl::Renderer::mRenderStateTable[RS_COUNT] [protected]

bool vl::Renderer::mCurrentEnable[EN_EnableCount] [protected]

const RenderState* vl::Renderer::mCurrentRenderState[RS_COUNT] [protected]

std::map< String, Uniform* > vl::Renderer::mCurrentUniform [protected]

const RenderState* vl::Renderer::mDefaultRenderStates[RS_COUNT] [protected]

const OpenGLContext* vl::Renderer::mOpenGLContext [protected]

bool vl::Renderer::mOcclusionCullingEnabled [protected]

ref<Shader> vl::Renderer::mOcclusionShader [protected]

int vl::Renderer::mOcclusionThreshold [protected]

unsigned vl::Renderer::mOcclusionQueryTick [protected]

unsigned vl::Renderer::mOcclusionQueryTickPrev [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::Rendering Class Reference

vl::Rendering

vl::Rendering Class Reference

The Rendering class collects all the information to perform the rendering of a scene. More...

#include <Rendering.hpp>

Inheritance diagram for vl::Rendering:

vl::RenderingAbstract vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Rendering ()
Constructor.
Rendering (const Rendering &other)
Copy constructor.
Rendering & | operator= (const Rendering &other)
Assignment operator.
virtual void | render ()
Executes the rendering.
void | resetStates ()
Resets the OpenGL rendering states.
void | setRenderQueueSorter (RenderQueueSorter *render_queue_sorter)
The RenderQueueSorter used to perform the sorting of the objects to be rendered, if NULL no sorting is performed.
RenderQueueSorter * renderQueueSorter ()
The RenderQueueSorter used to perform the sorting of the objects to be rendered, if NULL no sorting is performed.
void | setRenderer (Renderer *renderer)
The Renderer object used to perform the actual rendering of the scene.
const Renderer * | renderer () const
The Renderer object used to perform the actual rendering of the scene.
Renderer * renderer ()
The Renderer object used to perform the actual rendering of the scene.
void | setCamera (Camera *camera)
The Camera that defines the point of view and viewport to be used when rendering the scene.
const Camera * | camera () const
The Camera that defines the point of view and viewport to be used when rendering the scene.
Camera * camera ()
The Camera that defines the point of view and viewport to be used when rendering the scene.
Collection< SceneManager > * sceneManagers ()
Returns the list of SceneManager[s] containing the Actor[s] to be rendered.
const Collection< SceneManager > * | sceneManagers () const
Returns the list of SceneManager[s] containing the Actor[s] to be rendered.
void | setRenderTarget (RenderTarget *render_target)
The RenderTarget on which the rendering is performed.
const RenderTarget * | renderTarget () const
The RenderTarget on which the rendering is performed.
RenderTarget * renderTarget ()
The RenderTarget on which the rendering is performed.
void | setTransform (Transform *transform)
The root of the Transform tree updated at every rendering frame.
const Transform * | transform () const
The root of the Transform tree updated at every rendering frame.
Transform * transform ()
The root of the Transform tree updated at every rendering frame.
void | setEvaluateLOD (bool evaluate_lod)
Whether the Level-Of-Detail should be evaluated or not.
bool | evaluateLOD () const
Whether the Level-Of-Detail should be evaluated or not.
void | setActorAnimationEnabled (bool animate_actors)
Whether Actor::update() should be called or not.
bool | actorAnimationEnabled () const
Whether Actor::update() should be called or not.
void | setShaderAnimationEnabled (bool animate_shaders)
Whether Shader::update() should be called or not.
bool | shaderAnimationEnabled () const
Whether Shader::update() should be called or not.
void | setCullingEnabled (bool enabled)
Whether the installed SceneManager[s] should perform Actor culling or not in order to maximize the rendering performances.
bool | cullingEnabled () const
Whether the installed SceneManager[s] should perform Actor culling or not in order to maximize the rendering performances.
void | setClearFlags (EClearFlags clear_flags)
EClearFlags | clearFlags () const
void | setAutomaticResourceInit (bool enable)
Whether OpenGL resources such as textures and GLSL programs should be automatically initialized before the rendering takes place.
bool | automaticResourceInit () const
Whether OpenGL resources such as textures and GLSL programs should be automatically initialized before the rendering takes place.

Protected Member Functions

void | fillRenderQueue (ActorCollection *actor_list)
ActorCollection * actorQueue ()
RenderQueue * renderQueue ()

Protected Attributes

ref< RenderQueueSorter > mRenderQueueSorter
ref< ActorCollection > mActorQueue
ref< RenderQueue > mRenderQueue
ref< Renderer > mRenderer
ref< RenderTarget > mRenderTarget
ref< Camera > mCamera
ref< Transform > mTransform
ref< Collection< SceneManager > > mSceneManagers
EClearFlags mClearFlags
bool | mAutomaticResourceInit
bool | mCullingEnabled
bool | mEvaluateLOD
bool | mActorAnimationEnabled
bool | mShaderAnimationEnabled

Detailed Description

The Rendering class collects all the information to perform the rendering of a scene.

The Rendering class performs the following steps:

  1. activates the appropriate OpenGLContext
  2. dispatches the RC_PreRendering RenderingCallback[s]
  3. activates the RenderTarget's framebuffer and draw buffers
  4. recursively computes the world matrix of the installed Transform hierarchy
  5. setups the Camera transform and the Viewport
  6. extracts all the visible Actor[s] from the installed SceneManager[s]
  7. compiles and sorts the RenderQueue using the installed RenderQueueSorter
  8. uses the installed Renderer to perform the rendering of the RenderQueue
  9. dispatches the RC_PostRendering RenderingCallback[s]

To be included in the rendering an Actor must have an enableMask() and Effect::enableMask() such that "(Actor::enableMask() & Rendering::enableMask()) != 0" and "(Actor::effect()->enableMask() & Rendering::enableMask()) != 0".

See also:
  • Renderer
  • Actor
  • Effect
  • Transform

Constructor & Destructor Documentation

Rendering::Rendering ( )

Constructor.

vl::Rendering::Rendering ( const Rendering & other ) [inline]

Copy constructor.

Member Function Documentation

virtual const char* vl::Rendering::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Rendering & Rendering::operator= ( const Rendering & other )

Assignment operator.

void Rendering::render ( ) [virtual]

Executes the rendering.

  • RC_PreRendering RenderingCallback is issued right before the rendering takes place.
  • RC_PostRendering RenderingCallback is issued right after the rendering is completed.

Implements vl::RenderingAbstract.

void Rendering::resetStates ( )

Resets the OpenGL rendering states.

void vl::Rendering::setRenderQueueSorter ( RenderQueueSorter * render_queue_sorter ) [inline]

The RenderQueueSorter used to perform the sorting of the objects to be rendered, if NULL no sorting is performed.

RenderQueueSorter* vl::Rendering::renderQueueSorter ( ) [inline]

The RenderQueueSorter used to perform the sorting of the objects to be rendered, if NULL no sorting is performed.

void vl::Rendering::setRenderer ( Renderer * renderer ) [inline]

The Renderer object used to perform the actual rendering of the scene.

const Renderer* vl::Rendering::renderer ( ) const [inline]

The Renderer object used to perform the actual rendering of the scene.

Renderer* vl::Rendering::renderer ( ) [inline]

The Renderer object used to perform the actual rendering of the scene.

void vl::Rendering::setCamera ( Camera * camera ) [inline]

The Camera that defines the point of view and viewport to be used when rendering the scene.

const Camera* vl::Rendering::camera ( ) const [inline]

The Camera that defines the point of view and viewport to be used when rendering the scene.

Camera* vl::Rendering::camera ( ) [inline]

The Camera that defines the point of view and viewport to be used when rendering the scene.

Collection<SceneManager>* vl::Rendering::sceneManagers ( ) [inline]

Returns the list of SceneManager[s] containing the Actor[s] to be rendered.

const Collection<SceneManager>* vl::Rendering::sceneManagers ( ) const [inline]

Returns the list of SceneManager[s] containing the Actor[s] to be rendered.

void vl::Rendering::setRenderTarget ( RenderTarget * render_target ) [inline]

The RenderTarget on which the rendering is performed.

const RenderTarget* vl::Rendering::renderTarget ( ) const [inline]

The RenderTarget on which the rendering is performed.

RenderTarget* vl::Rendering::renderTarget ( ) [inline]

The RenderTarget on which the rendering is performed.

void vl::Rendering::setTransform ( Transform * transform ) [inline]

The root of the Transform tree updated at every rendering frame.

const Transform* vl::Rendering::transform ( ) const [inline]

The root of the Transform tree updated at every rendering frame.

Transform* vl::Rendering::transform ( ) [inline]

The root of the Transform tree updated at every rendering frame.

void vl::Rendering::setEvaluateLOD ( bool evaluate_lod ) [inline]

Whether the Level-Of-Detail should be evaluated or not.

When disabled lod #0 is used.

bool vl::Rendering::evaluateLOD ( ) const [inline]

Whether the Level-Of-Detail should be evaluated or not.

When disabled lod #0 is used.

void vl::Rendering::setActorAnimationEnabled ( bool animate_actors ) [inline]

Whether Actor::update() should be called or not.

Note:
Only visible Actor[s] are updated.

bool vl::Rendering::actorAnimationEnabled ( ) const [inline]

Whether Actor::update() should be called or not.

Note:
Only visible Actor[s] are updated.

void vl::Rendering::setShaderAnimationEnabled ( bool animate_shaders ) [inline]

Whether Shader::update() should be called or not.

Note:
Only Shader[s] belonging to visible Actor[s] are updated.

bool vl::Rendering::shaderAnimationEnabled ( ) const [inline]

Whether Shader::update() should be called or not.

Note:
Only Shader[s] belonging to visible Actor[s] are updated.

void vl::Rendering::setCullingEnabled ( bool enabled ) [inline]

Whether the installed SceneManager[s] should perform Actor culling or not in order to maximize the rendering performances.

bool vl::Rendering::cullingEnabled ( ) const [inline]

Whether the installed SceneManager[s] should perform Actor culling or not in order to maximize the rendering performances.

void vl::Rendering::setClearFlags ( EClearFlags clear_flags ) [inline]

EClearFlags vl::Rendering::clearFlags ( ) const [inline]

void vl::Rendering::setAutomaticResourceInit ( bool enable ) [inline]

Whether OpenGL resources such as textures and GLSL programs should be automatically initialized before the rendering takes place.

bool vl::Rendering::automaticResourceInit ( ) const [inline]

Whether OpenGL resources such as textures and GLSL programs should be automatically initialized before the rendering takes place.

void Rendering::fillRenderQueue ( ActorCollection * actor_list ) [protected]

ActorCollection* vl::Rendering::actorQueue ( ) [inline, protected]

RenderQueue* vl::Rendering::renderQueue ( ) [inline, protected]

Member Data Documentation

ref<RenderQueueSorter> vl::Rendering::mRenderQueueSorter [protected]

ref<ActorCollection> vl::Rendering::mActorQueue [protected]

ref<RenderQueue> vl::Rendering::mRenderQueue [protected]

ref<Renderer> vl::Rendering::mRenderer [protected]

ref<RenderTarget> vl::Rendering::mRenderTarget [protected]

ref<Camera> vl::Rendering::mCamera [protected]

ref<Transform> vl::Rendering::mTransform [protected]

ref<Collection<SceneManager> > vl::Rendering::mSceneManagers [protected]

EClearFlags vl::Rendering::mClearFlags [protected]

bool vl::Rendering::mAutomaticResourceInit [protected]

bool vl::Rendering::mCullingEnabled [protected]

bool vl::Rendering::mEvaluateLOD [protected]

bool vl::Rendering::mActorAnimationEnabled [protected]

bool vl::Rendering::mShaderAnimationEnabled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RenderingAbstract Class Reference

vl::RenderingAbstract

vl::RenderingAbstract Class Reference

The RenderingAbstract class implements the abstract rendering interface. More...

#include <RenderingAbstract.hpp>

Inheritance diagram for vl::RenderingAbstract:

vl::Object vl::Rendering vl::RenderingTree

List of all members.

Public Member Functions

RenderingAbstract ()
Constructor.
virtual void | render ()=0
Executes the rendering.
RenderingAbstract & | operator= (const RenderingAbstract &other)
void | dispatchRenderingCallbacks (ERenderingCallback reason)
Triggers the execution of the rendering callbacks with the given reason.
Collection< RenderingCallback > * renderingCallbacks ()
Returns the list of RenderingCallback objects bound to a Rendering.
const Collection
< RenderingCallback > * 		renderingCallbacks () const
Returns the list of RenderingCallback objects bound to a Rendering.
void | setEnableMask (unsigned int mask)
The enable mask of the Rendering, used to define wheter the rendering is enabled or not, and which objects should be rendered.
unsigned int | enableMask () const
The enable mask of the Rendering, used to define wheter the rendering is enabled or not, and which objects should be rendered.
bool | isEnabled (unsigned int mask)
Utility function equivalent to "(mask & mEnableMask) != 0".
void | setUpdateTime (Real cur_time)
The update time of the current rendering frame.
Real | updateTime () const
The update time of the current rendering frame.

Protected Attributes

ref< Collection
< RenderingCallback > > 		mRenderingCallbacks
Real mUpdateTime
unsigned int | mEnableMask

Detailed Description

The RenderingAbstract class implements the abstract rendering interface.

Constructor & Destructor Documentation

RenderingAbstract::RenderingAbstract ( )

Constructor.

Member Function Documentation

virtual void vl::RenderingAbstract::render ( ) [pure virtual]

Executes the rendering.

  • RC_PreRendering RenderingCallback is issued right before the rendering takes place.
  • RC_PostRendering RenderingCallback is issued right after the rendering is completed.

Implemented in vl::Rendering, and vl::RenderingTree.

RenderingAbstract & RenderingAbstract::operator= ( const RenderingAbstract & other )

void RenderingAbstract::dispatchRenderingCallbacks ( ERenderingCallback reason )

Triggers the execution of the rendering callbacks with the given reason.

Collection<RenderingCallback>* vl::RenderingAbstract::renderingCallbacks ( ) [inline]

Returns the list of RenderingCallback objects bound to a Rendering.

const Collection<RenderingCallback>* vl::RenderingAbstract::renderingCallbacks ( ) const [inline]

Returns the list of RenderingCallback objects bound to a Rendering.

void vl::RenderingAbstract::setEnableMask ( unsigned int mask ) [inline]

The enable mask of the Rendering, used to define wheter the rendering is enabled or not, and which objects should be rendered.

See also:
vl::Actor::setEnableMask()

unsigned int vl::RenderingAbstract::enableMask ( ) const [inline]

The enable mask of the Rendering, used to define wheter the rendering is enabled or not, and which objects should be rendered.

bool vl::RenderingAbstract::isEnabled ( unsigned int mask ) [inline]

Utility function equivalent to "(mask & mEnableMask) != 0".

void vl::RenderingAbstract::setUpdateTime ( Real cur_time ) [inline]

The update time of the current rendering frame.

Real vl::RenderingAbstract::updateTime ( ) const [inline]

The update time of the current rendering frame.

Member Data Documentation

ref< Collection<RenderingCallback> > vl::RenderingAbstract::mRenderingCallbacks [protected]

Real vl::RenderingAbstract::mUpdateTime [protected]

unsigned int vl::RenderingAbstract::mEnableMask [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RenderingCallback Class Reference

vl::RenderingCallback

vl::RenderingCallback Class Reference

An abstract class used to perform operations at the end or at the beginning of a rendering. More...

#include <RenderingCallback.hpp>

Inheritance diagram for vl::RenderingCallback:

vl::Object vl::BlitFramebuffer vl::CopyTexSubImage vl::ReadPixels vl::CopyTexSubImage1D vl::CopyTexSubImage2D vl::CopyTexSubImage3D

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderingCallback ()
virtual bool | renderingCallback (const RenderingAbstract *rendering, ERenderingCallback reason)=0
Implements the actual code to be executed upon callback activation.
void | setRemoveAfterCall (bool remove)
Defines if the callback shall be removed after being executed.
bool | removeAfterCall () const
Defines if the callback shall be removed after being executed.

Protected Attributes

float | mRank
bool | mRemoveAfterCall

Detailed Description

An abstract class used to perform operations at the end or at the beginning of a rendering.

Install a callback to react to the following two events: vl::RC_PreRendering and vl::RC_PostRendering. The callbacks are executed in the same order in which they appear in the vl::Rendering::renderingCallbacks() collection. For more information see:

  • vl::Rendering::renderingCallbacks()
  • vl::Rendering

Constructor & Destructor Documentation

vl::RenderingCallback::RenderingCallback ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderingCallback::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::BlitFramebuffer, vl::CopyTexSubImage1D, vl::CopyTexSubImage2D, vl::CopyTexSubImage3D, and vl::ReadPixels.

virtual bool vl::RenderingCallback::renderingCallback | ( | const RenderingAbstract * | rendering,
 |  | ERenderingCallback | reason |
 | ) |  |  | [pure virtual]

Implements the actual code to be executed upon callback activation.

Returns:
true if the callback reacted to the given reason

Implemented in vl::BlitFramebuffer, vl::CopyTexSubImage, and vl::ReadPixels.

void vl::RenderingCallback::setRemoveAfterCall ( bool remove ) [inline]

Defines if the callback shall be removed after being executed.

Note that the callback is removed only if the renderingCallback() method returns true.

bool vl::RenderingCallback::removeAfterCall ( ) const [inline]

Defines if the callback shall be removed after being executed.

Note that the callback is removed only if the renderingCallback() method returns true.

Member Data Documentation

float vl::RenderingCallback::mRank [protected]

bool vl::RenderingCallback::mRemoveAfterCall [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingCallback.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: vl::RenderingTree Class Reference

vl::RenderingTree

vl::RenderingTree Class Reference

The RenderingTree class organizes a set of renderings into a tree-like data structure. More...

#include <RenderingTree.hpp>

Inheritance diagram for vl::RenderingTree:

vl::RenderingAbstract vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderingTree ()
Constructor.
RenderingTree (const RenderingTree &other)
Copy constructor.
RenderingTree & | operator= (const RenderingTree &other)
Assignment operator.
virtual void | render ()
Recursively calls the render() method of its children.
Collection< RenderingAbstract > * subRenderings ()
The sub-Rendering (or child-Rendering) objects of a Rendering. A sub-Rendering is rendered before it's parent and after its children.
const Collection
< RenderingAbstract > * 		subRenderings () const
The sub-Rendering (or child-Rendering) objects of a Rendering. A sub-Rendering is rendered before it's parent and after its children.

Protected Attributes

ref< Collection
< RenderingAbstract > > 		mSubRendering

Detailed Description

The RenderingTree class organizes a set of renderings into a tree-like data structure.

To enable the RenderingTree set the enableMask() to a value != 0, otherwise the RenderingTree will be disabled.

Constructor & Destructor Documentation

RenderingTree::RenderingTree ( )

Constructor.

vl::RenderingTree::RenderingTree ( const RenderingTree & other ) [inline]

Copy constructor.

Member Function Documentation

virtual const char* vl::RenderingTree::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

RenderingTree & RenderingTree::operator= ( const RenderingTree & other )

Assignment operator.

void RenderingTree::render ( ) [virtual]

Recursively calls the render() method of its children.

Note:
  • RC_PreRendering RenderingCallback is issued before the rendering of any children.
  • RC_PostRendering RenderingCallback is issued after the rendering of all the children. If enableMask() == 0 then no rendering and no RenderingCallback is generated.

Implements vl::RenderingAbstract.

Collection<RenderingAbstract>* vl::RenderingTree::subRenderings ( ) [inline]

The sub-Rendering (or child-Rendering) objects of a Rendering. A sub-Rendering is rendered before it's parent and after its children.

const Collection<RenderingAbstract>* vl::RenderingTree::subRenderings ( ) const [inline]

The sub-Rendering (or child-Rendering) objects of a Rendering. A sub-Rendering is rendered before it's parent and after its children.

Member Data Documentation

ref< Collection<RenderingAbstract> > vl::RenderingTree::mSubRendering [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueue Class Reference

vl::RenderQueue

vl::RenderQueue Class Reference

The RenderQueue class collects a list of RenderToken objects to be sorted and rendered. More...

#include <RenderQueue.hpp>

Inheritance diagram for vl::RenderQueue:

vl::Object

List of all members.

Classes

class | Sorter

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueue ()
RenderToken * | at (int i) const
RenderToken * | newToken (bool multipass)
void | clear ()
bool | empty ()
int | size () const
void | sort (RenderQueueSorter *sorter, Camera *camera)

Protected Attributes

std::vector< ref< RenderToken > > | mList
std::vector< ref< RenderToken > > | mListMP
int | mSize
int | mSizeMP

Detailed Description

The RenderQueue class collects a list of RenderToken objects to be sorted and rendered.

Constructor & Destructor Documentation

vl::RenderQueue::RenderQueue ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueue::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

RenderToken* vl::RenderQueue::at ( int i ) const [inline]

RenderToken* vl::RenderQueue::newToken ( bool multipass ) [inline]

void vl::RenderQueue::clear ( ) [inline]

bool vl::RenderQueue::empty ( ) [inline]

int vl::RenderQueue::size ( ) const [inline]

void vl::RenderQueue::sort | ( | RenderQueueSorter * | sorter,
 |  | Camera * | camera |
 | ) |  |  | [inline]

Member Data Documentation

std::vector< ref<RenderToken> > vl::RenderQueue::mList [protected]

std::vector< ref<RenderToken> > vl::RenderQueue::mListMP [protected]

int vl::RenderQueue::mSize [protected]

int vl::RenderQueue::mSizeMP [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueue.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorter Class Reference

vl::RenderQueueSorter

vl::RenderQueueSorter Class Reference

The RenderQueueSorter class is the abstract base class of all the algorithms used to sort a set of RenderToken. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorter:

vl::Object vl::RenderQueueSorterAggressive vl::RenderQueueSorterBasic vl::RenderQueueSorterByRenderable vl::RenderQueueSorterByShader vl::RenderQueueSorterOcclusion vl::RenderQueueSorterStandard

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorter ()
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const =0
virtual bool | confirmZCameraDistanceNeed (const RenderToken *) const =0
virtual bool | mightNeedZCameraDistance () const =0

Detailed Description

The RenderQueueSorter class is the abstract base class of all the algorithms used to sort a set of RenderToken.

Constructor & Destructor Documentation

vl::RenderQueueSorter::RenderQueueSorter ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorter::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::RenderQueueSorterByShader, vl::RenderQueueSorterByRenderable, vl::RenderQueueSorterBasic, vl::RenderQueueSorterStandard, vl::RenderQueueSorterOcclusion, and vl::RenderQueueSorterAggressive.

virtual bool vl::RenderQueueSorter::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [pure virtual]

Implemented in vl::RenderQueueSorterByShader, vl::RenderQueueSorterByRenderable, vl::RenderQueueSorterBasic, vl::RenderQueueSorterStandard, vl::RenderQueueSorterOcclusion, and vl::RenderQueueSorterAggressive.

virtual bool vl::RenderQueueSorter::confirmZCameraDistanceNeed ( const RenderToken * ) const [pure virtual]

Implemented in vl::RenderQueueSorterByShader, vl::RenderQueueSorterByRenderable, vl::RenderQueueSorterBasic, vl::RenderQueueSorterStandard, vl::RenderQueueSorterOcclusion, and vl::RenderQueueSorterAggressive.

virtual bool vl::RenderQueueSorter::mightNeedZCameraDistance ( ) const [pure virtual]

Implemented in vl::RenderQueueSorterByShader, vl::RenderQueueSorterByRenderable, vl::RenderQueueSorterStandard, vl::RenderQueueSorterOcclusion, and vl::RenderQueueSorterAggressive.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterAggressive Class Reference

vl::RenderQueueSorterAggressive

vl::RenderQueueSorterAggressive Class Reference

Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterAggressive:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterAggressive ()
virtual bool | mightNeedZCameraDistance () const
virtual bool | confirmZCameraDistanceNeed (const RenderToken *a) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const
EDepthSortMode | depthSortMode () const
void | setDepthSortMode (EDepthSortMode mode)

Public Attributes

EDepthSortMode mDepthSortMode

Detailed Description

Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer.

Constructor & Destructor Documentation

vl::RenderQueueSorterAggressive::RenderQueueSorterAggressive ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterAggressive::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterAggressive::mightNeedZCameraDistance ( ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterAggressive::confirmZCameraDistanceNeed ( const RenderToken * a ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterAggressive::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

EDepthSortMode vl::RenderQueueSorterAggressive::depthSortMode ( ) const [inline]

void vl::RenderQueueSorterAggressive::setDepthSortMode ( EDepthSortMode mode ) [inline]

Member Data Documentation

EDepthSortMode vl::RenderQueueSorterAggressive::mDepthSortMode

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterBasic Class Reference

vl::RenderQueueSorterBasic

vl::RenderQueueSorterBasic Class Reference

Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterBasic:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterBasic ()
virtual bool | confirmZCameraDistanceNeed (const RenderToken *) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const

Detailed Description

Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer.

Constructor & Destructor Documentation

vl::RenderQueueSorterBasic::RenderQueueSorterBasic ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterBasic::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterBasic::confirmZCameraDistanceNeed ( const RenderToken * ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterBasic::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterByRenderable Class Reference

vl::RenderQueueSorterByRenderable

vl::RenderQueueSorterByRenderable Class Reference

Sorts the RenderTokens by their Renderable pointer. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterByRenderable:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterByRenderable ()
virtual bool | mightNeedZCameraDistance () const
virtual bool | confirmZCameraDistanceNeed (const RenderToken *) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const

Detailed Description

Sorts the RenderTokens by their Renderable pointer.

Constructor & Destructor Documentation

vl::RenderQueueSorterByRenderable::RenderQueueSorterByRenderable ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterByRenderable::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByRenderable::mightNeedZCameraDistance ( ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByRenderable::confirmZCameraDistanceNeed ( const RenderToken * ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByRenderable::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterByShader Class Reference

vl::RenderQueueSorterByShader

vl::RenderQueueSorterByShader Class Reference

Sorts the RenderTokens by their Shader pointer. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterByShader:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterByShader ()
virtual bool | mightNeedZCameraDistance () const
virtual bool | confirmZCameraDistanceNeed (const RenderToken *) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const

Detailed Description

Sorts the RenderTokens by their Shader pointer.

Constructor & Destructor Documentation

vl::RenderQueueSorterByShader::RenderQueueSorterByShader ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterByShader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByShader::mightNeedZCameraDistance ( ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByShader::confirmZCameraDistanceNeed ( const RenderToken * ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterByShader::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterOcclusion Class Reference

vl::RenderQueueSorterOcclusion

vl::RenderQueueSorterOcclusion Class Reference

Implements a RenderQueueSorter to be used with occlusion culling. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterOcclusion:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterOcclusion ()
virtual bool | mightNeedZCameraDistance () const
virtual bool | confirmZCameraDistanceNeed (const RenderToken *) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const

Detailed Description

Implements a RenderQueueSorter to be used with occlusion culling.

Sorts the RenderTokens by:

  1. Actor render block
  2. Effect render rank
  3. Actor render rank
  4. Solid objects first, translucent objects last
  5. Sort solid objects front-to-back
  6. Sort translucent objects back-to-front

Constructor & Destructor Documentation

vl::RenderQueueSorterOcclusion::RenderQueueSorterOcclusion ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterOcclusion::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterOcclusion::mightNeedZCameraDistance ( ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterOcclusion::confirmZCameraDistanceNeed ( const RenderToken * ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterOcclusion::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderQueueSorterStandard Class Reference

vl::RenderQueueSorterStandard

vl::RenderQueueSorterStandard Class Reference

Implements the default RenderQueueSorter. More...

#include <RenderQueueSorter.hpp>

Inheritance diagram for vl::RenderQueueSorterStandard:

vl::RenderQueueSorter vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderQueueSorterStandard ()
virtual bool | mightNeedZCameraDistance () const
virtual bool | confirmZCameraDistanceNeed (const RenderToken *a) const
virtual bool | operator() (const RenderToken *a, const RenderToken *b) const
EDepthSortMode | depthSortMode () const
void | setDepthSortMode (EDepthSortMode mode)

Public Attributes

EDepthSortMode mDepthSortMode

Detailed Description

Implements the default RenderQueueSorter.

Sorts the RenderTokens by:

  1. Actor render block
  2. Effect render rank
  3. Actor render rank
  4. Solid objects first, translucent objects last
  5. Sort translucent objects back-to-front
  6. Sort solid objects by Shader
  7. Sort solid objects by Renderable

Constructor & Destructor Documentation

vl::RenderQueueSorterStandard::RenderQueueSorterStandard ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderQueueSorterStandard::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterStandard::mightNeedZCameraDistance ( ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterStandard::confirmZCameraDistanceNeed ( const RenderToken * a ) const [inline, virtual]

Implements vl::RenderQueueSorter.

virtual bool vl::RenderQueueSorterStandard::operator() | ( | const RenderToken * | a,
 |  | const RenderToken * | b |
 | ) |  |  | const [inline, virtual]

Implements vl::RenderQueueSorter.

EDepthSortMode vl::RenderQueueSorterStandard::depthSortMode ( ) const [inline]

void vl::RenderQueueSorterStandard::setDepthSortMode ( EDepthSortMode mode ) [inline]

Member Data Documentation

EDepthSortMode vl::RenderQueueSorterStandard::mDepthSortMode

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderState Class Reference

vl::RenderState

vl::RenderState Class Reference

Base class for most of the OpenGL render state wrapper classes. More...

#include <RenderState.hpp>

Inheritance diagram for vl::RenderState:

vl::Object vl::AlphaFunc vl::BlendColor vl::BlendEquation vl::BlendFunc vl::ClipPlane vl::ColorMask vl::CullFace vl::DepthFunc vl::DepthMask vl::DepthRange vl::Fog vl::FrontFace vl::GLSLProgram vl::Hint vl::Light vl::LightModel vl::LineStipple vl::LineWidth vl::LogicOp vl::Material vl::PixelTransfer vl::PointParameter vl::PointSize vl::PolygonMode vl::PolygonOffset vl::PolygonStipple vl::SampleCoverage vl::ShadeModel vl::StencilFunc vl::StencilMask vl::StencilOp vl::TexEnv vl::TexGen vl::TextureMatrix vl::TextureUnit

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderState ()
virtual | ~RenderState ()
virtual ERenderState | type () const
virtual void | apply (const Camera *) const =0
virtual void | disable () const
virtual void | enable () const
virtual void | initResources ()
int | textureUnit () const
void | setUnitIndex (int unit_index)

Protected Attributes

int | mTextureUnit

Detailed Description

Base class for most of the OpenGL render state wrapper classes.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::RenderState::RenderState ( ) [inline]

virtual vl::RenderState::~RenderState ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::RenderState::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::ClipPlane, vl::GLSLProgram, vl::Light, vl::PixelTransfer, vl::Hint, vl::CullFace, vl::FrontFace, vl::DepthFunc, vl::DepthMask, vl::PolygonMode, vl::ShadeModel, vl::BlendFunc, vl::BlendEquation, vl::SampleCoverage, vl::AlphaFunc, vl::Material, vl::LightModel, vl::Fog, vl::PolygonOffset, vl::LogicOp, vl::DepthRange, vl::LineWidth, vl::PointSize, vl::PolygonStipple, vl::LineStipple, vl::PointParameter, vl::StencilFunc, vl::StencilOp, vl::StencilMask, vl::BlendColor, vl::ColorMask, vl::TextureMatrix, vl::TexEnv, vl::TexGen, and vl::TextureUnit.

virtual ERenderState vl::RenderState::type ( ) const [inline, virtual]

Reimplemented in vl::ClipPlane, vl::GLSLProgram, vl::Light, vl::PixelTransfer, vl::Hint, vl::CullFace, vl::FrontFace, vl::DepthFunc, vl::DepthMask, vl::PolygonMode, vl::ShadeModel, vl::BlendFunc, vl::BlendEquation, vl::SampleCoverage, vl::AlphaFunc, vl::Material, vl::LightModel, vl::Fog, vl::PolygonOffset, vl::LogicOp, vl::DepthRange, vl::LineWidth, vl::PointSize, vl::PolygonStipple, vl::LineStipple, vl::PointParameter, vl::StencilFunc, vl::StencilOp, vl::StencilMask, vl::BlendColor, vl::ColorMask, vl::TextureMatrix, vl::TexEnv, vl::TexGen, and vl::TextureUnit.

virtual void vl::RenderState::apply ( const Camera * ) const [pure virtual]

Implemented in vl::ClipPlane, vl::GLSLProgram, vl::Light, vl::PixelTransfer, vl::Hint, vl::CullFace, vl::FrontFace, vl::DepthFunc, vl::DepthMask, vl::PolygonMode, vl::ShadeModel, vl::BlendFunc, vl::BlendEquation, vl::SampleCoverage, vl::AlphaFunc, vl::Material, vl::LightModel, vl::Fog, vl::PolygonOffset, vl::LogicOp, vl::DepthRange, vl::LineWidth, vl::PointSize, vl::PolygonStipple, vl::LineStipple, vl::PointParameter, vl::StencilFunc, vl::StencilOp, vl::StencilMask, vl::BlendColor, vl::ColorMask, vl::TextureMatrix, vl::TexEnv, vl::TexGen, and vl::TextureUnit.

virtual void vl::RenderState::disable ( ) const [inline, virtual]

Reimplemented in vl::ClipPlane, vl::Light, and vl::TextureUnit.

virtual void vl::RenderState::enable ( ) const [inline, virtual]

Reimplemented in vl::ClipPlane, vl::Light, and vl::TextureUnit.

virtual void vl::RenderState::initResources ( ) [inline, virtual]

Reimplemented in vl::GLSLProgram, and vl::TextureUnit.

int vl::RenderState::textureUnit ( ) const [inline]

void vl::RenderState::setUnitIndex ( int unit_index ) [inline]

Member Data Documentation

int vl::RenderState::mTextureUnit [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderState.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderStateSet Class Reference

vl::RenderStateSet

vl::RenderStateSet Class Reference

A set of RenderState objects managed by a Shader. More...

#include <Shader.hpp>

Inheritance diagram for vl::RenderStateSet:

vl::Object

List of all members.

Public Member Functions

RenderStateSet ()
virtual const char * | className ()
Returns the name of the class.
void | setRenderState (RenderState *renderstate)
RenderState * | renderState (ERenderState type)
const RenderState * | renderState (ERenderState type) const
const std::vector< ref
< RenderState > > & 		renderStates () const
void | eraseRenderState (ERenderState type)
void | eraseAllRenderStates ()
const GLSLProgram * | glslProgram () const
Returns the GLSLProgram associated to a RenderStateSet (if any).
GLSLProgram * glslProgram ()
Returns the GLSLProgram associated to a RenderStateSet (if any).

Protected Attributes

std::vector< ref< RenderState > > | mRenderStates
GLSLProgram * mGLSLProgram

Detailed Description

A set of RenderState objects managed by a Shader.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::RenderStateSet::RenderStateSet ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderStateSet::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::RenderStateSet::setRenderState ( RenderState * renderstate ) [inline]

RenderState* vl::RenderStateSet::renderState ( ERenderState type ) [inline]

const RenderState* vl::RenderStateSet::renderState ( ERenderState type ) const [inline]

const std::vector< ref<RenderState> >& vl::RenderStateSet::renderStates ( ) const [inline]

void vl::RenderStateSet::eraseRenderState ( ERenderState type ) [inline]

void vl::RenderStateSet::eraseAllRenderStates ( ) [inline]

const GLSLProgram* vl::RenderStateSet::glslProgram ( ) const [inline]

Returns the GLSLProgram associated to a RenderStateSet (if any).

GLSLProgram* vl::RenderStateSet::glslProgram ( ) [inline]

Returns the GLSLProgram associated to a RenderStateSet (if any).

Member Data Documentation

std::vector< ref<RenderState> > vl::RenderStateSet::mRenderStates [protected]

GLSLProgram* vl::RenderStateSet::mGLSLProgram [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::RenderTarget Class Reference

vl::RenderTarget

vl::RenderTarget Class Reference

The RenderTarget class defines an abstract 'surface' where OpenGL can render into. More...

#include <RenderTarget.hpp>

Inheritance diagram for vl::RenderTarget:

vl::Object vl::FBORenderTarget

List of all members.

Public Member Functions

OpenGLContext * openglContext ()
const OpenGLContext * | openglContext () const
int | width () const
int | height () const
void | setWidth (int width)
void | setHeight (int height)
void | activate ()
Activates the RenderTarget by calling bindFramebuffer() and setDrawBuffers().
virtual void | bindFramebuffer ()
void | bindDrawBuffers () const
void | checkDrawBuffers () const
void | setDrawBuffers (EReadDrawBuffer render_buffer)
void | setDrawBuffers (EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2)
void | setDrawBuffers (EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3)
void | setDrawBuffers (EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3, EReadDrawBuffer render_buffer4)
void | setDrawBuffers (const std::vector< EReadDrawBuffer > &render_buffers)
const std::vector
< EReadDrawBuffer > & 		renderBuffers ()

Protected Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderTarget (OpenGLContext *ctx, int w, int h)

Protected Attributes

std::vector< EReadDrawBuffer > | mDrawBuffers
int | mWidth
int | mHeight
OpenGLContext * mOpenGLContext

Friends

class | OpenGLContext

Detailed Description

The RenderTarget class defines an abstract 'surface' where OpenGL can render into.

See also:
OpenGLContext::renderTarget() and FBORenderTarget

Constructor & Destructor Documentation

vl::RenderTarget::RenderTarget | ( | OpenGLContext * | ctx,
 |  | int | w,
 |  | int | h |
 | ) |  |  | [inline, protected]

Member Function Documentation

virtual const char* vl::RenderTarget::className ( ) [inline, protected, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::FBORenderTarget.

OpenGLContext* vl::RenderTarget::openglContext ( ) [inline]

const OpenGLContext* vl::RenderTarget::openglContext ( ) const [inline]

int vl::RenderTarget::width ( ) const [inline]

int vl::RenderTarget::height ( ) const [inline]

void vl::RenderTarget::setWidth ( int width ) [inline]

void vl::RenderTarget::setHeight ( int height ) [inline]

void vl::RenderTarget::activate ( ) [inline]

Activates the RenderTarget by calling bindFramebuffer() and setDrawBuffers().

virtual void vl::RenderTarget::bindFramebuffer ( ) [inline, virtual]

Reimplemented in vl::FBORenderTarget.

void RenderTarget::bindDrawBuffers ( ) const

void RenderTarget::checkDrawBuffers ( ) const

void vl::RenderTarget::setDrawBuffers ( EReadDrawBuffer render_buffer ) [inline]

void vl::RenderTarget::setDrawBuffers | ( | EReadDrawBuffer | render_buffer1,
 |  | EReadDrawBuffer | render_buffer2 |
 | ) |  |  | [inline]

void vl::RenderTarget::setDrawBuffers | ( | EReadDrawBuffer | render_buffer1,
 |  | EReadDrawBuffer | render_buffer2,
 |  | EReadDrawBuffer | render_buffer3 |
 | ) |  |  | [inline]

void vl::RenderTarget::setDrawBuffers | ( | EReadDrawBuffer | render_buffer1,
 |  | EReadDrawBuffer | render_buffer2,
 |  | EReadDrawBuffer | render_buffer3,
 |  | EReadDrawBuffer | render_buffer4 |
 | ) |  |  | [inline]

void vl::RenderTarget::setDrawBuffers ( const std::vector< EReadDrawBuffer > & render_buffers ) [inline]

const std::vector< EReadDrawBuffer >& vl::RenderTarget::renderBuffers ( ) [inline]

Friends And Related Function Documentation

friend class OpenGLContext [friend]

Reimplemented in vl::FBORenderTarget.

Member Data Documentation

std::vector< EReadDrawBuffer > vl::RenderTarget::mDrawBuffers [protected]

int vl::RenderTarget::mWidth [protected]

int vl::RenderTarget::mHeight [protected]

OpenGLContext* vl::RenderTarget::mOpenGLContext [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::RenderToken Class Reference

vl::RenderToken

vl::RenderToken Class Reference

Internally used by the rendering engine. More...

#include <RenderToken.hpp>

Inheritance diagram for vl::RenderToken:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
RenderToken ()

Public Attributes

const RenderToken * | mNextPass
Actor * mActor
Renderable * mRenderable
const Shader * | mShader
int | mEffectRenderRank
Real mCameraDistance

Detailed Description

Internally used by the rendering engine.

Constructor & Destructor Documentation

vl::RenderToken::RenderToken ( ) [inline]

Member Function Documentation

virtual const char* vl::RenderToken::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Member Data Documentation

const RenderToken* vl::RenderToken::mNextPass

Actor* vl::RenderToken::mActor

Renderable* vl::RenderToken::mRenderable

const Shader* vl::RenderToken::mShader

int vl::RenderToken::mEffectRenderRank

Real vl::RenderToken::mCameraDistance

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderToken.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::ResourceDatabase Class Reference

vl::ResourceDatabase

vl::ResourceDatabase Class Reference

The ResourceDatabase class contains and manipulates a set of resources. More...

#include <ResourceDatabase.hpp>

Inheritance diagram for vl::ResourceDatabase:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
const std::vector< ref< Object > > & | resources () const
std::vector< ref< Object > > & | resources ()
template<class T >
unsigned | count () const
template<class T >
T * | get (int j) const
template<class T >
T * | next (int &cur_pos) const
template<class T >
void | extract (std::vector< ref< T > > &resources, bool clear_vector=true)
template<class T >
void | get (std::vector< ref< T > > &resources, bool clear_vector=true)

Protected Attributes

std::vector< ref< Object > > | mResources

Detailed Description

The ResourceDatabase class contains and manipulates a set of resources.

It works with any kind of resources derived from vl::Object, even user-customized ones.

Member Function Documentation

virtual const char* vl::ResourceDatabase::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

const std::vector< ref<Object> >& vl::ResourceDatabase::resources ( ) const [inline]

std::vector< ref<Object> >& vl::ResourceDatabase::resources ( ) [inline]

template<class T >
unsigned vl::ResourceDatabase::count ( ) const [inline]

template<class T >
T* vl::ResourceDatabase::get ( int j ) const [inline]

template<class T >
T* vl::ResourceDatabase::next ( int & cur_pos ) const [inline]

template<class T >
void vl::ResourceDatabase::extract | ( | std::vector< ref< T > > & | resources,
 |  | bool | clear_vector = true |
 | ) |  |  | [inline]

template<class T >
void vl::ResourceDatabase::get | ( | std::vector< ref< T > > & | resources,
 |  | bool | clear_vector = true |
 | ) |  |  | [inline]

Member Data Documentation

std::vector< ref<Object> > vl::ResourceDatabase::mResources [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceDatabase.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::ResourceLoadWriter Class Reference

vl::ResourceLoadWriter

vl::ResourceLoadWriter Class Reference

The ResourceLoadWriter class is an abstract class used to implement read/write support for one or more resource types. More...

#include <ResourceLoadWriter.hpp>

Inheritance diagram for vl::ResourceLoadWriter:

vl::Object vl::LoadWriter3DS vl::LoadWriterAC3D vl::LoadWriterBMP vl::LoadWriterDAT vl::LoadWriterDDS vl::LoadWriterDICOM vl::LoadWriterJPG vl::LoadWriterMD2 vl::LoadWriterOBJ vl::LoadWriterPLY vl::LoadWriterPNG vl::LoadWriterSTL vl::LoadWriterTGA vl::LoadWriterTIFF

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ResourceLoadWriter (const String &load_extensions, const String &write_extensions)
virtual ref< ResourceDatabase > | loadResource (const String &path) const =0
virtual ref< ResourceDatabase > | loadResource (VirtualFile *file) const =0
virtual bool | writeResource (const String &path, ResourceDatabase *resource) const =0
virtual bool | writeResource (VirtualFile *file, ResourceDatabase *resource) const =0
bool | canLoad (const String &extension) const
Returns true if the given file type can be loaded.
const String & | loadExtensions () const
Returns the string containing the file types that can be loaded.
void | setLoadExtensions (const String &extensions)
Sets the set of file extensions that can be loaded.
bool | canWrite (const String &extension) const
Returns true if the given file type can be written.
const String & | writeExtensions () const
Returns the string containing the file types that can be written.
void | setWriteExtensions (const String &extensions)
Sets the set of file extensions that can be written.

Protected Attributes

String mLoadExtensions
String mWriteExtensions

Detailed Description

The ResourceLoadWriter class is an abstract class used to implement read/write support for one or more resource types.

Constructor & Destructor Documentation

vl::ResourceLoadWriter::ResourceLoadWriter | ( | const String & | load_extensions,
 |  | const String & | write_extensions |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::ResourceLoadWriter::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, and vl::LoadWriterTIFF.

virtual ref<ResourceDatabase> vl::ResourceLoadWriter::loadResource ( const String & path ) const [pure virtual]

Implemented in vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, and vl::LoadWriterTIFF.

virtual ref<ResourceDatabase> vl::ResourceLoadWriter::loadResource ( VirtualFile * file ) const [pure virtual]

Implemented in vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, and vl::LoadWriterTIFF.

virtual bool vl::ResourceLoadWriter::writeResource | ( | const String & | path,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [pure virtual]

Implemented in vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, and vl::LoadWriterTIFF.

virtual bool vl::ResourceLoadWriter::writeResource | ( | VirtualFile * | file,
 |  | ResourceDatabase * | resource |
 | ) |  |  | const [pure virtual]

Implemented in vl::LoadWriter3DS, vl::LoadWriterAC3D, vl::LoadWriterBMP, vl::LoadWriterDAT, vl::LoadWriterDDS, vl::LoadWriterDICOM, vl::LoadWriterJPG, vl::LoadWriterMD2, vl::LoadWriterOBJ, vl::LoadWriterPLY, vl::LoadWriterPNG, vl::LoadWriterSTL, vl::LoadWriterTGA, and vl::LoadWriterTIFF.

bool vl::ResourceLoadWriter::canLoad ( const String & extension ) const [inline]

Returns true if the given file type can be loaded.

Note that the check is not case sensitive.

const String& vl::ResourceLoadWriter::loadExtensions ( ) const [inline]

Returns the string containing the file types that can be loaded.

The extensions returned are always lower-case.

void vl::ResourceLoadWriter::setLoadExtensions ( const String & extensions ) [inline]

Sets the set of file extensions that can be loaded.

The string must be of the form "|.ext1|.ext2|.ext3|" for example "|.jpg|.png|.gif|". Note that the file extension matching is non case sensitive, so for example the above extension includes also files with the following extensions: .JPG .Png, GiF and so on.

bool vl::ResourceLoadWriter::canWrite ( const String & extension ) const [inline]

Returns true if the given file type can be written.

Note that the check is not case sensitive.

const String& vl::ResourceLoadWriter::writeExtensions ( ) const [inline]

Returns the string containing the file types that can be written.

The extensions returned are always lower-case.

void vl::ResourceLoadWriter::setWriteExtensions ( const String & extensions ) [inline]

Sets the set of file extensions that can be written.

The string must be of the form "|.ext1|.ext2|.ext3|" for example "|.jpg|.png|.gif|". Note that the file extension matching is non case sensitive, so for example the above extension includes also files with the following extensions: .JPG .Png, GiF and so on.

Member Data Documentation

String vl::ResourceLoadWriter::mLoadExtensions [protected]

String vl::ResourceLoadWriter::mWriteExtensions [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceLoadWriter.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SampleCoverage Class Reference

vl::SampleCoverage

vl::SampleCoverage Class Reference

Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::SampleCoverage:

vl::RenderState vl::Object

List of all members.

Public Member Functions

SampleCoverage (GLclampf value=1.0f, bool invert=false)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (GLclampf value, bool invert)
void | setValue (GLclampf value)
void | setInvert (bool invert)
GLclampf | value () const
bool | invert () const

Protected Attributes

GLclampf | mValue
bool | mInvert

Detailed Description

Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information.

See also:
Shader, Effect, Actor, vl::EN_MULTISAMPLE, vl::EN_SAMPLE_ALPHA_TO_COVERAGE, vl::EN_SAMPLE_ALPHA_TO_ONE, vl::EN_SAMPLE_COVERAGE

Constructor & Destructor Documentation

vl::SampleCoverage::SampleCoverage | ( | GLclampf | value = 1.0f,
 |  | bool | invert = false |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::SampleCoverage::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::SampleCoverage::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void SampleCoverage::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::SampleCoverage::set | ( | GLclampf | value,
 |  | bool | invert |
 | ) |  |  | [inline]

void vl::SampleCoverage::setValue ( GLclampf value ) [inline]

void vl::SampleCoverage::setInvert ( bool invert ) [inline]

GLclampf vl::SampleCoverage::value ( ) const [inline]

bool vl::SampleCoverage::invert ( ) const [inline]

Member Data Documentation

GLclampf vl::SampleCoverage::mValue [protected]

bool vl::SampleCoverage::mInvert [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Say Class Reference

vl::Say

vl::Say Class Reference

A simple String formatting class. More...

#include <Say.hpp>

List of all members.

Public Member Functions

Say (const String &fstr)
Say & | operator<< (const SayArg &p)
template<typename T >
Say & | operator<< (T p)
operator String ()
String | str () const

Public Attributes

String format_string

Protected Member Functions

String | parse (const Say &pset) const
String | euronotation (const String &str, int base) const
String | format (unsigned long long n, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const
String | format (signed long long nn, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const
String | format (double num, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const
String | pipeline (const String &str, int base, int field, int decimals, int finalizer, int align, int eur, unsigned short fill, int negative, int plus) const

Detailed Description

A simple String formatting class.

Remarks:
Things that we cannot do:
  • Exponential rounding
  • Explicit parameter reference
  • Dynamic field and decimal length
Things we can do:
  • Handles: String, char*, signed/unsigned char/short/int/long long, float, double
  • Shows both integer and fractional numbers in the following bases 2, 8, 10, 16 (actually any base between 2 and 16 but the parser knows only these 4)
  • Field size
  • Field alignment
  • "+" Sign
  • Decimal field size with rounding (only for normal notation for now)
  • Uppercase and lowercase output
  • "Euro" notation ouput for numbers
  • Normal and exponential notation
  • Clear and helpful debugging messages
  • Typesafe, portable, easy to use, clean

Constructor & Destructor Documentation

vl::Say::Say ( const String & fstr ) [inline]

Member Function Documentation

Say& vl::Say::operator<< ( const SayArg & p ) [inline]

template<typename T >
Say& vl::Say::operator<< ( T p ) [inline]

vl::Say::operator String ( ) [inline]

String vl::Say::str ( ) const [inline]

String Say::parse ( const Say & pset ) const [protected]

String Say::euronotation | ( | const String & | str,
 |  | int | base |
 | ) |  |  | const [protected]

String Say::format | ( | unsigned long long | n,
 |  | int | base,
 |  | int | field,
 |  | int | decimals,
 |  | int | align,
 |  | unsigned short | fill,
 |  | int | plus,
 |  | int | finalizer,
 |  | int | eur |
 | ) |  |  | const [protected]

String Say::format | ( | signed long long | nn,
 |  | int | base,
 |  | int | field,
 |  | int | decimals,
 |  | int | align,
 |  | unsigned short | fill,
 |  | int | plus,
 |  | int | finalizer,
 |  | int | eur |
 | ) |  |  | const [protected]

String Say::format | ( | double | num,
 |  | int | base,
 |  | int | field,
 |  | int | decimals,
 |  | int | align,
 |  | unsigned short | fill,
 |  | int | plus,
 |  | int | finalizer,
 |  | int | eur |
 | ) |  |  | const [protected]

String Say::pipeline | ( | const String & | str,
 |  | int | base,
 |  | int | field,
 |  | int | decimals,
 |  | int | finalizer,
 |  | int | align,
 |  | int | eur,
 |  | unsigned short | fill,
 |  | int | negative,
 |  | int | plus |
 | ) |  |  | const [protected]

Member Data Documentation

String vl::Say::format_string

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SayArg Class Reference

vl::SayArg

vl::SayArg Class Reference

Used internally by the Say class. More...

#include <Say.hpp>

List of all members.

Public Member Functions

SayArg ()
SayArg (const unsigned char *d)
SayArg (const std::string &d)
SayArg (const char *d)
SayArg (void *d)
SayArg (const String &d)
SayArg (double d)
SayArg (float d)
SayArg (unsigned char d)
SayArg (signed char d)
SayArg (unsigned short d)
SayArg (signed short d)
SayArg (unsigned int d)
SayArg (signed int d)
SayArg (unsigned long d)
SayArg (signed long d)
SayArg (unsigned long long d)
SayArg (signed long long d)

Protected Types

enum {
NO_TYPE, STRING, FLOAT64, ULONGLONG,
SLONGLONG
}

Protected Member Functions

void | init ()

Protected Attributes

String str
double | float64
unsigned long long | ulonglong
signed long long | slonglong
enum vl::SayArg:: { ... } | type

Friends

class | Say

Detailed Description

Used internally by the Say class.

Member Enumeration Documentation

anonymous enum [protected]

Enumerator:
NO_TYPE
STRING
FLOAT64
ULONGLONG
SLONGLONG

Constructor & Destructor Documentation

SayArg::SayArg ( )

SayArg::SayArg ( const unsigned char * d ) [explicit]

SayArg::SayArg ( const std::string & d ) [explicit]

SayArg::SayArg ( const char * d ) [explicit]

SayArg::SayArg ( void * d ) [explicit]

SayArg::SayArg ( const String & d ) [explicit]

SayArg::SayArg ( double d ) [explicit]

SayArg::SayArg ( float d ) [explicit]

SayArg::SayArg ( unsigned char d ) [explicit]

SayArg::SayArg ( signed char d ) [explicit]

SayArg::SayArg ( unsigned short d ) [explicit]

SayArg::SayArg ( signed short d ) [explicit]

SayArg::SayArg ( unsigned int d ) [explicit]

SayArg::SayArg ( signed int d ) [explicit]

SayArg::SayArg ( unsigned long d ) [explicit]

SayArg::SayArg ( signed long d ) [explicit]

SayArg::SayArg ( unsigned long long d ) [explicit]

SayArg::SayArg ( signed long long d ) [explicit]

Member Function Documentation

void SayArg::init ( ) [protected]

Friends And Related Function Documentation

friend class Say [friend]

Member Data Documentation

String vl::SayArg::str [protected]

double vl::SayArg::float64 [protected]

unsigned long long vl::SayArg::ulonglong [protected]

signed long long vl::SayArg::slonglong [protected]

enum { ... } vl::SayArg::type [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SceneManager Class Reference

vl::SceneManager

vl::SceneManager Class Reference

The SceneManager class is the base class for all the scene managers. More...

#include <SceneManager.hpp>

Inheritance diagram for vl::SceneManager:

vl::Object vl::SceneManagerBVH< ActorKdTree > vl::SceneManagerBVH< ActorTree > vl::SceneManagerBVH< T > vl::SceneManagerPortals vlVG::SceneManagerVectorGraphics vl::SceneManagerActorKdTree vl::SceneManagerActorTree vl::Terrain

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
SceneManager ()
Constructor.
virtual void | appendVisibleActors (ActorCollection &list, const Camera *camera)=0
Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.
virtual void | appendActors (ActorCollection &list)=0
Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.
virtual void | computeBounds ()
Computes the bounding box and bounding sphere of the scene manager and of all the Actor[s] contained in the SceneManager.
void | setBoundingSphere (const Sphere &sphere)
Explicitly set the scene manager's bounding sphere. See also computeBounds().
const Sphere & | boundingSphere () const
Returns the scene manager's bounding sphere.
void | setBoundingBox (const AABB &bbox)
Explicitly set the scene manager's bounding sphere. See also computeBounds().
const AABB & | boundingBox () const
Returns the scene manager's bounding box.
void | setBoundsDirty (bool dirty)
Flags a scene manager's bounding box and bounding sphere as dirty. The bounds will be recomputed using computeBounds() at the next rendering frame.
bool | boundsDirty () const
Returns true if the scene manager's bounds should be recomputed at the next rendering frame.
void | setCullingEnabled (bool enable)
Used to enable or disable frustum culling or whichever culling system the scene manager implements.
bool | cullingEnabled () const
Used to enable or disable frustum culling or whichever culling system the scene manager implements.
void | setEnableMask (unsigned int enabled)
unsigned int | enableMask () const
bool | isEnabled (Actor *a)
Returns true if "a->enableMask() & enableMask()) != 0".

Protected Attributes

Sphere mSphere
AABB mAABB
unsigned int | mEnableMask
bool | mBoundsDirty
bool | mCullingEnabled

Detailed Description

The SceneManager class is the base class for all the scene managers.

A SceneManager implements an algorithm used to quickly identify which objects are visible and which ones are not. The algorithm can be a space partitioning scheme like a BSP, Kd-Tree, Octree etc. or a visibility based scheme like sector/portals, precomputed PVS etc. or a mix of them. The set of SceneManager[s] attached to a Rendering defines the scene. In fact, if an Actor does not belong to any SceneManager it will not have any chance of being rendered.

Visualization Library allows you to bind and use multiple SceneManagers at the same time within the same Rendering. Note that an Actor should belong to one and only one SceneManager otherwise you might end up rendering twice the same Actor thus wasting computational resources.

In order to implement your own scene manager you will have to dirive from the SceneManager class and provide an appropriate implementation for the following methods: appendVisibleActors(), appendActors().

See also:
  • ActorKdTree
  • ActorTree
  • SceneManager
  • SceneManagerActorKdTree
  • SceneManagerActorTree
  • SceneManagerPortals
  • Actor

Constructor & Destructor Documentation

SceneManager::SceneManager ( )

Constructor.

Member Function Documentation

virtual const char* vl::SceneManager::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::SceneManagerActorKdTree, vl::SceneManagerActorTree, vl::SceneManagerBVH< T >, vl::Terrain, vlVG::SceneManagerVectorGraphics, vl::SceneManagerBVH< ActorKdTree >, and vl::SceneManagerBVH< ActorTree >.

virtual void vl::SceneManager::appendVisibleActors | ( | ActorCollection & | list,
 |  | const Camera * | camera |
 | ) |  |  | [pure virtual]

Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.

See also enableMask(), Actor::enableMask()

Implemented in vl::SceneManagerBVH< T >, vl::SceneManagerPortals, vlVG::SceneManagerVectorGraphics, vl::SceneManagerBVH< ActorKdTree >, and vl::SceneManagerBVH< ActorTree >.

virtual void vl::SceneManager::appendActors ( ActorCollection & list ) [pure virtual]

Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.

Implemented in vl::SceneManagerBVH< T >, vl::SceneManagerPortals, vlVG::SceneManagerVectorGraphics, vl::SceneManagerBVH< ActorKdTree >, and vl::SceneManagerBVH< ActorTree >.

void SceneManager::computeBounds ( ) [virtual]

Computes the bounding box and bounding sphere of the scene manager and of all the Actor[s] contained in the SceneManager.

void vl::SceneManager::setBoundingSphere ( const Sphere & sphere ) [inline]

Explicitly set the scene manager's bounding sphere. See also computeBounds().

const Sphere& vl::SceneManager::boundingSphere ( ) const [inline]

Returns the scene manager's bounding sphere.

void vl::SceneManager::setBoundingBox ( const AABB & bbox ) [inline]

Explicitly set the scene manager's bounding sphere. See also computeBounds().

const AABB& vl::SceneManager::boundingBox ( ) const [inline]

Returns the scene manager's bounding box.

void vl::SceneManager::setBoundsDirty ( bool dirty ) [inline]

Flags a scene manager's bounding box and bounding sphere as dirty. The bounds will be recomputed using computeBounds() at the next rendering frame.

bool vl::SceneManager::boundsDirty ( ) const [inline]

Returns true if the scene manager's bounds should be recomputed at the next rendering frame.

void vl::SceneManager::setCullingEnabled ( bool enable ) [inline]

Used to enable or disable frustum culling or whichever culling system the scene manager implements.

bool vl::SceneManager::cullingEnabled ( ) const [inline]

Used to enable or disable frustum culling or whichever culling system the scene manager implements.

void vl::SceneManager::setEnableMask ( unsigned int enabled ) [inline]

unsigned int vl::SceneManager::enableMask ( ) const [inline]

bool vl::SceneManager::isEnabled ( Actor * a ) [inline]

Returns true if "a->enableMask() & enableMask()) != 0".

Member Data Documentation

Sphere vl::SceneManager::mSphere [protected]

AABB vl::SceneManager::mAABB [protected]

unsigned int vl::SceneManager::mEnableMask [protected]

bool vl::SceneManager::mBoundsDirty [protected]

bool vl::SceneManager::mCullingEnabled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SceneManagerActorKdTree Class Reference

vl::SceneManagerActorKdTree

vl::SceneManagerActorKdTree Class Reference

A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree. More...

#include <SceneManagerActorKdTree.hpp>

Inheritance diagram for vl::SceneManagerActorKdTree:

vl::SceneManagerBVH< ActorKdTree > vl::SceneManager vl::Object vl::Terrain

List of all members.

Public Member Functions

virtual const char * className ()
Returns the name of the class.
SceneManagerActorKdTree ()

Detailed Description

A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree.

See also:
  • Actor
  • ActorKdTree
  • ActorTree
  • SceneManager
  • SceneManagerBVH
  • SceneManagerActorTree
  • SceneManagerPortals

Constructor & Destructor Documentation

vl::SceneManagerActorKdTree::SceneManagerActorKdTree ( ) [inline]

Member Function Documentation

virtual const char* vl::SceneManagerActorKdTree::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::SceneManagerBVH< ActorKdTree >.

Reimplemented in vl::Terrain.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SceneManagerActorTree Class Reference

vl::SceneManagerActorTree

vl::SceneManagerActorTree Class Reference

A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree. More...

#include <SceneManagerActorTree.hpp>

Inheritance diagram for vl::SceneManagerActorTree:

vl::SceneManagerBVH< ActorTree > vl::SceneManager vl::Object

List of all members.

Public Member Functions

virtual const char * className ()
Returns the name of the class.
SceneManagerActorTree ()

Detailed Description

A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree.

See also:
  • Actor
  • ActorKdTree
  • ActorTree
  • SceneManager
  • SceneManagerBVH
  • SceneManagerActorKdTree
  • SceneManagerPortals

Constructor & Destructor Documentation

vl::SceneManagerActorTree::SceneManagerActorTree ( ) [inline]

Member Function Documentation

virtual const char* vl::SceneManagerActorTree::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::SceneManagerBVH< ActorTree >.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorTree.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SceneManagerBVH< T > Class Template Reference

vl::SceneManagerBVH

vl::SceneManagerBVH< T > Class Template Reference

The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers. More...

#include <SceneManagerBVH.hpp>

Inheritance diagram for vl::SceneManagerBVH< T >:

vl::SceneManager vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
void | setTree (T *bbh)
Sets the tree to be used by the scene manager.
const T * | tree () const
Returns the tree used by the scene manager.
T * | tree ()
Returns the tree used by the scene manager.
virtual void | appendVisibleActors (ActorCollection &list, const Camera *camera)
Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.
virtual void | appendActors (ActorCollection &list)
Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.

Protected Attributes

ref< T > | mBoundingVolumeTree

Detailed Description

template<class T>
class vl::SceneManagerBVH< T >

The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers.

See also:
  • Actor
  • ActorKdTree
  • ActorTree
  • SceneManager
  • SceneManagerActorKdTree
  • SceneManagerActorTree
  • SceneManagerPortals

Member Function Documentation

template<class T>
virtual const char* vl::SceneManagerBVH< T >::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::SceneManager.

Reimplemented in vl::SceneManagerActorKdTree, vl::SceneManagerActorTree, and vl::Terrain.

template<class T>
void vl::SceneManagerBVH< T >::setTree ( T * bbh ) [inline]

Sets the tree to be used by the scene manager.

template<class T>
const T* vl::SceneManagerBVH< T >::tree ( ) const [inline]

Returns the tree used by the scene manager.

template<class T>
T* vl::SceneManagerBVH< T >::tree ( ) [inline]

Returns the tree used by the scene manager.

template<class T>
virtual void vl::SceneManagerBVH< T >::appendVisibleActors | ( | ActorCollection & | list,
 |  | const Camera * | camera |
 | ) |  |  | [inline, virtual]

Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.

See also enableMask(), Actor::enableMask()

Implements vl::SceneManager.

template<class T>
virtual void vl::SceneManagerBVH< T >::appendActors ( ActorCollection & list ) [inline, virtual]

Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.

Implements vl::SceneManager.

Member Data Documentation

template<class T>
ref<T> vl::SceneManagerBVH< T >::mBoundingVolumeTree [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerBVH.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::SceneManagerPortals Class Reference

vl::SceneManagerPortals

vl::SceneManagerPortals Class Reference

The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes. More...

#include <SceneManagerPortals.hpp>

Inheritance diagram for vl::SceneManagerPortals:

vl::SceneManager vl::Object

List of all members.

Public Member Functions

SceneManagerPortals ()
Constructor.
void | appendActors (ActorCollection &list)
Appends to the given list all the Actor[s] contained in the scene regardless of their visibility.
void | appendVisibleActors (ActorCollection &list, const Camera *camera)
Appends to the given list all the visible Actor[s] using the portal culling algorithm.
std::vector< ref< Sector > > & | sectors ()
The Sectors that are part of the scene.
const std::vector< ref< Sector > > & | sectors () const
The Sectors that are part of the scene.
Sector * externalSector ()
Returns the external sector.
const Sector * | externalSector () const
Returns the external sector.
void | computePortalNormals ()
Compute the normal of the sectors.
void | initialize ()
Calls computePortalNormals() and performs some error checking.
bool | showPortals () const
Whether portals should be shown in the rendering or not.
void | setShowPortals (bool show)
Whether portals should be shown in the rendering or not.
const std::vector< Frustum > & | frustumStack () const
The stack of frustums active at a given point during sector discovery.

Protected Member Functions

void | renderPortal (Portal *portal)
void | visitSector (Sector *prev, Sector *sector, const vec3 &eye, const Camera *camera)
Sector * | computeStartingSector (const Camera *camera)

Protected Attributes

ref< Sector > mExternalSector
std::vector< ref< Sector > > | mSectors
std::vector< ref< Actor > > | mTempActors
std::map< Portal *, ref< Actor > > | mPortalActorMap
std::vector< Frustum > | mFrustumStack
unsigned | mVisitTick
bool | mShowPortals

Detailed Description

The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes.

See also:
  • Portal-Based Culling and Scene Management Tutorial
  • Portal
  • Sector
  • Actor
  • ActorKdTree
  • ActorTree
  • SceneManager
  • SceneManagerBVH
  • SceneManagerActorKdTree
  • SceneManagerActorTree

Constructor & Destructor Documentation

vl::SceneManagerPortals::SceneManagerPortals ( ) [inline]

Constructor.

Member Function Documentation

void SceneManagerPortals::appendActors ( ActorCollection & list ) [virtual]

Appends to the given list all the Actor[s] contained in the scene regardless of their visibility.

Implements vl::SceneManager.

void SceneManagerPortals::appendVisibleActors | ( | ActorCollection & | list,
 |  | const Camera * | camera |
 | ) |  |  | [virtual]

Appends to the given list all the visible Actor[s] using the portal culling algorithm.

Implements vl::SceneManager.

std::vector< ref<Sector> >& vl::SceneManagerPortals::sectors ( ) [inline]

The Sectors that are part of the scene.

const std::vector< ref<Sector> >& vl::SceneManagerPortals::sectors ( ) const [inline]

The Sectors that are part of the scene.

Sector* vl::SceneManagerPortals::externalSector ( ) [inline]

Returns the external sector.

The external sector is a special sector that is considered visible when the camera is not inside any other sector. The external sector can be used to contain objects that are outside the indoor environment defined by the other "normal" sectors. For example, you could use the SceneManagerPortals to model a house and put in the external sector all the objects that are outside the house. The portals inside the house can point to the external sector so that the objects outside the house are rendered only if they are visible through a door or a window for maximum performances. Of course you can also go from an external sector to an internal sector just as well using one or more portals.

const Sector* vl::SceneManagerPortals::externalSector ( ) const [inline]

Returns the external sector.

void SceneManagerPortals::computePortalNormals ( )

Compute the normal of the sectors.

void SceneManagerPortals::initialize ( )

Calls computePortalNormals() and performs some error checking.

bool vl::SceneManagerPortals::showPortals ( ) const [inline]

Whether portals should be shown in the rendering or not.

void vl::SceneManagerPortals::setShowPortals ( bool show ) [inline]

Whether portals should be shown in the rendering or not.

const std::vector<Frustum>& vl::SceneManagerPortals::frustumStack ( ) const [inline]

The stack of frustums active at a given point during sector discovery.

void SceneManagerPortals::renderPortal ( Portal * portal ) [protected]

void SceneManagerPortals::visitSector | ( | Sector * | prev,
 |  | Sector * | sector,
 |  | const vec3 & | eye,
 |  | const Camera * | camera |
 | ) |  |  | [protected]

Sector * SceneManagerPortals::computeStartingSector ( const Camera * camera ) [protected]

Member Data Documentation

ref<Sector> vl::SceneManagerPortals::mExternalSector [protected]

std::vector< ref<Sector> > vl::SceneManagerPortals::mSectors [protected]

std::vector< ref<Actor> > vl::SceneManagerPortals::mTempActors [protected]

std::map<Portal*, ref<Actor> > vl::SceneManagerPortals::mPortalActorMap [protected]

std::vector<Frustum> vl::SceneManagerPortals::mFrustumStack [protected]

unsigned vl::SceneManagerPortals::mVisitTick [protected]

bool vl::SceneManagerPortals::mShowPortals [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::Scissor Class Reference

vl::Scissor

vl::Scissor Class Reference

The Scissor class wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information. More...

#include <Scissor.hpp>

Inheritance diagram for vl::Scissor:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Scissor (int x, int y, int width, int height)
void | enable (const Viewport *viewport) const
Enables the scissor test on the area specified by scissorRect() clipped against the given Viewport.
void | disable ()
Disables the scissor test.
void | setScissor (int x, int y, int width, int height)
Defines the scissor box.
void | setScissor (const RectI &scissor)
Defines the scissor box.
const RectI & | scissorRect () const
Returns the scissor box.
bool | operator< (const Scissor &other) const
Defines a sort of lexicographic sorting that make possible the use of the Scissor class with STL containers like std::set, std::map etc.

Protected Attributes

RectI mScissor

Detailed Description

The Scissor class wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information.

See also:
  • Actor::setScissor()
  • Shader::setScissor()

Constructor & Destructor Documentation

vl::Scissor::Scissor | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::Scissor::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::Scissor::enable ( const Viewport * viewport ) const [inline]

Enables the scissor test on the area specified by scissorRect() clipped against the given Viewport.

void vl::Scissor::disable ( ) [inline]

Disables the scissor test.

void vl::Scissor::setScissor | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height |
 | ) |  |  | [inline]

Defines the scissor box.

The left, bottom, right and top parameters are in windows coordinates. See also http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information.

void vl::Scissor::setScissor ( const RectI & scissor ) [inline]

Defines the scissor box.

The left, bottom, right and top parameters are in windows coordinates. See also http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information.

const RectI& vl::Scissor::scissorRect ( ) const [inline]

Returns the scissor box.

bool vl::Scissor::operator< ( const Scissor & other ) const [inline]

Defines a sort of lexicographic sorting that make possible the use of the Scissor class with STL containers like std::set, std::map etc.

Member Data Documentation

RectI vl::Scissor::mScissor [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Scissor.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::Sector Class Reference

vl::Sector

vl::Sector Class Reference

Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s]. More...

#include <SceneManagerPortals.hpp>

Inheritance diagram for vl::Sector:

vl::Object

List of all members.

Classes

class | VisibilityCallback
A callback object called each time a Sector becomes visible through a Portal. More...

Public Member Functions

Sector ()
Constructor.
ActorCollection * actors ()
The Actor object contained in a sector. An actor can be part of multiple sectors.
const ActorCollection * | actors () const
The Actor object contained in a sector. An actor can be part of multiple sectors.
std::vector< ref< Portal > > & | portals ()
The portals within a sector that connect it to other sectors.
const std::vector< ref< Portal > > & | portals () const
The portals within a sector that connect it to other sectors.
std::vector< AABB > & | volumes ()
A set of volumes used to test if the camera is or not inside a Sector.
const std::vector< AABB > & | volumes () const
A set of volumes used to test if the camera is or not inside a Sector.
AABB computeBoundingBox ()
Returns the bounding box of all the Actor[s] in the sector.
std::vector< ref
< VisibilityCallback > > & 		callbacks ()
const std::vector< ref
< VisibilityCallback > > & 		callbacks () const
void | executeCallbacks (const Camera *cam, SceneManagerPortals *psm, Portal *p)

Protected Attributes

std::vector< ref< Portal > > | mPortals
std::vector< AABB > | mVolumes
ref< ActorCollection > mActors
std::vector< ref
< VisibilityCallback > > 		mCallbacks

Detailed Description

Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s].

See also:

  • SceneManagerPortals
  • Portal
  • Portal-Based Culling and Scene Management Tutorial

Constructor & Destructor Documentation

vl::Sector::Sector ( ) [inline]

Constructor.

Member Function Documentation

ActorCollection* vl::Sector::actors ( ) [inline]

The Actor object contained in a sector. An actor can be part of multiple sectors.

const ActorCollection* vl::Sector::actors ( ) const [inline]

The Actor object contained in a sector. An actor can be part of multiple sectors.

std::vector< ref<Portal> >& vl::Sector::portals ( ) [inline]

The portals within a sector that connect it to other sectors.

const std::vector< ref<Portal> >& vl::Sector::portals ( ) const [inline]

The portals within a sector that connect it to other sectors.

std::vector< AABB >& vl::Sector::volumes ( ) [inline]

A set of volumes used to test if the camera is or not inside a Sector.

The volumes of a sector must not intersecate with the volumes of another sector.

const std::vector< AABB >& vl::Sector::volumes ( ) const [inline]

A set of volumes used to test if the camera is or not inside a Sector.

The volumes of a sector must not intersecate with the volumes of another sector.

AABB Sector::computeBoundingBox ( )

Returns the bounding box of all the Actor[s] in the sector.

std::vector< ref<VisibilityCallback> >& vl::Sector::callbacks ( ) [inline]

const std::vector< ref<VisibilityCallback> >& vl::Sector::callbacks ( ) const [inline]

void Sector::executeCallbacks | ( | const Camera * | cam,
 |  | SceneManagerPortals * | psm,
 |  | Portal * | p
 | ) |  |

Member Data Documentation

std::vector< ref<Portal> > vl::Sector::mPortals [protected]

std::vector< AABB > vl::Sector::mVolumes [protected]

ref< ActorCollection > vl::Sector::mActors [protected]

std::vector< ref<VisibilityCallback> > vl::Sector::mCallbacks [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::Sector::VisibilityCallback Class Reference

vl::Sector::VisibilityCallback

vl::Sector::VisibilityCallback Class Reference

A callback object called each time a Sector becomes visible through a Portal. More...

#include <SceneManagerPortals.hpp>

Inheritance diagram for vl::Sector::VisibilityCallback:

vl::Object

List of all members.

Public Member Functions

virtual void operator() (const Camera *cam, SceneManagerPortals *psm, Sector *s, Portal *p)=0
Callback.

Detailed Description

A callback object called each time a Sector becomes visible through a Portal.

Note: a callback can be called multiple times with the same Sector argument if a Sector is discovered multiple times through different portals. Using callbacks can be very useful to perform special actions upon sector discovery, like enabling/disabling animations, enabling/disabling a ActorKdTree scene manager or a Terrain scene manager to render the external environment etc.

Member Function Documentation

virtual void vl::Sector::VisibilityCallback::operator() | ( | const Camera * | cam,
 |  | SceneManagerPortals * | psm,
 |  | Sector * | s,
 |  | Portal * | p |
 | ) |  |  | [pure virtual]

Callback.

Note: a callback can be called multiple times with the same Sector argument if a Sector is discovered multiple times through different portals.

Parameters:
cam | The current Camera.
psm | The SceneManagerPortals that generated the callback.
s | The Sector that has become visible.
p | The Portal used to enter the Sector. It is set to NULL if s is the starting Sector (the Sector in which the camera is).

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: vl::ShadeModel Class Reference

vl::ShadeModel

vl::ShadeModel Class Reference

Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::ShadeModel:

vl::RenderState vl::Object

List of all members.

Public Member Functions

ShadeModel (EShadeModel shademodel=SM_SMOOTH)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EShadeModel shademodel)
EShadeModel | shadeModel () const

Protected Attributes

EShadeModel mShadeModel

Detailed Description

Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::ShadeModel::ShadeModel ( EShadeModel shademodel = SM_SMOOTH ) [inline]

Member Function Documentation

virtual const char* vl::ShadeModel::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::ShadeModel::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void ShadeModel::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::ShadeModel::set ( EShadeModel shademodel ) [inline]

EShadeModel vl::ShadeModel::shadeModel ( ) const [inline]

Member Data Documentation

EShadeModel vl::ShadeModel::mShadeModel [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::Shader Class Reference

vl::Shader

vl::Shader Class Reference

Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects. More...

#include <Shader.hpp>

Inheritance diagram for vl::Shader:

vl::Object

List of all members.

Public Member Functions

Shader ()
virtual | ~Shader ()
virtual const char * | className ()
Returns the name of the class.
GLSLProgram * gocGLSLProgram ()
const GLSLProgram * | getGLSLProgram () const
GLSLProgram * getGLSLProgram ()
PixelTransfer * gocPixelTransfer ()
const PixelTransfer * | getPixelTransfer () const
PixelTransfer * getPixelTransfer ()
Hint * gocHint ()
const Hint * | getHint () const
Hint * getHint ()
CullFace * gocCullFace ()
const CullFace * | getCullFace () const
CullFace * getCullFace ()
FrontFace * gocFrontFace ()
const FrontFace * | getFrontFace () const
FrontFace * getFrontFace ()
DepthFunc * gocDepthFunc ()
const DepthFunc * | getDepthFunc () const
DepthFunc * getDepthFunc ()
DepthMask * gocDepthMask ()
const DepthMask * | getDepthMask () const
DepthMask * getDepthMask ()
ColorMask * gocColorMask ()
const ColorMask * | getColorMask () const
ColorMask * getColorMask ()
PolygonMode * gocPolygonMode ()
const PolygonMode * | getPolygonMode () const
PolygonMode * getPolygonMode ()
ShadeModel * gocShadeModel ()
const ShadeModel * | getShadeModel () const
ShadeModel * getShadeModel ()
BlendEquation * gocBlendEquation ()
const BlendEquation * | getBlendEquation () const
BlendEquation * getBlendEquation ()
AlphaFunc * gocAlphaFunc ()
const AlphaFunc * | getAlphaFunc () const
AlphaFunc * getAlphaFunc ()
Material * gocMaterial ()
const Material * | getMaterial () const
Material * getMaterial ()
LightModel * gocLightModel ()
const LightModel * | getLightModel () const
LightModel * getLightModel ()
Fog * gocFog ()
const Fog * | getFog () const
Fog * getFog ()
PolygonOffset * gocPolygonOffset ()
const PolygonOffset * | getPolygonOffset () const
PolygonOffset * getPolygonOffset ()
LogicOp * gocLogicOp ()
const LogicOp * | getLogicOp () const
LogicOp * getLogicOp ()
DepthRange * gocDepthRange ()
const DepthRange * | getDepthRange () const
DepthRange * getDepthRange ()
LineWidth * gocLineWidth ()
const LineWidth * | getLineWidth () const
LineWidth * getLineWidth ()
PointSize * gocPointSize ()
const PointSize * | getPointSize () const
PointSize * getPointSize ()
LineStipple * gocLineStipple ()
const LineStipple * | getLineStipple () const
LineStipple * getLineStipple ()
PolygonStipple * gocPolygonStipple ()
const PolygonStipple * | getPolygonStipple () const
PolygonStipple * getPolygonStipple ()
PointParameter * gocPointParameter ()
const PointParameter * | getPointParameter () const
PointParameter * getPointParameter ()
StencilFunc * gocStencilFunc ()
const StencilFunc * | getStencilFunc () const
StencilFunc * getStencilFunc ()
StencilOp * gocStencilOp ()
const StencilOp * | getStencilOp () const
StencilOp * getStencilOp ()
StencilMask * gocStencilMask ()
const StencilMask * | getStencilMask () const
StencilMask * getStencilMask ()
BlendColor * gocBlendColor ()
const BlendColor * | getBlendColor () const
BlendColor * getBlendColor ()
BlendFunc * gocBlendFunc ()
const BlendFunc * | getBlendFunc () const
BlendFunc * getBlendFunc ()
SampleCoverage * gocSampleCoverage ()
const SampleCoverage * | getSampleCoverage () const
SampleCoverage * getSampleCoverage ()
Light * | gocLight (int light_index)
const Light * | getLight (int light_index) const
Light * | getLight (int light_index)
ClipPlane * | gocClipPlane (int plane_index)
const ClipPlane * | getClipPlane (int plane_index) const
ClipPlane * | getClipPlane (int plane_index)
TextureUnit * | gocTextureUnit (int unit_index)
const TextureUnit * | getTextureUnit (int unit_index) const
TextureUnit * | getTextureUnit (int unit_index)
TexEnv * | gocTexEnv (int unit_index)
const TexEnv * | getTexEnv (int unit_index) const
TexEnv * | getTexEnv (int unit_index)
TexGen * | gocTexGen (int unit_index)
const TexGen * | getTexGen (int unit_index) const
TexGen * | getTexGen (int unit_index)
TextureMatrix * | gocTextureMatrix (int unit_index)
const TextureMatrix * | getTextureMatrix (int unit_index) const
TextureMatrix * | getTextureMatrix (int unit_index)
void | reset ()
void | enable (EEnable capability)
void | disable (EEnable capability)
const std::vector< EEnable > & | enables () const
int | isEnabled (EEnable capability) const
void | disableAll ()
bool | blendingEnabled () const
void | setRenderState (RenderState *renderstate)
const RenderState * | renderState (ERenderState type) const
RenderState * | renderState (ERenderState type)
const std::vector< ref
< RenderState > > & 		renderStates () const
void | eraseRenderState (ERenderState type)
void | eraseRenderState (RenderState *rs)
void | eraseAllRenderStates ()
const GLSLProgram * | glslProgram () const
Returns the GLSLProgram associated to a Shader (if any).
GLSLProgram * glslProgram ()
Returns the GLSLProgram associated to a Shader (if any).
void | setUniform (Uniform *uniform)
Equivalent to gocUniformSet()->setUniform(...).
const std::vector< ref
< Uniform > > & 		uniforms () const
Equivalent to gocUniformSet()->uniforms(...).
void | eraseUniform (const std::string &name)
Equivalent to gocUniformSet()->eraseUniform(...).
void | eraseUniform (const Uniform *uniform)
Equivalent to gocUniformSet()->eraseUniform(...).
void | eraseAllUniforms ()
Equivalent to gocUniformSet()->eraseAllUniforms(...).
Uniform * | gocUniform (const std::string &name)
Equivalent to gocUniformSet()->gocUniform(...).
Uniform * | getUniform (const std::string &name)
Equivalent to gocUniformSet()->getUniform(...).
const Uniform * | getUniform (const std::string &name) const
Equivalent to gocUniformSet()->getUniform(...).
EnableSet * gocEnableSet ()
EnableSet * getEnableSet ()
const EnableSet * | getEnableSet () const
RenderStateSet * gocRenderStateSet ()
RenderStateSet * getRenderStateSet ()
const RenderStateSet * | getRenderStateSet () const
UniformSet * gocUniformSet ()
Returns the UniformSet installed (creating it if no UniformSet has been installed).
UniformSet * getUniformSet ()
Returns the UniformSet installed.
const UniformSet * | getUniformSet () const
Returns the UniformSet installed.
void | setEnableSet (EnableSet *es)
void | setRenderStateSet (RenderStateSet *rss)
void | setUniformSet (UniformSet *us)
Installs a new UniformSet.
void | setScissor (Scissor *scissor)
Sets the Scissor to be used when rendering an Actor.
const Scissor * | scissor () const
Returns the Scissor to be used when rendering an Actor.
Scissor * scissor ()
Returns the Scissor to be used when rendering an Actor.
virtual void | update (Camera *, Real)
Virtual function used to update or animate a Shader during the rendering.
void | setLastUpdateTime (Real time)
Used internally.
Real | lastUpdateTime () const
Used internally.
void | initResources ()

Protected Attributes

Real mLastUpdateTime
ref< RenderStateSet > mRenderStateSet
ref< EnableSet > mEnableSet
ref< UniformSet > mUniformSet
ref< Scissor > mScissor

Detailed Description

Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects.

A Shader represents a rendering pass. Using the Effect class you can assign more rendering passes to an Actor. You can also specify different sets of rendering passes for each Effect LOD, for more information see Effect.

Remarks:
The Uniforms defined in the Actor and the ones defined in the Shader must not overlap, that is, an Actor must not define Uniforms present in the Shader and vice versa.
See also:
Effect, Actor

Constructor & Destructor Documentation

Shader::Shader ( )

Shader::~Shader ( ) [virtual]

Member Function Documentation

virtual const char* vl::Shader::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

GLSLProgram * Shader::gocGLSLProgram ( )

const GLSLProgram* vl::Shader::getGLSLProgram ( ) const [inline]

GLSLProgram* vl::Shader::getGLSLProgram ( ) [inline]

PixelTransfer * Shader::gocPixelTransfer ( )

const PixelTransfer* vl::Shader::getPixelTransfer ( ) const [inline]

PixelTransfer* vl::Shader::getPixelTransfer ( ) [inline]

Hint * Shader::gocHint ( )

const Hint* vl::Shader::getHint ( ) const [inline]

Hint* vl::Shader::getHint ( ) [inline]

CullFace * Shader::gocCullFace ( )

const CullFace* vl::Shader::getCullFace ( ) const [inline]

CullFace* vl::Shader::getCullFace ( ) [inline]

FrontFace * Shader::gocFrontFace ( )

const FrontFace* vl::Shader::getFrontFace ( ) const [inline]

FrontFace* vl::Shader::getFrontFace ( ) [inline]

DepthFunc * Shader::gocDepthFunc ( )

const DepthFunc* vl::Shader::getDepthFunc ( ) const [inline]

DepthFunc* vl::Shader::getDepthFunc ( ) [inline]

DepthMask * Shader::gocDepthMask ( )

const DepthMask* vl::Shader::getDepthMask ( ) const [inline]

DepthMask* vl::Shader::getDepthMask ( ) [inline]

ColorMask * Shader::gocColorMask ( )

const ColorMask* vl::Shader::getColorMask ( ) const [inline]

ColorMask* vl::Shader::getColorMask ( ) [inline]

PolygonMode * Shader::gocPolygonMode ( )

const PolygonMode* vl::Shader::getPolygonMode ( ) const [inline]

PolygonMode* vl::Shader::getPolygonMode ( ) [inline]

ShadeModel * Shader::gocShadeModel ( )

const ShadeModel* vl::Shader::getShadeModel ( ) const [inline]

ShadeModel* vl::Shader::getShadeModel ( ) [inline]

BlendEquation * Shader::gocBlendEquation ( )

const BlendEquation* vl::Shader::getBlendEquation ( ) const [inline]

BlendEquation* vl::Shader::getBlendEquation ( ) [inline]

AlphaFunc * Shader::gocAlphaFunc ( )

const AlphaFunc* vl::Shader::getAlphaFunc ( ) const [inline]

AlphaFunc* vl::Shader::getAlphaFunc ( ) [inline]

Material * Shader::gocMaterial ( )

const Material* vl::Shader::getMaterial ( ) const [inline]

Material* vl::Shader::getMaterial ( ) [inline]

LightModel * Shader::gocLightModel ( )

const LightModel* vl::Shader::getLightModel ( ) const [inline]

LightModel* vl::Shader::getLightModel ( ) [inline]

Fog * Shader::gocFog ( )

const Fog* vl::Shader::getFog ( ) const [inline]

Fog* vl::Shader::getFog ( ) [inline]

PolygonOffset * Shader::gocPolygonOffset ( )

const PolygonOffset* vl::Shader::getPolygonOffset ( ) const [inline]

PolygonOffset* vl::Shader::getPolygonOffset ( ) [inline]

LogicOp * Shader::gocLogicOp ( )

const LogicOp* vl::Shader::getLogicOp ( ) const [inline]

LogicOp* vl::Shader::getLogicOp ( ) [inline]

DepthRange * Shader::gocDepthRange ( )

const DepthRange* vl::Shader::getDepthRange ( ) const [inline]

DepthRange* vl::Shader::getDepthRange ( ) [inline]

LineWidth * Shader::gocLineWidth ( )

const LineWidth* vl::Shader::getLineWidth ( ) const [inline]

LineWidth* vl::Shader::getLineWidth ( ) [inline]

PointSize * Shader::gocPointSize ( )

const PointSize* vl::Shader::getPointSize ( ) const [inline]

PointSize* vl::Shader::getPointSize ( ) [inline]

LineStipple * Shader::gocLineStipple ( )

const LineStipple* vl::Shader::getLineStipple ( ) const [inline]

LineStipple* vl::Shader::getLineStipple ( ) [inline]

PolygonStipple * Shader::gocPolygonStipple ( )

const PolygonStipple* vl::Shader::getPolygonStipple ( ) const [inline]

PolygonStipple* vl::Shader::getPolygonStipple ( ) [inline]

PointParameter * Shader::gocPointParameter ( )

const PointParameter* vl::Shader::getPointParameter ( ) const [inline]

PointParameter* vl::Shader::getPointParameter ( ) [inline]

StencilFunc * Shader::gocStencilFunc ( )

const StencilFunc* vl::Shader::getStencilFunc ( ) const [inline]

StencilFunc* vl::Shader::getStencilFunc ( ) [inline]

StencilOp * Shader::gocStencilOp ( )

const StencilOp* vl::Shader::getStencilOp ( ) const [inline]

StencilOp* vl::Shader::getStencilOp ( ) [inline]

StencilMask * Shader::gocStencilMask ( )

const StencilMask* vl::Shader::getStencilMask ( ) const [inline]

StencilMask* vl::Shader::getStencilMask ( ) [inline]

BlendColor * Shader::gocBlendColor ( )

const BlendColor* vl::Shader::getBlendColor ( ) const [inline]

BlendColor* vl::Shader::getBlendColor ( ) [inline]

BlendFunc * Shader::gocBlendFunc ( )

const BlendFunc* vl::Shader::getBlendFunc ( ) const [inline]

BlendFunc* vl::Shader::getBlendFunc ( ) [inline]

SampleCoverage * Shader::gocSampleCoverage ( )

const SampleCoverage* vl::Shader::getSampleCoverage ( ) const [inline]

SampleCoverage* vl::Shader::getSampleCoverage ( ) [inline]

Light * Shader::gocLight ( int light_index )

const Light* vl::Shader::getLight ( int light_index ) const [inline]

Light* vl::Shader::getLight ( int light_index ) [inline]

ClipPlane * Shader::gocClipPlane ( int plane_index )

const ClipPlane* vl::Shader::getClipPlane ( int plane_index ) const [inline]

ClipPlane* vl::Shader::getClipPlane ( int plane_index ) [inline]

TextureUnit * Shader::gocTextureUnit ( int unit_index )

const TextureUnit* vl::Shader::getTextureUnit ( int unit_index ) const [inline]

TextureUnit* vl::Shader::getTextureUnit ( int unit_index ) [inline]

TexEnv * Shader::gocTexEnv ( int unit_index )

const TexEnv* vl::Shader::getTexEnv ( int unit_index ) const [inline]

TexEnv* vl::Shader::getTexEnv ( int unit_index ) [inline]

TexGen * Shader::gocTexGen ( int unit_index )

const TexGen* vl::Shader::getTexGen ( int unit_index ) const [inline]

TexGen* vl::Shader::getTexGen ( int unit_index ) [inline]

TextureMatrix * Shader::gocTextureMatrix ( int unit_index )

const TextureMatrix* vl::Shader::getTextureMatrix ( int unit_index ) const [inline]

TextureMatrix* vl::Shader::getTextureMatrix ( int unit_index ) [inline]

void vl::Shader::reset ( ) [inline]

void vl::Shader::enable ( EEnable capability ) [inline]

void vl::Shader::disable ( EEnable capability ) [inline]

const std::vector<EEnable>& vl::Shader::enables ( ) const [inline]

int vl::Shader::isEnabled ( EEnable capability ) const [inline]

void vl::Shader::disableAll ( ) [inline]

bool vl::Shader::blendingEnabled ( ) const [inline]

void vl::Shader::setRenderState ( RenderState * renderstate ) [inline]

const RenderState* vl::Shader::renderState ( ERenderState type ) const [inline]

RenderState* vl::Shader::renderState ( ERenderState type ) [inline]

const std::vector< ref<RenderState> >& vl::Shader::renderStates ( ) const [inline]

void vl::Shader::eraseRenderState ( ERenderState type ) [inline]

void vl::Shader::eraseRenderState ( RenderState * rs ) [inline]

void vl::Shader::eraseAllRenderStates ( ) [inline]

const GLSLProgram* vl::Shader::glslProgram ( ) const [inline]

Returns the GLSLProgram associated to a Shader (if any).

GLSLProgram* vl::Shader::glslProgram ( ) [inline]

Returns the GLSLProgram associated to a Shader (if any).

void vl::Shader::setUniform ( Uniform * uniform ) [inline]

Equivalent to gocUniformSet()->setUniform(...).

const std::vector< ref<Uniform> >& vl::Shader::uniforms ( ) const [inline]

Equivalent to gocUniformSet()->uniforms(...).

void vl::Shader::eraseUniform ( const std::string & name ) [inline]

Equivalent to gocUniformSet()->eraseUniform(...).

void vl::Shader::eraseUniform ( const Uniform * uniform ) [inline]

Equivalent to gocUniformSet()->eraseUniform(...).

void vl::Shader::eraseAllUniforms ( ) [inline]

Equivalent to gocUniformSet()->eraseAllUniforms(...).

Uniform* vl::Shader::gocUniform ( const std::string & name ) [inline]

Equivalent to gocUniformSet()->gocUniform(...).

Uniform* vl::Shader::getUniform ( const std::string & name ) [inline]

Equivalent to gocUniformSet()->getUniform(...).

const Uniform* vl::Shader::getUniform ( const std::string & name ) const [inline]

Equivalent to gocUniformSet()->getUniform(...).

EnableSet* vl::Shader::gocEnableSet ( ) [inline]

EnableSet* vl::Shader::getEnableSet ( ) [inline]

const EnableSet* vl::Shader::getEnableSet ( ) const [inline]

RenderStateSet* vl::Shader::gocRenderStateSet ( ) [inline]

RenderStateSet* vl::Shader::getRenderStateSet ( ) [inline]

const RenderStateSet* vl::Shader::getRenderStateSet ( ) const [inline]

UniformSet* vl::Shader::gocUniformSet ( ) [inline]

Returns the UniformSet installed (creating it if no UniformSet has been installed).

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

UniformSet* vl::Shader::getUniformSet ( ) [inline]

Returns the UniformSet installed.

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

const UniformSet* vl::Shader::getUniformSet ( ) const [inline]

Returns the UniformSet installed.

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

void vl::Shader::setEnableSet ( EnableSet * es ) [inline]

void vl::Shader::setRenderStateSet ( RenderStateSet * rss ) [inline]

void vl::Shader::setUniformSet ( UniformSet * us ) [inline]

Installs a new UniformSet.

See also:
  • setUniform()
  • uniforms()
  • eraseUniform(const std::string& name)
  • eraseUniform(const Uniform* uniform)
  • eraseAllUniforms()
  • getUniform()

void vl::Shader::setScissor ( Scissor * scissor ) [inline]

Sets the Scissor to be used when rendering an Actor.

Note:
You can also define a Scissor on a per-Actor basis using the function Actor::setScissor(). In case both the Shader's and the Actor's Scissor are defined the Actor's Scissor is used.
See also:
  • Scissor
  • Actor::setScissor()

const Scissor* vl::Shader::scissor ( ) const [inline]

Returns the Scissor to be used when rendering an Actor.

See also:
  • Scissor
  • Shader::setScissor()
  • Actor::setScissor()

Scissor* vl::Shader::scissor ( ) [inline]

Returns the Scissor to be used when rendering an Actor.

See also:
  • Scissor
  • Shader::setScissor()
  • Actor::setScissor()

virtual void vl::Shader::update | ( | Camera * | ,
 |  | Real |  |
 | ) |  |  | [inline, virtual]

Virtual function used to update or animate a Shader during the rendering.

Parameters:
camera | the camera used for the current rendering.
cur_t | the current animation time.

void vl::Shader::setLastUpdateTime ( Real time ) [inline]

Used internally.

Real vl::Shader::lastUpdateTime ( ) const [inline]

Used internally.

void vl::Shader::initResources ( ) [inline]

Member Data Documentation

Real vl::Shader::mLastUpdateTime [protected]

ref<RenderStateSet> vl::Shader::mRenderStateSet [protected]

ref<EnableSet> vl::Shader::mEnableSet [protected]

ref<UniformSet> vl::Shader::mUniformSet [protected]

ref<Scissor> vl::Shader::mScissor [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::ShaderNode Class Reference

vl::ShaderNode

vl::ShaderNode Class Reference

The ShaderNode class is used to conveniently manage complex hierarchies of Shader[s]. More...

#include <ShaderNode.hpp>

Inheritance diagram for vl::ShaderNode:

vl::Object

List of all members.

Classes

class | EnableInfo
class | RenderStateInfo
class | UniformInfo

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ShaderNode ()
void | addChild (ShaderNode *node)
void | eraseChild (ShaderNode *node)
void | eraseChild (unsigned index)
void | eraseChildren (unsigned start, unsigned count)
int | findChild (const ShaderNode *node) const
unsigned | childrenCount () const
ShaderNode * | child (unsigned i)
const ShaderNode * | child (unsigned i) const
ShaderNode * parent ()
const ShaderNode * | parent () const
void | inherit (ShaderNode *parent)
void | setRenderState (RenderState *rs, EInheritance inheritance=IN_Propagate)
void | eraseRenderState (RenderState *rs)
void | setEnable (EEnable en, bool on, EInheritance inheritance=IN_Propagate)
void | eraseEnable (EEnable en)
void | setUniform (Uniform *unif, EInheritance inheritance=IN_Propagate)
void | eraseUniform (Uniform *unif)
void | setShader (Shader *shader)
const Shader * | shader () const
Shader * shader ()
void | updateHierachy ()

Protected Attributes

std::vector< ref< ShaderNode > > | mNodes
ShaderNode * mParent
std::map< ERenderState,
RenderStateInfo > 		mRenderStates
std::map< EEnable, EnableInfo > | mEnables
std::map< std::string,
UniformInfo > 		mUniforms
std::map< ERenderState,
RenderStateInfo > 		mRenderStates_Final
std::map< EEnable, EnableInfo > | mEnables_Final
std::map< std::string,
UniformInfo > 		mUniforms_Final
ref< Shader > mShader

Detailed Description

The ShaderNode class is used to conveniently manage complex hierarchies of Shader[s].

Constructor & Destructor Documentation

vl::ShaderNode::ShaderNode ( ) [inline]

Member Function Documentation

virtual const char* vl::ShaderNode::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::ShaderNode::addChild ( ShaderNode * node ) [inline]

void vl::ShaderNode::eraseChild ( ShaderNode * node ) [inline]

void vl::ShaderNode::eraseChild ( unsigned index ) [inline]

void vl::ShaderNode::eraseChildren | ( | unsigned | start,
 |  | unsigned | count |
 | ) |  |  | [inline]

int vl::ShaderNode::findChild ( const ShaderNode * node ) const [inline]

unsigned vl::ShaderNode::childrenCount ( ) const [inline]

ShaderNode* vl::ShaderNode::child ( unsigned i ) [inline]

const ShaderNode* vl::ShaderNode::child ( unsigned i ) const [inline]

ShaderNode* vl::ShaderNode::parent ( ) [inline]

const ShaderNode* vl::ShaderNode::parent ( ) const [inline]

void vl::ShaderNode::inherit ( ShaderNode * parent ) [inline]

void vl::ShaderNode::setRenderState | ( | RenderState * | rs,
 |  | EInheritance | inheritance = IN_Propagate |
 | ) |  |  | [inline]

void vl::ShaderNode::eraseRenderState ( RenderState * rs ) [inline]

void vl::ShaderNode::setEnable | ( | EEnable | en,
 |  | bool | on,
 |  | EInheritance | inheritance = IN_Propagate |
 | ) |  |  | [inline]

void vl::ShaderNode::eraseEnable ( EEnable en ) [inline]

void vl::ShaderNode::setUniform | ( | Uniform * | unif,
 |  | EInheritance | inheritance = IN_Propagate |
 | ) |  |  | [inline]

void vl::ShaderNode::eraseUniform ( Uniform * unif ) [inline]

void vl::ShaderNode::setShader ( Shader * shader ) [inline]

const Shader* vl::ShaderNode::shader ( ) const [inline]

Shader* vl::ShaderNode::shader ( ) [inline]

void vl::ShaderNode::updateHierachy ( ) [inline]

Member Data Documentation

std::vector< ref< ShaderNode > > vl::ShaderNode::mNodes [protected]

ShaderNode* vl::ShaderNode::mParent [protected]

std::map< ERenderState, RenderStateInfo > vl::ShaderNode::mRenderStates [protected]

std::map< EEnable, EnableInfo> vl::ShaderNode::mEnables [protected]

std::map< std::string, UniformInfo > vl::ShaderNode::mUniforms [protected]

std::map< ERenderState, RenderStateInfo > vl::ShaderNode::mRenderStates_Final [protected]

std::map< EEnable, EnableInfo> vl::ShaderNode::mEnables_Final [protected]

std::map< std::string, UniformInfo > vl::ShaderNode::mUniforms_Final [protected]

ref<Shader> vl::ShaderNode::mShader [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ShaderNode.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: vl::ShaderSequence Class Reference

vl::ShaderSequence

vl::ShaderSequence Class Reference

A sequence of Shader objects each of which represent a rendering pass. More...

#include <Effect.hpp>

Inheritance diagram for vl::ShaderSequence:

vl::Collection< Shader > vl::Object

List of all members.

Public Member Functions

virtual const char * className ()
Returns the name of the class.
ShaderSequence (Shader *pass1=NULL, Shader *pass2=NULL, Shader *pass3=NULL, Shader *pass4=NULL)
Constructor.

Detailed Description

A sequence of Shader objects each of which represent a rendering pass.

Each LOD (level of detail) in an Effect corresponts a ShaderSequence.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::ShaderSequence::ShaderSequence | ( | Shader * | pass1 = NULL,
 |  | Shader * | pass2 = NULL,
 |  | Shader * | pass3 = NULL,
 |  | Shader * | pass4 = NULL |
 | ) |  |  | [inline]

Constructor.

Parameters:
pass1 | The Shader (if any) to be used for pass #1
pass2 | The Shader (if any) to be used for pass #2
pass3 | The Shader (if any) to be used for pass #3
pass4 | The Shader (if any) to be used for pass #4

Member Function Documentation

virtual const char* vl::ShaderSequence::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Collection< Shader >.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: vl::Sphere Class Reference

vl::Sphere

vl::Sphere Class Reference

The Sphere class defines a sphere using a center and a radius using vl::Real precision. More...

#include <Sphere.hpp>

List of all members.

Public Member Functions

Sphere ()
Sphere (const AABB &aabb)
void | setNull ()
void | setPoint ()
bool | isNull () const
bool | isPoint () const
void | setCenter (const vec3 &center)
const vec3 & | center () const
void | setRadius (Real radius)
Real | radius () const
bool | includes (const Sphere &other) const
Sphere & | operator= (const AABB &aabb)
Sphere | operator+ (const Sphere &other)
const Sphere & | operator+= (const Sphere &other)
void | transformed (Sphere &sphere, const mat4 &mat) const
Sphere | transformed (const mat4 &mat) const

Protected Attributes

vec3 mCenter
Real mRadius

Detailed Description

The Sphere class defines a sphere using a center and a radius using vl::Real precision.

Constructor & Destructor Documentation

vl::Sphere::Sphere ( ) [inline]

vl::Sphere::Sphere ( const AABB & aabb ) [inline]

Member Function Documentation

void vl::Sphere::setNull ( ) [inline]

void vl::Sphere::setPoint ( ) [inline]

bool vl::Sphere::isNull ( ) const [inline]

bool vl::Sphere::isPoint ( ) const [inline]

void vl::Sphere::setCenter ( const vec3 & center ) [inline]

const vec3& vl::Sphere::center ( ) const [inline]

void vl::Sphere::setRadius ( Real radius ) [inline]

Real vl::Sphere::radius ( ) const [inline]

bool vl::Sphere::includes ( const Sphere & other ) const [inline]

Sphere& vl::Sphere::operator= ( const AABB & aabb ) [inline]

Sphere vl::Sphere::operator+ ( const Sphere & other ) [inline]

const Sphere& vl::Sphere::operator+= ( const Sphere & other ) [inline]

void vl::Sphere::transformed | ( | Sphere & | sphere,
 |  | const mat4 & | mat |
 | ) |  |  | const [inline]

Sphere vl::Sphere::transformed ( const mat4 & mat ) const [inline]

Member Data Documentation

vec3 vl::Sphere::mCenter [protected]

Real vl::Sphere::mRadius [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Sphere.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: vl::StandardLog Class Reference

vl::StandardLog

vl::StandardLog Class Reference

The StandardLog class outputs the log messages on the stdout device and optionally also on a specified file. More...

#include <Log.hpp>

Inheritance diagram for vl::StandardLog:

vl::Log vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
void | setLogFile (const String &file)
const String & | logFile () const

Protected Member Functions

virtual void | printImplementation (ELogLevel level, const String &log)

Protected Attributes

String mLogFile

Detailed Description

The StandardLog class outputs the log messages on the stdout device and optionally also on a specified file.

Member Function Documentation

virtual const char* vl::StandardLog::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Log.

void vl::StandardLog::setLogFile ( const String & file ) [inline]

const String& vl::StandardLog::logFile ( ) const [inline]

void StandardLog::printImplementation | ( | ELogLevel | level,
 |  | const String & | log |
 | ) |  |  | [protected, virtual]

Implements vl::Log.

Member Data Documentation

String vl::StandardLog::mLogFile [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: vl::StencilFunc Class Reference

vl::StencilFunc

vl::StencilFunc Class Reference

Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::StencilFunc:

vl::RenderState vl::Object

List of all members.

Public Member Functions

StencilFunc (EFunction function=FU_ALWAYS, int refvalue=0, unsigned int mask=~(unsigned int) 0)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EPolygonFace face, EFunction function, int refvalue, unsigned int mask)
EFunction | function_Front () const
int | refValue_Front () const
unsigned int | mask_Front () const
EFunction | function_Back () const
int | refValue_Back () const
unsigned int | mask_Back () const

Protected Attributes

EFunction mFunction_Front
EFunction mFunction_Back
int | mRefValue_Front
int | mRefValue_Back
unsigned int | mMask_Front
unsigned int | mMask_Back

Detailed Description

Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information.

See also:
Shader, Effect, Actor, StencilMask, StencilOp, vl::EN_STENCIL_TEST

Constructor & Destructor Documentation

vl::StencilFunc::StencilFunc | ( | EFunction | function = FU_ALWAYS,
 |  | int | refvalue = 0,
 |  | unsigned int | mask = ~(unsigned int)0 |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::StencilFunc::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::StencilFunc::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void StencilFunc::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::StencilFunc::set | ( | EPolygonFace | face,
 |  | EFunction | function,
 |  | int | refvalue,
 |  | unsigned int | mask |
 | ) |  |  | [inline]

EFunction vl::StencilFunc::function_Front ( ) const [inline]

int vl::StencilFunc::refValue_Front ( ) const [inline]

unsigned int vl::StencilFunc::mask_Front ( ) const [inline]

EFunction vl::StencilFunc::function_Back ( ) const [inline]

int vl::StencilFunc::refValue_Back ( ) const [inline]

unsigned int vl::StencilFunc::mask_Back ( ) const [inline]

Member Data Documentation

EFunction vl::StencilFunc::mFunction_Front [protected]

EFunction vl::StencilFunc::mFunction_Back [protected]

int vl::StencilFunc::mRefValue_Front [protected]

int vl::StencilFunc::mRefValue_Back [protected]

unsigned int vl::StencilFunc::mMask_Front [protected]

unsigned int vl::StencilFunc::mMask_Back [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::StencilMask Class Reference

vl::StencilMask

vl::StencilMask Class Reference

Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::StencilMask:

vl::RenderState vl::Object

List of all members.

Public Member Functions

StencilMask (unsigned int mask=~(unsigned int) 0)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EPolygonFace face, unsigned int mask)
unsigned int | mask_Front () const
unsigned int | mask_Back () const

Protected Attributes

unsigned int | mMask_Front
unsigned int | mMask_Back

Detailed Description

Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information.

See also:
Shader, Effect, Actor, StencilOp, StencilFunc, vl::EN_STENCIL_TEST

Constructor & Destructor Documentation

vl::StencilMask::StencilMask ( unsigned int mask = ~(unsigned int)0 ) [inline]

Member Function Documentation

virtual const char* vl::StencilMask::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::StencilMask::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void StencilMask::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::StencilMask::set | ( | EPolygonFace | face,
 |  | unsigned int | mask |
 | ) |  |  | [inline]

unsigned int vl::StencilMask::mask_Front ( ) const [inline]

unsigned int vl::StencilMask::mask_Back ( ) const [inline]

Member Data Documentation

unsigned int vl::StencilMask::mMask_Front [protected]

unsigned int vl::StencilMask::mMask_Back [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::StencilOp Class Reference

vl::StencilOp

vl::StencilOp Class Reference

Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::StencilOp:

vl::RenderState vl::Object

List of all members.

Public Member Functions

StencilOp (EStencilOp sfail=SO_KEEP, EStencilOp dpfail=SO_KEEP, EStencilOp dppass=SO_KEEP)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | set (EPolygonFace face, EStencilOp sfail, EStencilOp dpfail, EStencilOp dppass)
EStencilOp | sFail_Front () const
EStencilOp | dpFail_Front () const
EStencilOp | dpPass_Front () const
EStencilOp | sFail_Back () const
EStencilOp | dpFail_Back () const
EStencilOp | dpPass_Back () const

Protected Attributes

EStencilOp mSFail_Front
EStencilOp mSFail_Back
EStencilOp mDpFail_Front
EStencilOp mDpFail_Back
EStencilOp mDpPass_Front
EStencilOp mDpPass_Back

Detailed Description

Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information.

See also:
Shader, Effect, Actor, StencilMask, StencilFunc, vl::EN_STENCIL_TEST

Constructor & Destructor Documentation

vl::StencilOp::StencilOp | ( | EStencilOp | sfail = SO_KEEP,
 |  | EStencilOp | dpfail = SO_KEEP,
 |  | EStencilOp | dppass = SO_KEEP |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vl::StencilOp::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::StencilOp::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void StencilOp::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::StencilOp::set | ( | EPolygonFace | face,
 |  | EStencilOp | sfail,
 |  | EStencilOp | dpfail,
 |  | EStencilOp | dppass |
 | ) |  |  | [inline]

EStencilOp vl::StencilOp::sFail_Front ( ) const [inline]

EStencilOp vl::StencilOp::dpFail_Front ( ) const [inline]

EStencilOp vl::StencilOp::dpPass_Front ( ) const [inline]

EStencilOp vl::StencilOp::sFail_Back ( ) const [inline]

EStencilOp vl::StencilOp::dpFail_Back ( ) const [inline]

EStencilOp vl::StencilOp::dpPass_Back ( ) const [inline]

Member Data Documentation

EStencilOp vl::StencilOp::mSFail_Front [protected]

EStencilOp vl::StencilOp::mSFail_Back [protected]

EStencilOp vl::StencilOp::mDpFail_Front [protected]

EStencilOp vl::StencilOp::mDpFail_Back [protected]

EStencilOp vl::StencilOp::mDpPass_Front [protected]

EStencilOp vl::StencilOp::mDpPass_Back [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: vl::STLLoader Class Reference

vl::STLLoader

vl::STLLoader Class Reference

Loads an STL file. More...

#include <vlSTL.hpp>

List of all members.

Public Member Functions

virtual const char * | className ()
ref< ResourceDatabase > | loadSTL (VirtualFile *file)
Loads a STL file.
ref< ResourceDatabase > | loadAscii (VirtualFile *file)
ref< ResourceDatabase > | loadBinary (VirtualFile *file)

Detailed Description

Loads an STL file.

Member Function Documentation

virtual const char* vl::STLLoader::className ( ) [inline, virtual]

ref< ResourceDatabase > STLLoader::loadSTL ( VirtualFile * file )

Loads a STL file.

ref< ResourceDatabase > STLLoader::loadAscii ( VirtualFile * file )

ref< ResourceDatabase > STLLoader::loadBinary ( VirtualFile * file )

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: vl::String Class Reference

vl::String

vl::String Class Reference

The String class implements an advanced UTF16 (Unicode BMP) string manipulation engine. More...

#include <String.hpp>

List of all members.

Classes

class | StringData

Public Member Functions

String ()
Constructor.
String (const String &other)
Constructor.
String (const wchar_t *wstr)
Constructor.
String (const char *str)
Constructor.
String (wchar_t ch, int count=1)
Constructor.
const wchar_t * | ptr () const
Returns the 0-terminated utf16 string.
wchar_t * | ptr ()
Returns the 0-terminated utf16 string.
int | length () const
Returns the length of the string.
bool | empty () const
Returns true if length() == 0.
bool | null () const
Returns true if the String has never been assigned or resized.
String & clear ()
Clears the string.
const wchar_t & | operator[] (int i) const
Returns the character at position i.
wchar_t & | operator[] (int i)
Returns the character at position i.
String & | replace (wchar_t old_ch, wchar_t new_ch)
Replaces the character 'old_ch' with 'new_ch'.
String & | replace (int start, int count, wchar_t ch)
Replaces count characters starting at position start with ch.
String & | replace (int start, int count, const String &str)
Equivalent to remove(start, count); insert(start, str);.
String & | replace (const String &oldstr, const String &newstr, bool case_sensitive=true)
Replaces all the occurrences of oldstr with newstr.
String & | remove (wchar_t ch, int start=0, int count=-1)
Removes 'count' occurrences of the character 'ch' after position 'start'.
String & | remove (const String &str, int start=0, int count=-1)
Removes 'count' occurrences of the string 'str' after position 'start'.
String & | remove (int start, int count)
Removes 'count' characters starting at position 'start'.
String & reverse ()
Reverses the order of the characters in the string.
String & normalizeSlashes ()
Transform \ slashes in / slashes and removes duplicates.
int | count (wchar_t ch, int start=0) const
Returns the number of occurrences of the given character after position 'start'.
int | count (const String &str, int start=0) const
Returns the number of occurrences of the given string after position 'start'.
int | compare (const String &other) const
Performs a lexicographic comparison.
bool | endsWith (const String &str) const
Returns true if a String ends with the specified String str.
bool | startsWith (const String &str) const
Returns true if a String starts with the specified String str.
bool | endsWith (wchar_t ch) const
Returns true if a String ends with the specified character.
bool | startsWith (wchar_t ch) const
Returns true if a String starts with the specified character.
String & | insert (int pos, const String &str)
Inserts str at position pos.
String & | insert (int pos, wchar_t ch, int count=1)
Inserts count characters ch starting at position pos.
String | left (int count) const
Returns the count leftmost caracters of a String. If count is negative the function returns all but the abs(count) rightmost caracters.
String | right (int count) const
Returns the count rightmost caracters of a String. If count is negative the function returns all but the abs(count) leftmost caracters.
String | extractPath () const
If the String contains a file path the function returns the path with trailing slash, without the file name.
String | extractFileName () const
If the String contains a file path the function returns the file name without the path.
String | extractFileExtension (bool require_dot=true) const
If the String contains a file name or file path the function returns the extension of the file.
String & | resize (int character_count)
Resizes the string to the specified character count.
String | substring (int start, int count=-1) const
Returns the count characters long substring starting a character index start. If count == -1 the returned substring will contain all the characters from start to the end of the String.
String & | fill (wchar_t ch)
Fills the string with the specified character ch.
String & | trim (wchar_t ch)
Removes the specified character ch from the beginning and the end of the String.
String & | trim (const String &chars)
Removes the characters contained in chars from the beginning and the end of the String.
String & trim ()
Equivalent to trim("\n\r\t\v "), that is, removes all the tabs, spaces and new-lines from the beginning and end of a String.
void | split (wchar_t separator, std::vector< String > &fields, bool remove_empty_fields=false) const
Splits a String into a set of fields. The fields are separated by the specified separator and are returned in fields.
void | split (const String &separator_list, std::vector< String > &fields, bool remove_empty_fields=false) const
Splits a String into a set of fields. The fields are separated by the specified separator_list and are returned in fields.
void | splitLines (std::vector< String > &lines) const
Splits a String into a set of Strings each of which contains a line.
String | field (wchar_t separator, int field_index) const
Splits a String into a set of fields based on the specified separator and returns the filed at position field_index.
String & | append (const String &other)
Appends the specified String to another String.
String & | append (wchar_t ch, int count=1)
Appends count characters ch to another String.
String & | prepend (const String &str)
Prepends the specified String to another String.
String & | prepend (wchar_t ch, int count)
Prepends count characters ch to another String.
int | find (wchar_t ch, int start=0) const
Searches for the specified character ch starting at position start and returns the index of the first occurence or -1 if no occurrence was found.
int | find (const String &str, int start=0) const
Searches for the specified String substr starting at position start and returns the index of the first occurence or -1 if no occurrence was found.
int | findBackwards (wchar_t ch) const
Searches for the specified character starting from the end of the string and returns the index of the first occurence or -1 if no occurrence was found.
int | findBackwards (const String &str) const
Searches for the specified String str from the end of the string and returns the index of the first occurence or -1 if no occurrence was found.
bool | contains (wchar_t ch) const
Returns true if a String contains the specified character.
bool | contains (const String &str) const
Returns true if a String contains the specified String.
void | squeeze ()
Minimizes the memory buffer used to store the String.
int | toInt (bool hex=false) const
Returns the int number represented by the string. The conversion is done using the standard atoi() function.
double | toDouble () const
Returns the double number represented by the string. The conversion is done using the standard atof() function.
float | toFloat () const
Returns the float number represented by the string. The conversion is done using the standard atof() function.
std::string | toStdString () const
Returns a UTF8 encoded std::string.
std::wstring | toStdWString () const
Returns the std::wstring representation of a String.
void | toAscii (std::string &ascii, bool translate_non_ascii_chars=true) const
Provides some basic character translation of code points outside of the ASCII range.
void | toUTF8 (std::vector< unsigned char > &utf8, bool include_utf8_signature=true) const
Encodes the String into a UTF8 encoded string.
void | toUTF8 (std::string &utf8, bool include_utf8_signature=true) const
Encodes the String into a UTF8 encoded std::string.
void | toUTF16BE (std::vector< unsigned char > &utf16, bool include_utf16be_signature=true) const
Encodes the String into a UTF16 big endian encoded string.
void | toUTF16LE (std::vector< unsigned char > &utf16, bool include_utf16le_signature=true) const
Encodes the String into a UTF16 little endian encoded string.
void | toLatin1 (std::vector< unsigned char > &latin1) const
Encodes the String into a Latin1 encoded string.
String | toLowerCase () const
Returns the lower-case version of a String.
String | toUpperCase () const
Returns the upper-case version of a String.
bool | operator< (const String &other) const
Lexicographic sorting, equivalent to "compare(other) < 0".
String & | operator= (const char *str)
Equivalent to '*this = fromUTF8(str);'.
String & | operator= (const std::string &str)
Equivalent to '*this = fromUTF8(str.c_str());'.
String & | operator= (const wchar_t *wstr)
String & | operator= (const std::wstring &str)
String & | operator= (const String &other)
bool | operator== (const String &other) const
bool | operator== (const std::string &other) const
bool | operator== (const std::wstring &other) const
bool | operator== (const char *other) const
bool | operator== (const wchar_t *other) const
bool | operator!= (const String &other) const
bool | operator!= (const std::string &other) const
bool | operator!= (const std::wstring &other) const
bool | operator!= (const char *other) const
bool | operator!= (const wchar_t *other) const
String & | operator+= (wchar_t ch)
String | operator+ (wchar_t ch) const
String & | operator+= (const String &other)
String | operator+ (const String &other) const
void | acquireData () const
Acquires a private copy of the data if the string has been copied from another one.

Static Public Member Functions

static EStringEncoding | detectEncoding (const void *str, int byte_count, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING)
Detects the encoding.
static String | loadText (const String &path, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING)
Loads a String from the specified path.
static String | loadText (const char *path, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING)
Loads a String from the specified path.
static String | loadText (VirtualFile *file, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING)
Loads a String from the specified VirtualFile.
static String | loadText (void *data, int bytes, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING)
Loads a String from the specified memory buffer.
static unsigned short | getUpperCase (unsigned short ch)
Returns the upper-case version of the specified character.
static unsigned short | getLowerCase (unsigned short ch)
Returns the lower-case version of the specified character.
static unsigned short | getTitleCase (unsigned short ch)
Returns the title-case version of the specified character.
static void | filterStrings (std::vector< String > &strings, const String &filter)
Filters the specified Strings using the given filter. The filter must be of the type "*abc", "abc*" and "*abc*".
static wchar_t | platformSlash ()
Returns '\' under windows and '/' under Linux and Mac.
static std::string | trimStdString (const std::string &text)
Remove the spaces before and after an std::string.
static String | fromInt (int value)
Creates a string representing the given integer value.
static String | fromUInt (unsigned int value)
Creates a string representing the given unsigned integer value.
static String | fromLongLong (long long value)
Creates a string representing the given long long value.
static String | fromULongLong (unsigned long long value)
Creates a string representing the given unsigned long long value.
static String | fromDouble (double value, int decimals=6)
Creates a string representing the given double value The value of 'decimals' can be between 0 and 20.
static String | fromStdString (const std::string &str)
Initializes the string from a std::string using the fromAscii() function.
static String | fromStdWString (const std::wstring &str)
Initializes the string from a std::string using the fromAscii() function.
static String | fromAscii (const char *str, int size=-1)
Initializes the string from a 7 bit ascii string.
static String | fromUTF16BE (const unsigned short *str, int byte_count=-1)
Accepts strings with and without UTF16 BE signature Supports natively the characters from the BMP, the other characters are substituted with '?' The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.
static String | fromUTF16LE (const unsigned short *str, int byte_count=-1)
Accepts strings with and without UTF16 LE signature Supports natively the characters from the BMP, the other characters are substituted with '?' The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.
static String | fromUTF16 (const unsigned short *str, int byte_count=-1)
str must have UTF16 LE or UTF16 BE signature The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.
static String | fromUTF8 (const char *str, int byte_count=-1)
Accepts strings with and without UTF8 signature.
static String | fromLatin1 (const char *str, int character_count=-1)
The size of the buffer pointed by 'str' must be at least 'character_count' bytes large or null terminated.

Protected Member Functions

void | createData () const

Detailed Description

The String class implements an advanced UTF16 (Unicode BMP) string manipulation engine.

The String class features:

  • Lazy data copy on write that speeds up String manipulation, copy and comparison.
  • Encoding and decoding functions for UTF8, UTF16 BE, UTF16 LE, Latin1 and Ascii, with and without signature.
  • Interoperability to and from std::string, std::wstring, char* and wchar_t*.
  • Unicode to Ascii character translation when possible.
  • Extended character case manipulation for most UTF16/BMP codes.
  • Advanced string manipulation routines like line/field splitting, comparison, search, replace, trimming, matching, counting, filling etc.
  • Fast substring find function based on the Quick Find algorithm.
  • Loads text from a variety of formats and sources.

Constructor & Destructor Documentation

String::String ( )

Constructor.

String::String ( const String & other )

Constructor.

String::String ( const wchar_t * wstr )

Constructor.

String::String ( const char * str )

Constructor.

String::String | ( | wchar_t | ch,
 |  | int | count = 1 |
 | ) |  |  | [explicit]

Constructor.

Member Function Documentation

EStringEncoding String::detectEncoding | ( | const void * | str,
 |  | int | byte_count,
 |  | EStringEncoding | encoding = VL_PLATFORM_DEFAULT_ENCODING |
 | ) |  |  | [static]

Detects the encoding.

String String::loadText | ( | const String & | path,
 |  | EStringEncoding | encoding = VL_PLATFORM_DEFAULT_ENCODING |
 | ) |  |  | [static]

Loads a String from the specified path.

static String vl::String::loadText | ( | const char * | path,
 |  | EStringEncoding | encoding = VL_PLATFORM_DEFAULT_ENCODING |
 | ) |  |  | [inline, static]

Loads a String from the specified path.

String String::loadText | ( | VirtualFile * | file,
 |  | EStringEncoding | encoding = VL_PLATFORM_DEFAULT_ENCODING |
 | ) |  |  | [static]

Loads a String from the specified VirtualFile.

String String::loadText | ( | void * | data,
 |  | int | bytes,
 |  | EStringEncoding | encoding = VL_PLATFORM_DEFAULT_ENCODING |
 | ) |  |  | [static]

Loads a String from the specified memory buffer.

unsigned short String::getUpperCase ( unsigned short ch ) [static]

Returns the upper-case version of the specified character.

unsigned short String::getLowerCase ( unsigned short ch ) [static]

Returns the lower-case version of the specified character.

unsigned short String::getTitleCase ( unsigned short ch ) [static]

Returns the title-case version of the specified character.

void String::filterStrings | ( | std::vector< String > & | strings,
 |  | const String & | filter |
 | ) |  |  | [static]

Filters the specified Strings using the given filter. The filter must be of the type "*abc", "abc*" and "*abc*".

static wchar_t vl::String::platformSlash ( ) [inline, static]

Returns '\' under windows and '/' under Linux and Mac.

std::string String::trimStdString ( const std::string & text ) [static]

Remove the spaces before and after an std::string.

const wchar_t* vl::String::ptr ( ) const [inline]

Returns the 0-terminated utf16 string.

wchar_t* vl::String::ptr ( ) [inline]

Returns the 0-terminated utf16 string.

int vl::String::length ( ) const [inline]

Returns the length of the string.

bool vl::String::empty ( ) const [inline]

Returns true if length() == 0.

bool vl::String::null ( ) const [inline]

Returns true if the String has never been assigned or resized.

String& vl::String::clear ( ) [inline]

Clears the string.

const wchar_t& vl::String::operator[] ( int i ) const [inline]

Returns the character at position i.

wchar_t& vl::String::operator[] ( int i ) [inline]

Returns the character at position i.

String & String::replace | ( | wchar_t | old_ch,
 |  | wchar_t | new_ch
 | ) |  |

Replaces the character 'old_ch' with 'new_ch'.

String & String::replace | ( | int | start,
 |  | int | count,
 |  | wchar_t | ch
 | ) |  |

Replaces count characters starting at position start with ch.

String & String::replace | ( | int | start,
 |  | int | count,
 |  | const String & | str
 | ) |  |

Equivalent to remove(start, count); insert(start, str);.

String & String::replace | ( | const String & | oldstr,
 |  | const String & | newstr,
 |  | bool | case_sensitive = true
 | ) |  |

Replaces all the occurrences of oldstr with newstr.

String & String::remove | ( | wchar_t | ch,
 |  | int | start = 0,
 |  | int | count = -1
 | ) |  |

Removes 'count' occurrences of the character 'ch' after position 'start'.

If 'count' is set -1 there is no limit to the number of occurrences removed.

String & String::remove | ( | const String & | str,
 |  | int | start = 0,
 |  | int | count = -1
 | ) |  |

Removes 'count' occurrences of the string 'str' after position 'start'.

If 'count' is set -1 there is no limit to the number of occurrences removed.

String & String::remove | ( | int | start,
 |  | int | count
 | ) |  |

Removes 'count' characters starting at position 'start'.

String & String::reverse ( )

Reverses the order of the characters in the string.

String & String::normalizeSlashes ( )

Transform \ slashes in / slashes and removes duplicates.

int String::count | ( | wchar_t | ch,
 |  | int | start = 0 |
 | ) |  |  | const

Returns the number of occurrences of the given character after position 'start'.

int String::count | ( | const String & | str,
 |  | int | start = 0 |
 | ) |  |  | const

Returns the number of occurrences of the given string after position 'start'.

int String::compare ( const String & other ) const

Performs a lexicographic comparison.

Returns < 0 if this string comes before 'other'. Returns > 0 if 'other' comes before this string. Returns 0 if the two strings are equal.

bool String::endsWith ( const String & str ) const

Returns true if a String ends with the specified String str.

bool String::startsWith ( const String & str ) const

Returns true if a String starts with the specified String str.

bool String::endsWith ( wchar_t ch ) const

Returns true if a String ends with the specified character.

bool String::startsWith ( wchar_t ch ) const

Returns true if a String starts with the specified character.

String & String::insert | ( | int | pos,
 |  | const String & | str
 | ) |  |

Inserts str at position pos.

String & String::insert | ( | int | pos,
 |  | wchar_t | ch,
 |  | int | count = 1
 | ) |  |

Inserts count characters ch starting at position pos.

String String::left ( int count ) const

Returns the count leftmost caracters of a String. If count is negative the function returns all but the abs(count) rightmost caracters.

String String::right ( int count ) const

Returns the count rightmost caracters of a String. If count is negative the function returns all but the abs(count) leftmost caracters.

String String::extractPath ( ) const

If the String contains a file path the function returns the path with trailing slash, without the file name.

String String::extractFileName ( ) const

If the String contains a file path the function returns the file name without the path.

String String::extractFileExtension ( bool require_dot = true ) const

If the String contains a file name or file path the function returns the extension of the file.

String & String::resize ( int character_count )

Resizes the string to the specified character count.

String String::substring | ( | int | start,
 |  | int | count = -1 |
 | ) |  |  | const

Returns the count characters long substring starting a character index start. If count == -1 the returned substring will contain all the characters from start to the end of the String.

String & String::fill ( wchar_t ch )

Fills the string with the specified character ch.

String & String::trim ( wchar_t ch )

Removes the specified character ch from the beginning and the end of the String.

String & String::trim ( const String & chars )

Removes the characters contained in chars from the beginning and the end of the String.

String & String::trim ( )

Equivalent to trim("\n\r\t\v "), that is, removes all the tabs, spaces and new-lines from the beginning and end of a String.

void String::split | ( | wchar_t | separator,
 |  | std::vector< String > & | fields,
 |  | bool | remove_empty_fields = false |
 | ) |  |  | const

Splits a String into a set of fields. The fields are separated by the specified separator and are returned in fields.

void String::split | ( | const String & | separator_list,
 |  | std::vector< String > & | fields,
 |  | bool | remove_empty_fields = false |
 | ) |  |  | const

Splits a String into a set of fields. The fields are separated by the specified separator_list and are returned in fields.

void String::splitLines ( std::vector< String > & lines ) const

Splits a String into a set of Strings each of which contains a line.

String String::field | ( | wchar_t | separator,
 |  | int | field_index |
 | ) |  |  | const

Splits a String into a set of fields based on the specified separator and returns the filed at position field_index.

String & String::append ( const String & other )

Appends the specified String to another String.

String & String::append | ( | wchar_t | ch,
 |  | int | count = 1
 | ) |  |

Appends count characters ch to another String.

String & String::prepend ( const String & str )

Prepends the specified String to another String.

String & String::prepend | ( | wchar_t | ch,
 |  | int | count
 | ) |  |

Prepends count characters ch to another String.

int String::find | ( | wchar_t | ch,
 |  | int | start = 0 |
 | ) |  |  | const

Searches for the specified character ch starting at position start and returns the index of the first occurence or -1 if no occurrence was found.

int String::find | ( | const String & | str,
 |  | int | start = 0 |
 | ) |  |  | const

Searches for the specified String substr starting at position start and returns the index of the first occurence or -1 if no occurrence was found.

int String::findBackwards ( wchar_t ch ) const

Searches for the specified character starting from the end of the string and returns the index of the first occurence or -1 if no occurrence was found.

int String::findBackwards ( const String & str ) const

Searches for the specified String str from the end of the string and returns the index of the first occurence or -1 if no occurrence was found.

bool String::contains ( wchar_t ch ) const

Returns true if a String contains the specified character.

bool String::contains ( const String & str ) const

Returns true if a String contains the specified String.

void String::squeeze ( )

Minimizes the memory buffer used to store the String.

String String::fromInt ( int value ) [static]

Creates a string representing the given integer value.

String String::fromUInt ( unsigned int value ) [static]

Creates a string representing the given unsigned integer value.

String String::fromLongLong ( long long value ) [static]

Creates a string representing the given long long value.

String String::fromULongLong ( unsigned long long value ) [static]

Creates a string representing the given unsigned long long value.

String String::fromDouble | ( | double | value,
 |  | int | decimals = 6 |
 | ) |  |  | [static]

Creates a string representing the given double value The value of 'decimals' can be between 0 and 20.

String String::fromStdString ( const std::string & str ) [static]

Initializes the string from a std::string using the fromAscii() function.

String String::fromStdWString ( const std::wstring & str ) [static]

Initializes the string from a std::string using the fromAscii() function.

String String::fromAscii | ( | const char * | str,
 |  | int | size = -1 |
 | ) |  |  | [static]

Initializes the string from a 7 bit ascii string.

String String::fromUTF16BE | ( | const unsigned short * | str,
 |  | int | byte_count = -1 |
 | ) |  |  | [static]

Accepts strings with and without UTF16 BE signature Supports natively the characters from the BMP, the other characters are substituted with '?' The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.

String String::fromUTF16LE | ( | const unsigned short * | str,
 |  | int | byte_count = -1 |
 | ) |  |  | [static]

Accepts strings with and without UTF16 LE signature Supports natively the characters from the BMP, the other characters are substituted with '?' The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.

String String::fromUTF16 | ( | const unsigned short * | str,
 |  | int | byte_count = -1 |
 | ) |  |  | [static]

str must have UTF16 LE or UTF16 BE signature The size of the buffer pointed by 'str' must be at least 'byte_count' bytes large or null terminated.

String String::fromUTF8 | ( | const char * | str,
 |  | int | byte_count = -1 |
 | ) |  |  | [static]

Accepts strings with and without UTF8 signature.

String String::fromLatin1 | ( | const char * | str,
 |  | int | character_count = -1 |
 | ) |  |  | [static]

The size of the buffer pointed by 'str' must be at least 'character_count' bytes large or null terminated.

int String::toInt ( bool hex = false ) const

Returns the int number represented by the string. The conversion is done using the standard atoi() function.

double String::toDouble ( ) const

Returns the double number represented by the string. The conversion is done using the standard atof() function.

float vl::String::toFloat ( ) const [inline]

Returns the float number represented by the string. The conversion is done using the standard atof() function.

std::string String::toStdString ( ) const

Returns a UTF8 encoded std::string.

std::wstring String::toStdWString ( ) const

Returns the std::wstring representation of a String.

void String::toAscii | ( | std::string & | ascii,
 |  | bool | translate_non_ascii_chars = true |
 | ) |  |  | const

Provides some basic character translation of code points outside of the ASCII range.

void String::toUTF8 | ( | std::vector< unsigned char > & | utf8,
 |  | bool | include_utf8_signature = true |
 | ) |  |  | const

Encodes the String into a UTF8 encoded string.

void String::toUTF8 | ( | std::string & | utf8,
 |  | bool | include_utf8_signature = true |
 | ) |  |  | const

Encodes the String into a UTF8 encoded std::string.

void String::toUTF16BE | ( | std::vector< unsigned char > & | utf16,
 |  | bool | include_utf16be_signature = true |
 | ) |  |  | const

Encodes the String into a UTF16 big endian encoded string.

void String::toUTF16LE | ( | std::vector< unsigned char > & | utf16,
 |  | bool | include_utf16le_signature = true |
 | ) |  |  | const

Encodes the String into a UTF16 little endian encoded string.

void String::toLatin1 ( std::vector< unsigned char > & latin1 ) const

Encodes the String into a Latin1 encoded string.

String String::toLowerCase ( ) const

Returns the lower-case version of a String.

String String::toUpperCase ( ) const

Returns the upper-case version of a String.

bool vl::String::operator< ( const String & other ) const [inline]

Lexicographic sorting, equivalent to "compare(other) < 0".

String& vl::String::operator= ( const char * str ) [inline]

Equivalent to '*this = fromUTF8(str);'.

String& vl::String::operator= ( const std::string & str ) [inline]

Equivalent to '*this = fromUTF8(str.c_str());'.

String& vl::String::operator= ( const wchar_t * wstr ) [inline]

String& vl::String::operator= ( const std::wstring & str ) [inline]

String& vl::String::operator= ( const String & other ) [inline]

bool vl::String::operator== ( const String & other ) const [inline]

bool vl::String::operator== ( const std::string & other ) const [inline]

bool vl::String::operator== ( const std::wstring & other ) const [inline]

bool vl::String::operator== ( const char * other ) const [inline]

bool vl::String::operator== ( const wchar_t * other ) const [inline]

bool vl::String::operator!= ( const String & other ) const [inline]

bool vl::String::operator!= ( const std::string & other ) const [inline]

bool vl::String::operator!= ( const std::wstring & other ) const [inline]

bool vl::String::operator!= ( const char * other ) const [inline]

bool vl::String::operator!= ( const wchar_t * other ) const [inline]

String& vl::String::operator+= ( wchar_t ch ) [inline]

String vl::String::operator+ ( wchar_t ch ) const [inline]

String& vl::String::operator+= ( const String & other ) [inline]

String vl::String::operator+ ( const String & other ) const [inline]

void vl::String::acquireData ( ) const [inline]

Acquires a private copy of the data if the string has been copied from another one.

void vl::String::createData ( ) const [inline, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: vl::Terrain Class Reference

vl::Terrain

vl::Terrain Class Reference

The Terrain class implements a ActorKdTree-based terrain scene manager. More...

#include <Terrain.hpp>

Inheritance diagram for vl::Terrain:

vl::SceneManagerActorKdTree vl::SceneManagerBVH< ActorKdTree > vl::SceneManager vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Terrain ()
void | init ()
bool | useGLSL () const
int | detailRepetitionMode () const
double | width () const
double | depth () const
double | height () const
const vec3 & | origin () const
const String & | detailTexture () const
const String & | terrainTexture () const
const String & | heightmapTexture () const
ETextureFormat | heightmapTextureFormat () const
ETextureFormat | terrainTextureFormat () const
ETextureFormat | detailTextureFormat () const
void | setUseGLSL (bool enable)
void | setDetailRepetitionCount (int count)
void | setWidth (double w)
void | setDepth (double d)
void | setHeight (double h)
void | setOrigin (const vec3 &origin)
void | setHeightmapTextureFormat (ETextureFormat format)
void | setTerrainTextureFormat (ETextureFormat format)
void | setDetailTextureFormat (ETextureFormat format)
void | setVertexShader (const String &vs_path)
const String & | vertexShader () const
void | setFragmentShader (const String &fs_path)
const String & | fragmentShader () const
const ActorCollection & | chunks () const
int | chunkCount () const
Actor * | chunk (int i)
const Actor * | chunk (int i) const
void | setDetailTexture (const String &texture)
Sets the texture to be used as detail texture, it can be of any size.
void | setTerrainTexture (const String &texture)
Sets the texture to be used as the base terrain texture.
void | setHeightmapTexture (const String &texture)
Sets the texture to be used as the heightmap.
const ShaderNode * | shaderNode () const
ShaderNode * shaderNode ()

Protected Attributes

ref< ShaderNode > mShaderNode
ActorCollection mChunks
double | mWidth
double | mHeight
double | mDepth
vec3 mOrigin
String mDetailTexture
String mTerrainTexture
String mHeightmapTexture
String mVertexShader
String mFragmentShader
int | mDetailRepetitionCount
ETextureFormat mHeightmapTextureFormat
ETextureFormat mTerrainTextureFormat
ETextureFormat mDetailTextureFormat
bool | mUseGLSL

Detailed Description

The Terrain class implements a ActorKdTree-based terrain scene manager.

Some applications do not need complex LOD or CLOD management algorithms to display height fields or terrains, either because the data displayed has a limited size or because particular constraints are applied to the camera (like in RTS games for example) for which only a limited portion of the terrain is visible at a given time.

This applications can greatly benefit from the vl::Terrain scene manager which implements a fool-proof, high-precision (8, 16 and 32 bits heightmaps are supported) and efficient terrain/heightfield generation and management system. All the user has to provide is a texture for the terrain, a heightfield image and a detail texture following very simple and precise guidelines.

The vl::Terrain class takes care of all the rest, like dividing the provided images into chunks, generating the geometry, generating the kd-tree, computing the appropriate texture coordinates in order to prevent seams and so on.

If the OpenGL Shading Language is available, the vl::Terrain class can also store the heightmap directly on the GPU and can generate the geometry on the fly using a technique called "vertex texture fetch" (http://developer.nvidia.com/object/using_vertex_textures.html). This technique allows the application to save GPU memory and to manage even greater terrain databases at a higher speed.

See also:
setTerrainTexture(), setHeightmapTexture(), setDetailTexture()

Constructor & Destructor Documentation

vl::Terrain::Terrain ( ) [inline]

Member Function Documentation

virtual const char* vl::Terrain::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::SceneManagerActorKdTree.

void Terrain::init ( )

bool vl::Terrain::useGLSL ( ) const [inline]

int vl::Terrain::detailRepetitionMode ( ) const [inline]

double vl::Terrain::width ( ) const [inline]

double vl::Terrain::depth ( ) const [inline]

double vl::Terrain::height ( ) const [inline]

const vec3& vl::Terrain::origin ( ) const [inline]

const String& vl::Terrain::detailTexture ( ) const [inline]

const String& vl::Terrain::terrainTexture ( ) const [inline]

const String& vl::Terrain::heightmapTexture ( ) const [inline]

ETextureFormat vl::Terrain::heightmapTextureFormat ( ) const [inline]

ETextureFormat vl::Terrain::terrainTextureFormat ( ) const [inline]

ETextureFormat vl::Terrain::detailTextureFormat ( ) const [inline]

void vl::Terrain::setUseGLSL ( bool enable ) [inline]

void vl::Terrain::setDetailRepetitionCount ( int count ) [inline]

void vl::Terrain::setWidth ( double w ) [inline]

void vl::Terrain::setDepth ( double d ) [inline]

void vl::Terrain::setHeight ( double h ) [inline]

void vl::Terrain::setOrigin ( const vec3 & origin ) [inline]

void vl::Terrain::setHeightmapTextureFormat ( ETextureFormat format ) [inline]

void vl::Terrain::setTerrainTextureFormat ( ETextureFormat format ) [inline]

void vl::Terrain::setDetailTextureFormat ( ETextureFormat format ) [inline]

void vl::Terrain::setVertexShader ( const String & vs_path ) [inline]

const String& vl::Terrain::vertexShader ( ) const [inline]

void vl::Terrain::setFragmentShader ( const String & fs_path ) [inline]

const String& vl::Terrain::fragmentShader ( ) const [inline]

const ActorCollection& vl::Terrain::chunks ( ) const [inline]

int vl::Terrain::chunkCount ( ) const [inline]

Actor* vl::Terrain::chunk ( int i ) [inline]

const Actor* vl::Terrain::chunk ( int i ) const [inline]

void vl::Terrain::setDetailTexture ( const String & texture ) [inline]

Sets the texture to be used as detail texture, it can be of any size.

void vl::Terrain::setTerrainTexture ( const String & texture ) [inline]

Sets the texture to be used as the base terrain texture.

Its size must be of the form: n * d - n + 1 where:

  • 'n' is any positive integer. 'n' is the value passed to setChunkSubdivision().
  • 'd' is a power of 2 and defines the dimension of the texture applied to each terrain chunk. For example: for a terrain with 8x8 chunks each of which with a 256x256 texture we have: 8*256-8+1 = 2041 = x and y size of the texture image.

void vl::Terrain::setHeightmapTexture ( const String & texture ) [inline]

Sets the texture to be used as the heightmap.

Its size must be of the form: n * d - n + 1 where:

  • 'n' is any positive integer. 'n' is the value passed to setChunkSubdivision().
  • 'd' is a power of 2 and defines the dimension of the heightmap portion used to build each terrain chunk. For example: for a terrain with 8x8 chunks each of which with a 256x256 heightmap we have: 8*256-8+1 = 2041 = x and y size of the heightmap image.

const ShaderNode* vl::Terrain::shaderNode ( ) const [inline]

ShaderNode* vl::Terrain::shaderNode ( ) [inline]

Member Data Documentation

ref<ShaderNode> vl::Terrain::mShaderNode [protected]

ActorCollection vl::Terrain::mChunks [protected]

double vl::Terrain::mWidth [protected]

double vl::Terrain::mHeight [protected]

double vl::Terrain::mDepth [protected]

vec3 vl::Terrain::mOrigin [protected]

String vl::Terrain::mDetailTexture [protected]

String vl::Terrain::mTerrainTexture [protected]

String vl::Terrain::mHeightmapTexture [protected]

String vl::Terrain::mVertexShader [protected]

String vl::Terrain::mFragmentShader [protected]

int vl::Terrain::mDetailRepetitionCount [protected]

ETextureFormat vl::Terrain::mHeightmapTextureFormat [protected]

ETextureFormat vl::Terrain::mTerrainTextureFormat [protected]

ETextureFormat vl::Terrain::mDetailTextureFormat [protected]

bool vl::Terrain::mUseGLSL [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: vl::Tessellator Class Reference

vl::Tessellator

vl::Tessellator Class Reference

Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library. More...

#include <Tessellator.hpp>

Inheritance diagram for vl::Tessellator:

vl::Object

List of all members.

Public Member Functions

Tessellator ()
Constructor.
~Tessellator ()
const std::vector< dvec3 > & | contourVerts () const
The contours that specify the complex polygon to be tessellated.
std::vector< dvec3 > & | contourVerts ()
The contours that specify the complex polygon to be tessellated.
const std::vector< int > & | contours () const
The contours that specify the complex polygon to be tessellated.
std::vector< int > & | contours ()
The contours that specify the complex polygon to be tessellated.
const std::vector< fvec3 > & | tessellatedTris () const
A set of triangles representing the tessellated polygon.
std::vector< fvec3 > & | tessellatedTris ()
A set of triangles representing the tessellated polygon.
void | setTessNormal (const fvec3 &normal)
See gluTessNormal documentation.
const fvec3 & | tessNormal () const
See gluTessNormal documentation.
void | setBoundaryOnly (bool on)
See gluTessProperty documentation (GLU_TESS_BOUNDARY_ONLY).
bool | boundaryOnly () const
See gluTessProperty documentation (GLU_TESS_BOUNDARY_ONLY).
double | tolerance () const
See gluTessProperty documentation (GLU_TESS_TOLERANCE).
void | setTolerance (double tolerance)
See gluTessProperty documentation (GLU_TESS_TOLERANCE).
ETessellationWinding | windingRule () const
See gluTessProperty documentation (GLU_TESS_WINDING_RULE).
void | setWindingRule (ETessellationWinding rule)
See gluTessProperty documentation (GLU_TESS_WINDING_RULE).
bool | tessellate (bool append_tessellated_tris=false)
ref< Geometry > | tessellateGeometry (bool append_tessellated_tris=false)
Utility function that calls tessellate() and creates a Geometry with the tessellated triangles.
bool | tessellateIntoSinglePolygon () const
void | setTessellateIntoSinglePolygon (bool on)

Protected Member Functions

void | freeCombinedVertices ()

Static Protected Member Functions

static void CALLBACK | tessBeginData (GLenum type, Tessellator *tessellator)
static void CALLBACK | tessVertexData (dvec3 *vec, Tessellator *tessellator)
static void CALLBACK | tessCombineData (GLdouble coords[3], dvec3 *d[4], GLfloat w[4], dvec3 **dataOut, Tessellator *tessellator)
static void CALLBACK | tessEnd (void)
static void CALLBACK | tessError (GLenum errno)

Protected Attributes

std::vector< int > | mContours
std::vector< dvec3 > | mContourVerts
std::vector< fvec3 > | mTessellatedTris
std::vector< std::vector< fvec3 > > | mFans
std::vector< std::vector< fvec3 > > | mTriStrips
std::vector< std::vector< fvec3 > > | mLineLoops
std::vector< dvec3 * > | mCombinedVertices
GLenum | mPrimitiveType
fvec3 mTessNormal
bool | mBoundaryOnly
double | mTolerance
ETessellationWinding mWindingRule
bool | mTessellateIntoSinglePolygon

Detailed Description

Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library.

For more information see the OpenGL Programmer's Guide chapter #11 "Tessellators and Quadrics".

Constructor & Destructor Documentation

Tessellator::Tessellator ( )

Constructor.

Tessellator::~Tessellator ( )

Member Function Documentation

const std::vector<dvec3>& vl::Tessellator::contourVerts ( ) const [inline]

The contours that specify the complex polygon to be tessellated.

std::vector<dvec3>& vl::Tessellator::contourVerts ( ) [inline]

The contours that specify the complex polygon to be tessellated.

const std::vector<int>& vl::Tessellator::contours ( ) const [inline]

The contours that specify the complex polygon to be tessellated.

std::vector<int>& vl::Tessellator::contours ( ) [inline]

The contours that specify the complex polygon to be tessellated.

const std::vector<fvec3>& vl::Tessellator::tessellatedTris ( ) const [inline]

A set of triangles representing the tessellated polygon.

std::vector<fvec3>& vl::Tessellator::tessellatedTris ( ) [inline]

A set of triangles representing the tessellated polygon.

void vl::Tessellator::setTessNormal ( const fvec3 & normal ) [inline]

See gluTessNormal documentation.

const fvec3& vl::Tessellator::tessNormal ( ) const [inline]

See gluTessNormal documentation.

void vl::Tessellator::setBoundaryOnly ( bool on ) [inline]

See gluTessProperty documentation (GLU_TESS_BOUNDARY_ONLY).

bool vl::Tessellator::boundaryOnly ( ) const [inline]

See gluTessProperty documentation (GLU_TESS_BOUNDARY_ONLY).

double vl::Tessellator::tolerance ( ) const [inline]

See gluTessProperty documentation (GLU_TESS_TOLERANCE).

void vl::Tessellator::setTolerance ( double tolerance ) [inline]

See gluTessProperty documentation (GLU_TESS_TOLERANCE).

ETessellationWinding vl::Tessellator::windingRule ( ) const [inline]

See gluTessProperty documentation (GLU_TESS_WINDING_RULE).

void vl::Tessellator::setWindingRule ( ETessellationWinding rule ) [inline]

See gluTessProperty documentation (GLU_TESS_WINDING_RULE).

bool Tessellator::tessellate ( bool append_tessellated_tris = false )

ref< Geometry > Tessellator::tessellateGeometry ( bool append_tessellated_tris = false )

Utility function that calls tessellate() and creates a Geometry with the tessellated triangles.

bool vl::Tessellator::tessellateIntoSinglePolygon ( ) const [inline]

void vl::Tessellator::setTessellateIntoSinglePolygon ( bool on ) [inline]

void CALLBACK Tessellator::tessBeginData | ( | GLenum | type,
 |  | Tessellator * | tessellator |
 | ) |  |  | [static, protected]

void CALLBACK Tessellator::tessVertexData | ( | dvec3 * | vec,
 |  | Tessellator * | tessellator |
 | ) |  |  | [static, protected]

void CALLBACK Tessellator::tessCombineData | ( | GLdouble | coords[3],
 |  | dvec3 * | d[4],
 |  | GLfloat | w[4],
 |  | dvec3 ** | dataOut,
 |  | Tessellator * | tessellator |
 | ) |  |  | [static, protected]

void CALLBACK Tessellator::tessEnd ( void ) [static, protected]

void CALLBACK Tessellator::tessError ( GLenum errno ) [static, protected]

void Tessellator::freeCombinedVertices ( ) [protected]

Member Data Documentation

std::vector<int> vl::Tessellator::mContours [protected]

std::vector<dvec3> vl::Tessellator::mContourVerts [protected]

std::vector<fvec3> vl::Tessellator::mTessellatedTris [protected]

std::vector< std::vector<fvec3> > vl::Tessellator::mFans [protected]

std::vector< std::vector<fvec3> > vl::Tessellator::mTriStrips [protected]

std::vector< std::vector<fvec3> > vl::Tessellator::mLineLoops [protected]

std::vector< dvec3* > vl::Tessellator::mCombinedVertices [protected]

GLenum vl::Tessellator::mPrimitiveType [protected]

fvec3 vl::Tessellator::mTessNormal [protected]

bool vl::Tessellator::mBoundaryOnly [protected]

double vl::Tessellator::mTolerance [protected]

ETessellationWinding vl::Tessellator::mWindingRule [protected]

bool vl::Tessellator::mTessellateIntoSinglePolygon [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: vl::TexEnv Class Reference

vl::TexEnv

vl::TexEnv Class Reference

Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::TexEnv:

vl::RenderState vl::Object

List of all members.

Public Member Functions

TexEnv (int texunit)
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | setMode (ETexEnvMode mode)
ETexEnvMode | mode () const
void | setCombineRGB (ETexEnvMode combineRGB)
ETexEnvMode | combineRGB () const
void | setCombineAlpha (ETexEnvMode combineAlpha)
ETexEnvMode | combineAlpha () const
void | setColor (fvec4 color)
fvec4 | color () const
void | setRGBScale (float rgbscale)
float | rgbScale () const
void | setAlphaScale (float alphascale)
float | alphaScale () const
void | setSource0RGB (ETexEnvSource source)
void | setSource1RGB (ETexEnvSource source)
void | setSource2RGB (ETexEnvSource source)
ETexEnvSource | source0RGB () const
ETexEnvSource | source1RGB () const
ETexEnvSource | source2RGB () const
void | setSource0Alpha (ETexEnvSource source)
void | setSource1Alpha (ETexEnvSource source)
void | setSource2Alpha (ETexEnvSource source)
ETexEnvSource | source0Alpha () const
ETexEnvSource | source1Alpha () const
ETexEnvSource | source2Alpha () const
void | setOperand0RGB (ETexEnvOperand operand)
void | setOperand1RGB (ETexEnvOperand operand)
void | setOperand2RGB (ETexEnvOperand operand)
ETexEnvOperand | operand0RGB () const
ETexEnvOperand | operand1RGB () const
ETexEnvOperand | operand2RGB () const
void | setOperand0Alpha (ETexEnvOperand operand)
void | setOperand1Alpha (ETexEnvOperand operand)
void | setOperand2Alpha (ETexEnvOperand operand)
ETexEnvOperand | operand0Alpha () const
ETexEnvOperand | operand1Alpha () const
ETexEnvOperand | operand2Alpha () const
void | setPointSpriteCoordReplace (bool replace)
bool | pointSpriteCoordReplace () const
void | setLodBias (float lodbias)
float | lodBias () const

Public Attributes

fvec4 mColor
float | mRGBScale
float | mAlphaScale
ETexEnvMode mMode
ETexEnvMode mCombineRGB
ETexEnvMode mCombineAlpha
ETexEnvSource mSource0RGB
ETexEnvSource mSource1RGB
ETexEnvSource mSource2RGB
ETexEnvSource mSource0Alpha
ETexEnvSource mSource1Alpha
ETexEnvSource mSource2Alpha
ETexEnvOperand mOperand0RGB
ETexEnvOperand mOperand1RGB
ETexEnvOperand mOperand2RGB
ETexEnvOperand mOperand0Alpha
ETexEnvOperand mOperand1Alpha
ETexEnvOperand mOperand2Alpha
float | mLodBias
bool | mPointSpriteCoordReplace

Detailed Description

Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information.

Note:
A TexParameter defines a set of variables associated to a Texture while TexGen and TexEnv define a set of variables associated to a TextureUnit.
See also:
Shader, TextureUnit, Texture, TexGen, TexParameter, Effect, Actor

Constructor & Destructor Documentation

TexEnv::TexEnv ( int texunit )

Member Function Documentation

virtual const char* vl::TexEnv::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::TexEnv::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void TexEnv::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::TexEnv::setMode ( ETexEnvMode mode ) [inline]

ETexEnvMode vl::TexEnv::mode ( ) const [inline]

void vl::TexEnv::setCombineRGB ( ETexEnvMode combineRGB ) [inline]

ETexEnvMode vl::TexEnv::combineRGB ( ) const [inline]

void vl::TexEnv::setCombineAlpha ( ETexEnvMode combineAlpha ) [inline]

ETexEnvMode vl::TexEnv::combineAlpha ( ) const [inline]

void vl::TexEnv::setColor ( fvec4 color ) [inline]

fvec4 vl::TexEnv::color ( ) const [inline]

void vl::TexEnv::setRGBScale ( float rgbscale ) [inline]

float vl::TexEnv::rgbScale ( ) const [inline]

void vl::TexEnv::setAlphaScale ( float alphascale ) [inline]

float vl::TexEnv::alphaScale ( ) const [inline]

void vl::TexEnv::setSource0RGB ( ETexEnvSource source ) [inline]

void vl::TexEnv::setSource1RGB ( ETexEnvSource source ) [inline]

void vl::TexEnv::setSource2RGB ( ETexEnvSource source ) [inline]

ETexEnvSource vl::TexEnv::source0RGB ( ) const [inline]

ETexEnvSource vl::TexEnv::source1RGB ( ) const [inline]

ETexEnvSource vl::TexEnv::source2RGB ( ) const [inline]

void vl::TexEnv::setSource0Alpha ( ETexEnvSource source ) [inline]

void vl::TexEnv::setSource1Alpha ( ETexEnvSource source ) [inline]

void vl::TexEnv::setSource2Alpha ( ETexEnvSource source ) [inline]

ETexEnvSource vl::TexEnv::source0Alpha ( ) const [inline]

ETexEnvSource vl::TexEnv::source1Alpha ( ) const [inline]

ETexEnvSource vl::TexEnv::source2Alpha ( ) const [inline]

void vl::TexEnv::setOperand0RGB ( ETexEnvOperand operand ) [inline]

void vl::TexEnv::setOperand1RGB ( ETexEnvOperand operand ) [inline]

void vl::TexEnv::setOperand2RGB ( ETexEnvOperand operand ) [inline]

ETexEnvOperand vl::TexEnv::operand0RGB ( ) const [inline]

ETexEnvOperand vl::TexEnv::operand1RGB ( ) const [inline]

ETexEnvOperand vl::TexEnv::operand2RGB ( ) const [inline]

void vl::TexEnv::setOperand0Alpha ( ETexEnvOperand operand ) [inline]

void vl::TexEnv::setOperand1Alpha ( ETexEnvOperand operand ) [inline]

void vl::TexEnv::setOperand2Alpha ( ETexEnvOperand operand ) [inline]

ETexEnvOperand vl::TexEnv::operand0Alpha ( ) const [inline]

ETexEnvOperand vl::TexEnv::operand1Alpha ( ) const [inline]

ETexEnvOperand vl::TexEnv::operand2Alpha ( ) const [inline]

void vl::TexEnv::setPointSpriteCoordReplace ( bool replace ) [inline]

bool vl::TexEnv::pointSpriteCoordReplace ( ) const [inline]

void vl::TexEnv::setLodBias ( float lodbias ) [inline]

float vl::TexEnv::lodBias ( ) const [inline]

Member Data Documentation

fvec4 vl::TexEnv::mColor

float vl::TexEnv::mRGBScale

float vl::TexEnv::mAlphaScale

ETexEnvMode vl::TexEnv::mMode

ETexEnvMode vl::TexEnv::mCombineRGB

ETexEnvMode vl::TexEnv::mCombineAlpha

ETexEnvSource vl::TexEnv::mSource0RGB

ETexEnvSource vl::TexEnv::mSource1RGB

ETexEnvSource vl::TexEnv::mSource2RGB

ETexEnvSource vl::TexEnv::mSource0Alpha

ETexEnvSource vl::TexEnv::mSource1Alpha

ETexEnvSource vl::TexEnv::mSource2Alpha

ETexEnvOperand vl::TexEnv::mOperand0RGB

ETexEnvOperand vl::TexEnv::mOperand1RGB

ETexEnvOperand vl::TexEnv::mOperand2RGB

ETexEnvOperand vl::TexEnv::mOperand0Alpha

ETexEnvOperand vl::TexEnv::mOperand1Alpha

ETexEnvOperand vl::TexEnv::mOperand2Alpha

float vl::TexEnv::mLodBias

bool vl::TexEnv::mPointSpriteCoordReplace

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::TexGen Class Reference

vl::TexGen

vl::TexGen Class Reference

Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information. More...

#include <Shader.hpp>

Inheritance diagram for vl::TexGen:

vl::RenderState vl::Object

List of all members.

Public Member Functions

TexGen (int texunit)
The eye and object planes are not transformed by any matrix (unlike usually with OpenGL), which means that the object plane is specified in object coordinates and that, the eye plane is specified in camera coordinates.
virtual const char * | className ()
Returns the name of the class.
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
void | setEyePlaneS (fvec4 plane)
void | setObjectPlaneS (fvec4 plane)
void | setGenModeS (ETexGenMode mode)
fvec4 | eyePlaneS () const
fvec4 | objectPlaneS () const
ETexGenMode | genModeS () const
void | setEyePlaneT (fvec4 plane)
void | setObjectPlaneT (fvec4 plane)
void | setGenModeT (ETexGenMode mode)
fvec4 | eyePlaneT () const
fvec4 | objectPlaneT () const
ETexGenMode | genModeT () const
void | setEyePlaneR (fvec4 plane)
void | setObjectPlaneR (fvec4 plane)
void | setGenModeR (ETexGenMode mode)
fvec4 | eyePlaneR () const
fvec4 | objectPlaneR () const
ETexGenMode | genModeR () const
void | setEyePlaneQ (fvec4 plane)
void | setObjectPlaneQ (fvec4 plane)
void | setGenModeQ (ETexGenMode mode)
fvec4 | eyePlaneQ () const
fvec4 | objectPlaneQ () const
ETexGenMode | genModeQ () const

Public Attributes

fvec4 mEyePlaneS
fvec4 mObjectPlaneS
fvec4 mEyePlaneT
fvec4 mObjectPlaneT
fvec4 mEyePlaneR
fvec4 mObjectPlaneR
fvec4 mEyePlaneQ
fvec4 mObjectPlaneQ
ETexGenMode mGenModeS
ETexGenMode mGenModeT
ETexGenMode mGenModeR
ETexGenMode mGenModeQ

Detailed Description

Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information.

Note:
A TexParameter defines a set of variables associated to a Texture while TexGen and TexEnv define a set of variables associated to a TextureUnit.
See also:
Shader, TextureUnit, Texture, TexGen, TexParameter, Effect, Actor

Constructor & Destructor Documentation

TexGen::TexGen ( int texunit )

The eye and object planes are not transformed by any matrix (unlike usually with OpenGL), which means that the object plane is specified in object coordinates and that, the eye plane is specified in camera coordinates.

Member Function Documentation

virtual const char* vl::TexGen::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::TexGen::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void TexGen::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void vl::TexGen::setEyePlaneS ( fvec4 plane ) [inline]

void vl::TexGen::setObjectPlaneS ( fvec4 plane ) [inline]

void vl::TexGen::setGenModeS ( ETexGenMode mode ) [inline]

fvec4 vl::TexGen::eyePlaneS ( ) const [inline]

fvec4 vl::TexGen::objectPlaneS ( ) const [inline]

ETexGenMode vl::TexGen::genModeS ( ) const [inline]

void vl::TexGen::setEyePlaneT ( fvec4 plane ) [inline]

void vl::TexGen::setObjectPlaneT ( fvec4 plane ) [inline]

void vl::TexGen::setGenModeT ( ETexGenMode mode ) [inline]

fvec4 vl::TexGen::eyePlaneT ( ) const [inline]

fvec4 vl::TexGen::objectPlaneT ( ) const [inline]

ETexGenMode vl::TexGen::genModeT ( ) const [inline]

void vl::TexGen::setEyePlaneR ( fvec4 plane ) [inline]

void vl::TexGen::setObjectPlaneR ( fvec4 plane ) [inline]

void vl::TexGen::setGenModeR ( ETexGenMode mode ) [inline]

fvec4 vl::TexGen::eyePlaneR ( ) const [inline]

fvec4 vl::TexGen::objectPlaneR ( ) const [inline]

ETexGenMode vl::TexGen::genModeR ( ) const [inline]

void vl::TexGen::setEyePlaneQ ( fvec4 plane ) [inline]

void vl::TexGen::setObjectPlaneQ ( fvec4 plane ) [inline]

void vl::TexGen::setGenModeQ ( ETexGenMode mode ) [inline]

fvec4 vl::TexGen::eyePlaneQ ( ) const [inline]

fvec4 vl::TexGen::objectPlaneQ ( ) const [inline]

ETexGenMode vl::TexGen::genModeQ ( ) const [inline]

Member Data Documentation

fvec4 vl::TexGen::mEyePlaneS

fvec4 vl::TexGen::mObjectPlaneS

fvec4 vl::TexGen::mEyePlaneT

fvec4 vl::TexGen::mObjectPlaneT

fvec4 vl::TexGen::mEyePlaneR

fvec4 vl::TexGen::mObjectPlaneR

fvec4 vl::TexGen::mEyePlaneQ

fvec4 vl::TexGen::mObjectPlaneQ

ETexGenMode vl::TexGen::mGenModeS

ETexGenMode vl::TexGen::mGenModeT

ETexGenMode vl::TexGen::mGenModeR

ETexGenMode vl::TexGen::mGenModeQ

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::TexParameter Class Reference

vl::TexParameter

vl::TexParameter Class Reference

Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information. More...

#include <Texture.hpp>

Inheritance diagram for vl::TexParameter:

vl::Object

List of all members.

Public Member Functions

TexParameter ()
virtual const char * | className ()
Returns the name of the class.
void | apply (ETextureDimension dimension)
ETexParamFilter | minFilter () const
ETexParamFilter | magFilter () const
ETexParamWrap | wrapS () const
ETexParamWrap | wrapT () const
ETexParamWrap | wrapR () const
fvec4 | borderColor () const
float | anisotropy () const
bool | generateMipmap () const
ETexCompareMode | compareMode () const
ETexCompareFunc | compareFunc () const
EDepthTextureMode | depthTextureMode () const
void | setMinFilter (ETexParamFilter minfilter)
void | setMagFilter (ETexParamFilter magfilter)
void | setWrapS (ETexParamWrap texturewrap)
void | setWrapT (ETexParamWrap texturewrap)
void | setWrapR (ETexParamWrap texturewrap)
void | setBorderColor (fvec4 bordercolor)
void | setAnisotropy (float anisotropy)
void | setGenerateMipmap (bool generate_mipmap)
void | setTexCompareMode (ETexCompareMode mode)
void | setTexCompareFunc (ETexCompareFunc func)
void | setDepthTextureMode (EDepthTextureMode mode)
bool | dirty () const

Protected Attributes

ETexParamFilter mMinFilter
ETexParamFilter mMagfilter
ETexParamWrap mWrapS
ETexParamWrap mWrapT
ETexParamWrap mWrapR
ETexCompareMode mCompareMode
ETexCompareFunc mCompareFunc
EDepthTextureMode mDepthTextureMode
fvec4 mBorderColor
float | mAnisotropy
bool | mGenerateMipmap
bool | mDirty

Detailed Description

Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information.

Note:
A TexParameter defines a set of variables associated to a Texture while TexGen and TexEnv define a set of variables associated to a TextureUnit.
See also:
  • TextureUnit
  • Texture
  • TexGen
  • TexEnv
  • Shader
  • Effect
  • Actor

Constructor & Destructor Documentation

TexParameter::TexParameter ( )

Member Function Documentation

virtual const char* vl::TexParameter::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void TexParameter::apply ( ETextureDimension dimension )

ETexParamFilter vl::TexParameter::minFilter ( ) const [inline]

ETexParamFilter vl::TexParameter::magFilter ( ) const [inline]

ETexParamWrap vl::TexParameter::wrapS ( ) const [inline]

ETexParamWrap vl::TexParameter::wrapT ( ) const [inline]

ETexParamWrap vl::TexParameter::wrapR ( ) const [inline]

fvec4 vl::TexParameter::borderColor ( ) const [inline]

float vl::TexParameter::anisotropy ( ) const [inline]

bool vl::TexParameter::generateMipmap ( ) const [inline]

ETexCompareMode vl::TexParameter::compareMode ( ) const [inline]

ETexCompareFunc vl::TexParameter::compareFunc ( ) const [inline]

EDepthTextureMode vl::TexParameter::depthTextureMode ( ) const [inline]

void vl::TexParameter::setMinFilter ( ETexParamFilter minfilter ) [inline]

void TexParameter::setMagFilter ( ETexParamFilter magfilter )

void vl::TexParameter::setWrapS ( ETexParamWrap texturewrap ) [inline]

void vl::TexParameter::setWrapT ( ETexParamWrap texturewrap ) [inline]

void vl::TexParameter::setWrapR ( ETexParamWrap texturewrap ) [inline]

void vl::TexParameter::setBorderColor ( fvec4 bordercolor ) [inline]

void vl::TexParameter::setAnisotropy ( float anisotropy ) [inline]

void vl::TexParameter::setGenerateMipmap ( bool generate_mipmap ) [inline]

void vl::TexParameter::setTexCompareMode ( ETexCompareMode mode ) [inline]

void vl::TexParameter::setTexCompareFunc ( ETexCompareFunc func ) [inline]

void vl::TexParameter::setDepthTextureMode ( EDepthTextureMode mode ) [inline]

bool vl::TexParameter::dirty ( ) const [inline]

Member Data Documentation

ETexParamFilter vl::TexParameter::mMinFilter [protected]

ETexParamFilter vl::TexParameter::mMagfilter [protected]

ETexParamWrap vl::TexParameter::mWrapS [protected]

ETexParamWrap vl::TexParameter::mWrapT [protected]

ETexParamWrap vl::TexParameter::mWrapR [protected]

ETexCompareMode vl::TexParameter::mCompareMode [protected]

ETexCompareFunc vl::TexParameter::mCompareFunc [protected]

EDepthTextureMode vl::TexParameter::mDepthTextureMode [protected]

fvec4 vl::TexParameter::mBorderColor [protected]

float vl::TexParameter::mAnisotropy [protected]

bool vl::TexParameter::mGenerateMipmap [protected]

bool vl::TexParameter::mDirty [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::Text Class Reference

vl::Text

vl::Text Class Reference

A Renderable that renders text with a given Font. More...

#include <Text.hpp>

Inheritance diagram for vl::Text:

vl::Renderable vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Text ()
const String & | text () const
void | setText (const String &text)
const fvec4 & | color () const
void | setColor (const fvec4 &color)
const fvec4 & | borderColor () const
void | setBorderColor (const fvec4 &border_color)
const fvec4 & | outlineColor () const
void | setOutlineColor (const fvec4 &outline_color)
const fvec4 & | backgroundColor () const
void | setBackgroundColor (const fvec4 &background_color)
const fvec4 & | shadowColor () const
void | setShadowColor (const fvec4 &shadow_color)
const fvec2 & | shadowVector () const
void | setShadowVector (const fvec2 &shadow_vector)
int | margin () const
void | setMargin (int margin)
Font * | font () const
void | setFont (Font *font)
const fmat4 | matrix () const
void | setMatrix (const fmat4 &matrix)
int | alignment () const
void | setAlignment (int align)
int | viewportAlignment () const
void | setViewportAlignment (int align)
float | interlineSpacing () const
void | setInterlineSpacing (float spacing)
ETextMode | mode () const
void | setMode (ETextMode mode)
ETextLayout | layout () const
void | setLayout (ETextLayout layout)
ETextAlign | textAlignment () const
void | setTextAlignment (ETextAlign align)
bool | borderEnabled () const
void | setBorderEnabled (bool border)
bool | backgroundEnabled () const
void | setBackgroundEnabled (bool background)
bool | kerningEnabled () const
void | setKerningEnabled (bool kerning)
bool | outlineEnabled () const
void | setOutlineEnabled (bool outline)
bool | shadowEnabled () const
void | setShadowEnabled (bool shadow)
virtual void | render (const Actor *, const OpenGLContext *, const Camera *camera) const
Renders the Renderable.
void | computeBounds_Implementation ()
AABB | boundingRect () const
Returns the plain 2D bounding box of the text, without taking into consideration the Text's matrix transform and the eventual actor's transform.
AABB | boundingRect (const String &text) const
AABB | boundingRectTransformed (vec3 &a, vec3 &b, vec3 &c, vec3 &d, const Camera *camera, const Actor *actor=NULL) const
AABB | boundingRectTransformed (const Camera *camera, const Actor *actor=NULL) const
Returns the fully transformed bounding box.
void | translate (float x, float y, float z)
void | rotate (float degrees, float x, float y, float z)
void | resetMatrix ()

Protected Member Functions

void | renderText (const Actor *, const Camera *camera, const fvec4 &color, const fvec2 &offset) const
void | renderBackground (const Actor *actor, const Camera *camera) const
void | renderBorder (const Actor *actor, const Camera *camera) const
AABB | rawboundingRect (const String &text) const

Protected Attributes

ref< Font > mFont
String mText
fvec4 mColor
fvec4 mBorderColor
fvec4 mBackgroundColor
fvec4 mOutlineColor
fvec4 mShadowColor
fvec2 mShadowVector
fmat4 mMatrix
float | mInterlineSpacing
int | mAlignment
int | mViewportAlignment
int | mMargin
ETextMode mMode
ETextLayout mLayout
ETextAlign mTextAlignment
bool | mBorderEnabled
bool | mBackgroundEnabled
bool | mOutlineEnabled
bool | mShadowEnabled
bool | mKerningEnabled

Detailed Description

A Renderable that renders text with a given Font.

See also:
  • Actor
  • VectorGraphics

Constructor & Destructor Documentation

vl::Text::Text ( ) [inline]

Member Function Documentation

virtual const char* vl::Text::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Renderable.

const String& vl::Text::text ( ) const [inline]

void vl::Text::setText ( const String & text ) [inline]

const fvec4& vl::Text::color ( ) const [inline]

void vl::Text::setColor ( const fvec4 & color ) [inline]

const fvec4& vl::Text::borderColor ( ) const [inline]

void vl::Text::setBorderColor ( const fvec4 & border_color ) [inline]

const fvec4& vl::Text::outlineColor ( ) const [inline]

void vl::Text::setOutlineColor ( const fvec4 & outline_color ) [inline]

const fvec4& vl::Text::backgroundColor ( ) const [inline]

void vl::Text::setBackgroundColor ( const fvec4 & background_color ) [inline]

const fvec4& vl::Text::shadowColor ( ) const [inline]

void vl::Text::setShadowColor ( const fvec4 & shadow_color ) [inline]

const fvec2& vl::Text::shadowVector ( ) const [inline]

void vl::Text::setShadowVector ( const fvec2 & shadow_vector ) [inline]

int vl::Text::margin ( ) const [inline]

void vl::Text::setMargin ( int margin ) [inline]

Font* vl::Text::font ( ) const [inline]

void vl::Text::setFont ( Font * font ) [inline]

const fmat4 vl::Text::matrix ( ) const [inline]

void vl::Text::setMatrix ( const fmat4 & matrix ) [inline]

int vl::Text::alignment ( ) const [inline]

void vl::Text::setAlignment ( int align ) [inline]

int vl::Text::viewportAlignment ( ) const [inline]

void vl::Text::setViewportAlignment ( int align ) [inline]

float vl::Text::interlineSpacing ( ) const [inline]

void vl::Text::setInterlineSpacing ( float spacing ) [inline]

ETextMode vl::Text::mode ( ) const [inline]

void vl::Text::setMode ( ETextMode mode ) [inline]

ETextLayout vl::Text::layout ( ) const [inline]

void vl::Text::setLayout ( ETextLayout layout ) [inline]

ETextAlign vl::Text::textAlignment ( ) const [inline]

void vl::Text::setTextAlignment ( ETextAlign align ) [inline]

bool vl::Text::borderEnabled ( ) const [inline]

void vl::Text::setBorderEnabled ( bool border ) [inline]

bool vl::Text::backgroundEnabled ( ) const [inline]

void vl::Text::setBackgroundEnabled ( bool background ) [inline]

bool vl::Text::kerningEnabled ( ) const [inline]

void vl::Text::setKerningEnabled ( bool kerning ) [inline]

bool vl::Text::outlineEnabled ( ) const [inline]

void vl::Text::setOutlineEnabled ( bool outline ) [inline]

bool vl::Text::shadowEnabled ( ) const [inline]

void vl::Text::setShadowEnabled ( bool shadow ) [inline]

void Text::render | ( | const Actor * | actor,
 |  | const OpenGLContext * | ,
 |  | const Camera * | camera |
 | ) |  |  | const [virtual]

Renders the Renderable.

Implements vl::Renderable.

void vl::Text::computeBounds_Implementation ( ) [inline, virtual]

Implements vl::Renderable.

AABB Text::boundingRect ( ) const

Returns the plain 2D bounding box of the text, without taking into consideration the Text's matrix transform and the eventual actor's transform.

AABB Text::boundingRect ( const String & text ) const

AABB Text::boundingRectTransformed | ( | vec3 & | a,
 |  | vec3 & | b,
 |  | vec3 & | c,
 |  | vec3 & | d,
 |  | const Camera * | camera,
 |  | const Actor * | actor = NULL |
 | ) |  |  | const

AABB Text::boundingRectTransformed | ( | const Camera * | camera,
 |  | const Actor * | actor = NULL |
 | ) |  |  | const

Returns the fully transformed bounding box.

actor is needed only if you are using the actor's transform with the Text2D to make the Text2D text follow the actor on the screen or you are using the Text3D to make the text follow the actor's transform in 3D.

The layout of the a, b, c and d points is the following:

d---------c
| |
| |
a---------b

Of course the above layout can be scaled, flipped, rotated and so on according to the given Text's matrix.

void Text::translate | ( | float | x,
 |  | float | y,
 |  | float | z
 | ) |  |

void Text::rotate | ( | float | degrees,
 |  | float | x,
 |  | float | y,
 |  | float | z
 | ) |  |

void Text::resetMatrix ( )

void Text::renderText | ( | const Actor * | actor,
 |  | const Camera * | camera,
 |  | const fvec4 & | color,
 |  | const fvec2 & | offset |
 | ) |  |  | const [protected]

void Text::renderBackground | ( | const Actor * | actor,
 |  | const Camera * | camera |
 | ) |  |  | const [protected]

void Text::renderBorder | ( | const Actor * | actor,
 |  | const Camera * | camera |
 | ) |  |  | const [protected]

AABB Text::rawboundingRect ( const String & text ) const [protected]

Member Data Documentation

ref<Font> vl::Text::mFont [protected]

String vl::Text::mText [protected]

fvec4 vl::Text::mColor [protected]

fvec4 vl::Text::mBorderColor [protected]

fvec4 vl::Text::mBackgroundColor [protected]

fvec4 vl::Text::mOutlineColor [protected]

fvec4 vl::Text::mShadowColor [protected]

fvec2 vl::Text::mShadowVector [protected]

fmat4 vl::Text::mMatrix [protected]

float vl::Text::mInterlineSpacing [protected]

int vl::Text::mAlignment [protected]

int vl::Text::mViewportAlignment [protected]

int vl::Text::mMargin [protected]

ETextMode vl::Text::mMode [protected]

ETextLayout vl::Text::mLayout [protected]

ETextAlign vl::Text::mTextAlignment [protected]

bool vl::Text::mBorderEnabled [protected]

bool vl::Text::mBackgroundEnabled [protected]

bool vl::Text::mOutlineEnabled [protected]

bool vl::Text::mShadowEnabled [protected]

bool vl::Text::mKerningEnabled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::TextStream Class Reference

vl::TextStream

vl::TextStream Class Reference

The TextStream class can be used to conveniently read or parse utf8-encoded text files. More...

#include <TextStream.hpp>

Inheritance diagram for vl::TextStream:

vl::BufferedStream< unsigned char, 128 *1024 > vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
TextStream (VirtualFile *file=NULL)
~TextStream ()
void | ungetLine (const std::string &utf8)
bool | readLine (std::string &utf8)
bool | readLine (String &line)
Reads a CR or LF or CR/LF or LF/CR terminated line.
bool | readLineCR (String &line)
Reads a CR terminated line.
bool | readLineLF (String &line)
Reads a LF terminated line.
bool | readInt (int &i, bool hex=false)
bool | readDouble (double &d)
bool | readString (String &token)
bool | readStdString (std::string &token)
bool | readQuotedString (String &token)

Protected Attributes

String mTmpStr
std::string | mTmpStdStr

Detailed Description

The TextStream class can be used to conveniently read or parse utf8-encoded text files.

Constructor & Destructor Documentation

vl::TextStream::TextStream ( VirtualFile * file = NULL ) [inline]

vl::TextStream::~TextStream ( ) [inline]

Member Function Documentation

virtual const char* vl::TextStream::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::BufferedStream< unsigned char, 128 *1024 >.

void vl::TextStream::ungetLine ( const std::string & utf8 ) [inline]

bool vl::TextStream::readLine ( std::string & utf8 ) [inline]

bool vl::TextStream::readLine ( String & line ) [inline]

Reads a CR or LF or CR/LF or LF/CR terminated line.

bool vl::TextStream::readLineCR ( String & line ) [inline]

Reads a CR terminated line.

bool vl::TextStream::readLineLF ( String & line ) [inline]

Reads a LF terminated line.

bool vl::TextStream::readInt | ( | int & | i,
 |  | bool | hex = false |
 | ) |  |  | [inline]

bool vl::TextStream::readDouble ( double & d ) [inline]

bool vl::TextStream::readString ( String & token ) [inline]

bool vl::TextStream::readStdString ( std::string & token ) [inline]

bool vl::TextStream::readQuotedString ( String & token ) [inline]

Member Data Documentation

String vl::TextStream::mTmpStr [protected]

std::string vl::TextStream::mTmpStdStr [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TextStream.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::Texture Class Reference

vl::Texture

vl::Texture Class Reference

Wraps an OpenGL texture object. More...

#include <Texture.hpp>

Inheritance diagram for vl::Texture:

vl::Object

List of all members.

Classes

class | SetupParams
The SetupParams function wraps all the parameters neede to crate a Texture. More...

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Texture (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
Texture (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
Texture (int width, ETextureFormat format=TF_RGBA, bool border=false)
Texture (int width, int height, ETextureFormat format=TF_RGBA, bool border=false)
Texture (int width, int height, int depth, ETextureFormat format=TF_RGBA, bool border=false)
Texture ()
virtual | ~Texture ()
TexParameter * | getTexParameter () const
bool | createTexture ()
Performs the actual creation of the texture.
void | setupTexture1D (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture1D (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture2D (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture2D (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture3D (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture3D (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTextureCubemap (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTextureCubemap (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false)
void | setupTexture1DArray (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true)
void | setupTexture1DArray (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true)
void | setupTexture2DArray (const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true)
void | setupTexture2DArray (Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true)
void | setupTextureRectangle (const String &image_path, ETextureFormat format=TF_RGBA)
void | setupTextureRectangle (Image *image, ETextureFormat format=TF_RGBA)
bool | isValid () const
bool | hasMipMaps () const
void | setHandle (unsigned int id)
void | setDimension (ETextureDimension dimension)
void | setWidth (int x)
void | setHeight (int y)
void | setDepth (int z)
void | setBorder (bool border)
void | setInternalFormat (ETextureFormat format)
unsigned int | handle () const
ETextureDimension | dimension () const
int | width () const
int | height () const
int | depth () const
bool | border () const
ETextureFormat | internalFormat () const
const SetupParams * | setupParams () const
See SetupParams.
SetupParams * setupParams ()
See SetupParams.
void | setSetupParams (SetupParams *setup_params)
See SetupParams.

Static Public Member Functions

static bool | supports (ETextureDimension texture_dim, ETextureFormat format, bool border, const Image *image, bool verbose=true)
static bool | isCompressedFormat (int format)

Protected Attributes

unsigned int | mHandle
ref< TexParameter > mTexParameter
ref< SetupParams > mSetupParams
ETextureFormat mFormat
ETextureDimension mDimension
int | mWidth
int | mHeight
int | mDepth
bool | mBorder
bool | mHasMipmaps

Detailed Description

Wraps an OpenGL texture object.

Note:
A TexParameter defines a set of variables associated to a Texture while TexGen and TexEnv define a set of variables associated to a TextureUnit.
See also:
  • TextureUnit
  • Texture
  • TexParameter
  • TexGen
  • TexEnv
  • Shader
  • Effect
  • Actor

Constructor & Destructor Documentation

Texture::Texture | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false
 | ) |  |

Texture::Texture | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false
 | ) |  |

Texture::Texture | ( | int | width,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | border = false
 | ) |  |

Texture::Texture | ( | int | width,
 |  | int | height,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | border = false
 | ) |  |

Texture::Texture | ( | int | width,
 |  | int | height,
 |  | int | depth,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | border = false
 | ) |  |

Texture::Texture ( )

Texture::~Texture ( ) [virtual]

Member Function Documentation

virtual const char* vl::Texture::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

TexParameter* vl::Texture::getTexParameter ( ) const [inline]

bool Texture::createTexture ( )

Performs the actual creation of the texture.

See also:
  • setupTexture2D()
  • SetupParams

void vl::Texture::setupTexture1D | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture1D | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture2D | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture2D | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture3D | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture3D | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTextureCubemap | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTextureCubemap | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true,
 |  | bool | border = false |
 | ) |  |  | [inline]

void vl::Texture::setupTexture1DArray | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true |
 | ) |  |  | [inline]

void vl::Texture::setupTexture1DArray | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true |
 | ) |  |  | [inline]

void vl::Texture::setupTexture2DArray | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true |
 | ) |  |  | [inline]

void vl::Texture::setupTexture2DArray | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA,
 |  | bool | mipmaps = true |
 | ) |  |  | [inline]

void vl::Texture::setupTextureRectangle | ( | const String & | image_path,
 |  | ETextureFormat | format = TF_RGBA |
 | ) |  |  | [inline]

void vl::Texture::setupTextureRectangle | ( | Image * | image,
 |  | ETextureFormat | format = TF_RGBA |
 | ) |  |  | [inline]

bool Texture::isValid ( ) const

bool vl::Texture::hasMipMaps ( ) const [inline]

void vl::Texture::setHandle ( unsigned int id ) [inline]

void vl::Texture::setDimension ( ETextureDimension dimension ) [inline]

void vl::Texture::setWidth ( int x ) [inline]

void vl::Texture::setHeight ( int y ) [inline]

void vl::Texture::setDepth ( int z ) [inline]

void vl::Texture::setBorder ( bool border ) [inline]

void vl::Texture::setInternalFormat ( ETextureFormat format ) [inline]

unsigned int vl::Texture::handle ( ) const [inline]

ETextureDimension vl::Texture::dimension ( ) const [inline]

int vl::Texture::width ( ) const [inline]

int vl::Texture::height ( ) const [inline]

int vl::Texture::depth ( ) const [inline]

bool vl::Texture::border ( ) const [inline]

ETextureFormat vl::Texture::internalFormat ( ) const [inline]

const SetupParams* vl::Texture::setupParams ( ) const [inline]

See SetupParams.

SetupParams* vl::Texture::setupParams ( ) [inline]

See SetupParams.

void vl::Texture::setSetupParams ( SetupParams * setup_params ) [inline]

See SetupParams.

bool Texture::supports | ( | ETextureDimension | texture_dim,
 |  | ETextureFormat | format,
 |  | bool | border,
 |  | const Image * | image,
 |  | bool | verbose = true |
 | ) |  |  | [static]

bool Texture::isCompressedFormat ( int format ) [static]

Member Data Documentation

unsigned int vl::Texture::mHandle [protected]

ref<TexParameter> vl::Texture::mTexParameter [protected]

ref<SetupParams> vl::Texture::mSetupParams [protected]

ETextureFormat vl::Texture::mFormat [protected]

ETextureDimension vl::Texture::mDimension [protected]

int vl::Texture::mWidth [protected]

int vl::Texture::mHeight [protected]

int vl::Texture::mDepth [protected]

bool vl::Texture::mBorder [protected]

bool vl::Texture::mHasMipmaps [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::Texture::SetupParams Class Reference

vl::Texture::SetupParams

vl::Texture::SetupParams Class Reference

The SetupParams function wraps all the parameters neede to crate a Texture. More...

#include <Texture.hpp>

Inheritance diagram for vl::Texture::SetupParams:

vl::Object

List of all members.

Public Member Functions

SetupParams ()
const String & | imagePath () const
Image * | image () const
ETextureDimension | dimension () const
ETextureFormat | format () const
bool | border () const
bool | hasMipmaps () const
void | setImagePath (const String &path)
void | setImage (Image *image)
void | setDimension (ETextureDimension dimension)
void | setFormat (ETextureFormat format)
void | setBorder (bool on)
void | setHasMipmaps (bool on)

Protected Attributes

String mImagePath
ref< Image > mImage
ETextureDimension mDimension
ETextureFormat mFormat
bool | mBorder
bool | mHasMipmaps

Detailed Description

The SetupParams function wraps all the parameters neede to crate a Texture.

A SetupParams object is automatically bound to a Texture after calling setupTexture2D() and similar functions. Once the SetupParams are bound to a Texture calling Texture::createTexture() will create a new Texture according to what specified in the SetupParams objects. After Texture::createTexture() the SetupParams object is removed.

Constructor & Destructor Documentation

vl::Texture::SetupParams::SetupParams ( ) [inline]

Member Function Documentation

const String& vl::Texture::SetupParams::imagePath ( ) const [inline]

Image* vl::Texture::SetupParams::image ( ) const [inline]

ETextureDimension vl::Texture::SetupParams::dimension ( ) const [inline]

ETextureFormat vl::Texture::SetupParams::format ( ) const [inline]

bool vl::Texture::SetupParams::border ( ) const [inline]

bool vl::Texture::SetupParams::hasMipmaps ( ) const [inline]

void vl::Texture::SetupParams::setImagePath ( const String & path ) [inline]

void vl::Texture::SetupParams::setImage ( Image * image ) [inline]

void vl::Texture::SetupParams::setDimension ( ETextureDimension dimension ) [inline]

void vl::Texture::SetupParams::setFormat ( ETextureFormat format ) [inline]

void vl::Texture::SetupParams::setBorder ( bool on ) [inline]

void vl::Texture::SetupParams::setHasMipmaps ( bool on ) [inline]

Member Data Documentation

String vl::Texture::SetupParams::mImagePath [protected]

ref<Image> vl::Texture::SetupParams::mImage [protected]

ETextureDimension vl::Texture::SetupParams::mDimension [protected]

ETextureFormat vl::Texture::SetupParams::mFormat [protected]

bool vl::Texture::SetupParams::mBorder [protected]

bool vl::Texture::SetupParams::mHasMipmaps [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::TextureMatrix Class Reference

vl::TextureMatrix

vl::TextureMatrix Class Reference

The TextureMatrix class uses a 4x4 matrix to transform the texture coordinates of a texture unit. More...

#include <Shader.hpp>

Inheritance diagram for vl::TextureMatrix:

vl::RenderState vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
TextureMatrix (int texunit)
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
const mat4 & | matrix () const
const TextureMatrix & | setMatrix (const mat4 &matrix)
void | setUseCameraRotationInverse (bool use)
Set this to true when you want your cubemap to appear in world space rather than eye space.
bool | useCameraRotationInverse () const

Protected Attributes

mat4 mMatrix
bool | mUseCameraRotationInverse

Detailed Description

The TextureMatrix class uses a 4x4 matrix to transform the texture coordinates of a texture unit.

See also:
Shader, TextureUnit, Texture, TexGen, TexParameter, Effect, Actor

Constructor & Destructor Documentation

vl::TextureMatrix::TextureMatrix ( int texunit ) [inline]

Member Function Documentation

virtual const char* vl::TextureMatrix::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::TextureMatrix::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void TextureMatrix::apply ( const Camera * camera ) const [virtual]

Implements vl::RenderState.

const mat4& vl::TextureMatrix::matrix ( ) const [inline]

const TextureMatrix& vl::TextureMatrix::setMatrix ( const mat4 & matrix ) [inline]

void vl::TextureMatrix::setUseCameraRotationInverse ( bool use ) [inline]

Set this to true when you want your cubemap to appear in world space rather than eye space.

When setUseCameraRotationInverse() is true the texture matrix is computed as:

 matrix()*camera->inverseViewMatrix().as3x3()
This way matrix() represents the transform of the texture in world coordinates, for example if you want to reorient your cubemap in world space or when you want to rotate the direction of one or more highlights prerendered in a cubemap.

bool vl::TextureMatrix::useCameraRotationInverse ( ) const [inline]

Member Data Documentation

mat4 vl::TextureMatrix::mMatrix [protected]

bool vl::TextureMatrix::mUseCameraRotationInverse [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::TextureUnit Class Reference

vl::TextureUnit

vl::TextureUnit Class Reference

The TextureUnit class associates a Texture object to an OpenGL texture unit. More...

#include <Shader.hpp>

Inheritance diagram for vl::TextureUnit:

vl::RenderState vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
TextureUnit (int texunit)
virtual ERenderState | type () const
virtual void | apply (const Camera *) const
virtual void | disable () const
virtual void | enable () const
virtual void | initResources ()
void | setTexture (Texture *texture)
Texture * texture ()
const Texture * | texture () const
bool | hasTexture () const

Protected Attributes

ref< Texture > mTexture

Detailed Description

The TextureUnit class associates a Texture object to an OpenGL texture unit.

See also:
Texture, TexParameter, Shader, TextureMatrix, TexEnv, TexGen, Effect, Actor

Constructor & Destructor Documentation

vl::TextureUnit::TextureUnit ( int texunit ) [inline]

Member Function Documentation

virtual const char* vl::TextureUnit::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::RenderState.

virtual ERenderState vl::TextureUnit::type ( ) const [inline, virtual]

Reimplemented from vl::RenderState.

void TextureUnit::apply ( const Camera * ) const [virtual]

Implements vl::RenderState.

void TextureUnit::disable ( ) const [virtual]

Reimplemented from vl::RenderState.

void TextureUnit::enable ( ) const [virtual]

Reimplemented from vl::RenderState.

virtual void vl::TextureUnit::initResources ( ) [inline, virtual]

Reimplemented from vl::RenderState.

void vl::TextureUnit::setTexture ( Texture * texture ) [inline]

Texture* vl::TextureUnit::texture ( ) [inline]

const Texture* vl::TextureUnit::texture ( ) const [inline]

bool vl::TextureUnit::hasTexture ( ) const [inline]

Member Data Documentation

ref<Texture> vl::TextureUnit::mTexture [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: vl::Time Class Reference

vl::Time

vl::Time Class Reference

Simple class to be used as a timer and to retrieve the current time and date. More...

#include <Time.hpp>

Inheritance diagram for vl::Time:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Time ()
int | year () const
int | month () const
int | dayOfWeek () const
int | dayOfMonth () const
int | hour () const
int | minute () const
int | second () const
int | microsecond () const
void | start (int index=0)
void | stop (int index=0)
bool | isStarted (int index=0) const
Real | elapsed (int index=0) const

Static Public Member Functions

static Real | currentTime ()
Seconds passed from an arbitrary origin QueryPerformanceFrequency should be called only once in the application lifetime.
static void | sleep (unsigned int milliseconds)

Protected Attributes

int | mYear
int | mMonth
int | mDayOfWeek
int | mDayOfMonth
int | mHour
int | mMinute
int | mSecond
int | mMicrosecond
Real | mStart [VL_MAX_TIMERS]

Detailed Description

Simple class to be used as a timer and to retrieve the current time and date.

Constructor & Destructor Documentation

Time::Time ( )

Member Function Documentation

virtual const char* vl::Time::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

int vl::Time::year ( ) const [inline]

int vl::Time::month ( ) const [inline]

int vl::Time::dayOfWeek ( ) const [inline]

int vl::Time::dayOfMonth ( ) const [inline]

int vl::Time::hour ( ) const [inline]

int vl::Time::minute ( ) const [inline]

int vl::Time::second ( ) const [inline]

int vl::Time::microsecond ( ) const [inline]

Real Time::currentTime ( ) [static]

Seconds passed from an arbitrary origin QueryPerformanceFrequency should be called only once in the application lifetime.

void Time::sleep ( unsigned int milliseconds ) [static]

void vl::Time::start ( int index = 0 ) [inline]

void vl::Time::stop ( int index = 0 ) [inline]

bool vl::Time::isStarted ( int index = 0 ) const [inline]

Real vl::Time::elapsed ( int index = 0 ) const [inline]

Member Data Documentation

int vl::Time::mYear [protected]

int vl::Time::mMonth [protected]

int vl::Time::mDayOfWeek [protected]

int vl::Time::mDayOfMonth [protected]

int vl::Time::mHour [protected]

int vl::Time::mMinute [protected]

int vl::Time::mSecond [protected]

int vl::Time::mMicrosecond [protected]

Real vl::Time::mStart[VL_MAX_TIMERS] [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::TrackballManipulator Class Reference

vl::TrackballManipulator

vl::TrackballManipulator Class Reference

This class lets you rotate a Camera or a Transform node using a vitual trackball. More...

#include <TrackballManipulator.hpp>

Inheritance diagram for vl::TrackballManipulator:

vl::UIEventListener vl::Object

List of all members.

Public Types

enum | ETrackballMode { NoMode, RotationMode, TranslationMode, ZoomMode }

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
TrackballManipulator ()
virtual void | mouseDownEvent (EMouseButton, int x, int y)
virtual void | mouseUpEvent (EMouseButton, int x, int y)
virtual void | mouseMoveEvent (int x, int y)
mat4 | trackballRotation (int x, int y)
vec3 | computeVector (int x, int y)
void | setCamera (Camera *camera)
Camera * camera ()
void | prepareToReconnect ()
Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.
void | setPivot (vec3 pivot)
Sets the center point the camera will rotate around.
vec3 | pivot () const
void | setTransform (Transform *tr)
Transform * transform ()
int | rotationButton () const
void | setRotationButton (int mouse_button)
int | zoomButton () const
void | setZoomButton (int mouse_button)
int | translationButton () const
void | setTranslationButton (int mouse_button)
float | rotationSpeed () const
void | setRotationSpeed (float speed)
float | zoomSpeed () const
void | setZoomSpeed (float speed)
float | translationSpeed () const
void | setTranslationSpeed (float speed)
ETrackballMode | mode () const
Returns the current trackball manipulator state.
void | adjustView (const AABB &aabb, const vec3 &dir, const vec3 &up, Real bias=1.0f)
Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB. See also Camera::adjustView().
void | adjustView (ActorCollection &actors, const vec3 &dir, const vec3 &up, Real bias=1.0f)
Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing the Actor[s]. See also Camera::adjustView().
void | adjustView (SceneManager *scene, const vec3 &dir, const vec3 &up, Real bias=1.0f)
Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing the given scene manager. See also Camera::adjustView().
void | adjustView (Rendering *rendering, const vec3 &dir, const vec3 &up, Real bias=1.0f)
Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing all the scene managers part of the given rendering. See also Camera::adjustView().

Protected Attributes

ref< Camera > mCamera
ivec2 mMouseStart
mat4 mStartMatrix
vec3 mPivot
vec3 mStartCameraPos
vec3 mStartPivot
ref< Transform > mTransform
ETrackballMode mMode
int | mRotationButton
int | mTranslationButton
int | mZoomButton
float | mRotationSpeed
float | mTranslationSpeed
float | mZoomSpeed

Detailed Description

This class lets you rotate a Camera or a Transform node using a vitual trackball.

If you set a Transform node to manipulate, using the function setTransform(), this object will manipulate the given Transform. If no Transform is specified or a NULL one is passed to the function setTransform() then this object will manipulate the current camera.

Note:
In any case, before using a TrackballManipulator you have to specify a Camera object using the function setCamera().

The Transform is expected to contain only rotation and translation information. Other transformations like shearing, scaling, projection, and so on can produce unspecified results.

Member Enumeration Documentation

enum vl::TrackballManipulator::ETrackballMode

Enumerator:
NoMode
RotationMode
TranslationMode
ZoomMode

Constructor & Destructor Documentation

vl::TrackballManipulator::TrackballManipulator ( ) [inline]

Member Function Documentation

virtual const char* vl::TrackballManipulator::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::UIEventListener.

void TrackballManipulator::mouseDownEvent | ( | EMouseButton | btn,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

void TrackballManipulator::mouseUpEvent | ( | EMouseButton | btn,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

void TrackballManipulator::mouseMoveEvent | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

mat4 TrackballManipulator::trackballRotation | ( | int | x,
 |  | int | y
 | ) |  |

vec3 TrackballManipulator::computeVector | ( | int | x,
 |  | int | y
 | ) |  |

void vl::TrackballManipulator::setCamera ( Camera * camera ) [inline]

Camera* vl::TrackballManipulator::camera ( ) [inline]

void vl::TrackballManipulator::prepareToReconnect ( ) [inline, virtual]

Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.

Reimplemented from vl::UIEventListener.

void vl::TrackballManipulator::setPivot ( vec3 pivot ) [inline]

Sets the center point the camera will rotate around.

vec3 vl::TrackballManipulator::pivot ( ) const [inline]

void vl::TrackballManipulator::setTransform ( Transform * tr ) [inline]

Transform* vl::TrackballManipulator::transform ( ) [inline]

int vl::TrackballManipulator::rotationButton ( ) const [inline]

void vl::TrackballManipulator::setRotationButton ( int mouse_button ) [inline]

int vl::TrackballManipulator::zoomButton ( ) const [inline]

void vl::TrackballManipulator::setZoomButton ( int mouse_button ) [inline]

int vl::TrackballManipulator::translationButton ( ) const [inline]

void vl::TrackballManipulator::setTranslationButton ( int mouse_button ) [inline]

float vl::TrackballManipulator::rotationSpeed ( ) const [inline]

void vl::TrackballManipulator::setRotationSpeed ( float speed ) [inline]

float vl::TrackballManipulator::zoomSpeed ( ) const [inline]

void vl::TrackballManipulator::setZoomSpeed ( float speed ) [inline]

float vl::TrackballManipulator::translationSpeed ( ) const [inline]

void vl::TrackballManipulator::setTranslationSpeed ( float speed ) [inline]

ETrackballMode vl::TrackballManipulator::mode ( ) const [inline]

Returns the current trackball manipulator state.

void TrackballManipulator::adjustView | ( | const AABB & | aabb,
 |  | const vec3 & | dir,
 |  | const vec3 & | up,
 |  | Real | bias = 1.0f
 | ) |  |

Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB. See also Camera::adjustView().

void TrackballManipulator::adjustView | ( | ActorCollection & | actors,
 |  | const vec3 & | dir,
 |  | const vec3 & | up,
 |  | Real | bias = 1.0f
 | ) |  |

Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing the Actor[s]. See also Camera::adjustView().

void TrackballManipulator::adjustView | ( | SceneManager * | scene,
 |  | const vec3 & | dir,
 |  | const vec3 & | up,
 |  | Real | bias = 1.0f
 | ) |  |

Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing the given scene manager. See also Camera::adjustView().

void TrackballManipulator::adjustView | ( | Rendering * | rendering,
 |  | const vec3 & | dir,
 |  | const vec3 & | up,
 |  | Real | bias = 1.0f
 | ) |  |

Adjusts the camera position in order to nicely see the scene. It also position the rotation pivot to the center of the AABB containing all the scene managers part of the given rendering. See also Camera::adjustView().

Member Data Documentation

ref<Camera> vl::TrackballManipulator::mCamera [protected]

ivec2 vl::TrackballManipulator::mMouseStart [protected]

mat4 vl::TrackballManipulator::mStartMatrix [protected]

vec3 vl::TrackballManipulator::mPivot [protected]

vec3 vl::TrackballManipulator::mStartCameraPos [protected]

vec3 vl::TrackballManipulator::mStartPivot [protected]

ref<Transform> vl::TrackballManipulator::mTransform [protected]

ETrackballMode vl::TrackballManipulator::mMode [protected]

int vl::TrackballManipulator::mRotationButton [protected]

int vl::TrackballManipulator::mTranslationButton [protected]

int vl::TrackballManipulator::mZoomButton [protected]

float vl::TrackballManipulator::mRotationSpeed [protected]

float vl::TrackballManipulator::mTranslationSpeed [protected]

float vl::TrackballManipulator::mZoomSpeed [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: vl::Transform Class Reference

vl::Transform

vl::Transform Class Reference

Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor. More...

#include <Transform.hpp>

Inheritance diagram for vl::Transform:

vl::Object vl::Billboard

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Transform ()
Transform (const mat4 &matrix)
virtual | ~Transform ()
void | addChild (Transform *child)
void | setChild (int index, Transform *child)
int | childCount () const
Transform * | child (int i)
Transform * lastChild ()
void | eraseChild (Transform *child)
void | eraseChildren (int index, int count)
void | eraseAllChildren ()
void | eraseAllChildrenRecursive ()
const Transform * | parent () const
Transform * parent ()
mat4 getComputedWorldMatrix ()
Returns the matrix computed concatenating this transform's matrix with its parents'.
void | setLocalMatrix (const mat4 &matrix)
Sets the local matrix. After calling this you might want to call computeWorldMatrix() or computeWorldMatrixRecursive().
const mat4 & | localMatrix () const
Returns the local matrix.
void | translate (Real x, Real y, Real z)
Utility function equivalent to setLocalMatrix( mat4::translation(x,y,z)*localMatrix() ).
void | translate (const vec3 &t)
Utility function equivalent to setLocalMatrix( mat4::translation(t)*localMatrix() ).
void | scale (Real x, Real y, Real z)
Utility function equivalent to setLocalMatrix( mat4::scaling(x,y,z)*localMatrix() ).
void | rotate (Real degrees, Real x, Real y, Real z)
Utility function equivalent to setLocalMatrix( mat4::rotation(degrees,x,y,z)*localMatrix() ).
void | rotate (const vec3 &from, const vec3 &to)
Utility function equivalent to setLocalMatrix( mat4::rotation(from,to)*localMatrix() ).
virtual void | computeWorldMatrix (Camera *camera=NULL)
void | computeWorldMatrixRecursive (Camera *camera=NULL)
const mat4 & | worldMatrix () const
long long | worldMatrixUpdateTick () const
void | setAlwaysIdentityWorldMatrix (bool assume_I)
If set to true the world matrix of this transform will always be considered and identity.
bool | alwaysIdentityWorldMatrix ()
If set to true the world matrix of this transform will always be considered and identity.

Protected Member Functions

void | setWorldMatrix (const mat4 &matrix)

Protected Attributes

mat4 mWorldMatrix
mat4 mLocalMatrix
std::vector< ref< Transform > > | mChildren
Transform * mParent
long long | mWorldMatrixUpdateTick
bool | mAssumeIdentityWorldMatrix

Detailed Description

Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor.

Transforms can be linked together to create a tree-like hierarchy.

See also:
Actor, Effect, Renderable, Geometry

Constructor & Destructor Documentation

vl::Transform::Transform ( ) [inline]

vl::Transform::Transform ( const mat4 & matrix ) [inline]

Transform::~Transform ( ) [virtual]

Member Function Documentation

virtual const char* vl::Transform::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::Billboard.

void Transform::addChild ( Transform * child )

void Transform::setChild | ( | int | index,
 |  | Transform * | child
 | ) |  |

int Transform::childCount ( ) const

Transform * Transform::child ( int i )

Transform * Transform::lastChild ( )

void Transform::eraseChild ( Transform * child )

void Transform::eraseChildren | ( | int | index,
 |  | int | count
 | ) |  |

void Transform::eraseAllChildren ( )

void Transform::eraseAllChildrenRecursive ( )

const Transform* vl::Transform::parent ( ) const [inline]

Transform* vl::Transform::parent ( ) [inline]

mat4 Transform::getComputedWorldMatrix ( )

Returns the matrix computed concatenating this transform's matrix with its parents'.

void Transform::setLocalMatrix ( const mat4 & matrix )

Sets the local matrix. After calling this you might want to call computeWorldMatrix() or computeWorldMatrixRecursive().

const mat4 & Transform::localMatrix ( ) const

Returns the local matrix.

void Transform::translate | ( | Real | x,
 |  | Real | y,
 |  | Real | z
 | ) |  |

Utility function equivalent to setLocalMatrix( mat4::translation(x,y,z)*localMatrix() ).

void Transform::translate ( const vec3 & t )

Utility function equivalent to setLocalMatrix( mat4::translation(t)*localMatrix() ).

void Transform::scale | ( | Real | x,
 |  | Real | y,
 |  | Real | z
 | ) |  |

Utility function equivalent to setLocalMatrix( mat4::scaling(x,y,z)*localMatrix() ).

void Transform::rotate | ( | Real | degrees,
 |  | Real | x,
 |  | Real | y,
 |  | Real | z
 | ) |  |

Utility function equivalent to setLocalMatrix( mat4::rotation(degrees,x,y,z)*localMatrix() ).

void Transform::rotate | ( | const vec3 & | from,
 |  | const vec3 & | to
 | ) |  |

Utility function equivalent to setLocalMatrix( mat4::rotation(from,to)*localMatrix() ).

void Transform::computeWorldMatrix ( Camera * camera = NULL ) [virtual]

Reimplemented in vl::Billboard.

void Transform::computeWorldMatrixRecursive ( Camera * camera = NULL )

const mat4 & Transform::worldMatrix ( ) const

long long vl::Transform::worldMatrixUpdateTick ( ) const [inline]

void vl::Transform::setAlwaysIdentityWorldMatrix ( bool assume_I ) [inline]

If set to true the world matrix of this transform will always be considered and identity.

Is usually used to save calculations for top Transforms with many sub-Transforms.

bool vl::Transform::alwaysIdentityWorldMatrix ( ) [inline]

If set to true the world matrix of this transform will always be considered and identity.

Is usually used to save calculations for top Transforms with many sub-Transforms.

void Transform::setWorldMatrix ( const mat4 & matrix ) [protected]

Member Data Documentation

mat4 vl::Transform::mWorldMatrix [protected]

mat4 vl::Transform::mLocalMatrix [protected]

std::vector< ref<Transform> > vl::Transform::mChildren [protected]

Transform* vl::Transform::mParent [protected]

long long vl::Transform::mWorldMatrixUpdateTick [protected]

bool vl::Transform::mAssumeIdentityWorldMatrix [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::TriangleStripGenerator Class Reference

vl::TriangleStripGenerator

vl::TriangleStripGenerator Class Reference

The TriangleStripGenerator class is used to substitute lists of triangles or quads with triangle strips. More...

#include <TriangleStripGenerator.hpp>

List of all members.

Public Member Functions

virtual const char * | className ()

Static Public Member Functions

static void | stripfy (Geometry *geom, int cache_size=22, bool merge_strips=true, bool remove_doubles=true, bool substitute_quads=true)

Detailed Description

The TriangleStripGenerator class is used to substitute lists of triangles or quads with triangle strips.

Member Function Documentation

virtual const char* vl::TriangleStripGenerator::className ( ) [inline, virtual]

void TriangleStripGenerator::stripfy | ( | Geometry * | geom,
 |  | int | cache_size = 22,
 |  | bool | merge_strips = true,
 |  | bool | remove_doubles = true,
 |  | bool | substitute_quads = true |
 | ) |  |  | [static]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::UIEventListener Class Reference

vl::UIEventListener

vl::UIEventListener Class Reference

The UIEventListener class listens to the events emitted by an OpenGLContext. More...

#include <UIEventListener.hpp>

Inheritance diagram for vl::UIEventListener:

vl::Object vl::GhostCameraManipulator vl::TrackballManipulator vlut::Applet

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
UIEventListener ()
virtual | ~UIEventListener ()
virtual void | initEvent ()
virtual void | mouseMoveEvent (int, int)
virtual void | mouseUpEvent (EMouseButton, int, int)
virtual void | mouseDownEvent (EMouseButton, int, int)
virtual void | mouseWheelEvent (int)
virtual void | keyPressEvent (unsigned short, EKey)
virtual void | keyReleaseEvent (unsigned short, EKey)
virtual void | resizeEvent (int, int)
virtual void | destroyEvent ()
virtual void | runEvent ()
virtual void | visibilityEvent (bool)
virtual void | fileDroppedEvent (const std::vector< String > &)
virtual void | openglContextBoundEvent (OpenGLContext *)
void | setRank (int rank)
int | rank () const
OpenGLContext * openglContext ()
Returns the OpenGL context to which this UIEventListener is bound or NULL if no context is bound.
virtual void | setEnabled (bool enabled)
Enables or disables a UIEventListener.
virtual void | prepareToReconnect ()
Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.
bool | isEnabled () const
bool | operator< (const UIEventListener &other) const

Protected Attributes

OpenGLContext * mOpenGLContext
int | mRank
bool | mEnabled

Friends

class | OpenGLContext

Detailed Description

The UIEventListener class listens to the events emitted by an OpenGLContext.

Remarks:
  • Qt amongst others does not distinguish between left and right alt, shift and control keys, which means that you won't receive messages like Key_LeftCtrl, Key_RightCtrl, Key_LeftAlt, Key_RightAlt, Key_LeftShift and Key_RightShift but only the more general Key_Ctrl, Key_Alt and Key_Shift messages.
  • SDL supports Unicode only partially at the moment, which means that you will receive Unicode codes only for key press events and not for release events.
  • keyPressed() returns the correct state only for the keys whose messages have been received by the OpenGLContext. This means that for example if a key was pressed when the BanckendAdaper did not have the keyboard focus, the function keyPressed() will wrongly report a released state for that key. If a key release event is not sent to the OpenGLContext because generated when the OpenGLContext did not have the keyboard focus, the function keyPressed() will wrongly report a pressed state for that key.

Constructor & Destructor Documentation

vl::UIEventListener::UIEventListener ( ) [inline]

virtual vl::UIEventListener::~UIEventListener ( ) [inline, virtual]

Member Function Documentation

virtual const char* vl::UIEventListener::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::GhostCameraManipulator, vl::TrackballManipulator, and vlut::Applet.

virtual void vl::UIEventListener::initEvent ( ) [inline, virtual]

Reimplemented in vlut::Applet.

virtual void vl::UIEventListener::mouseMoveEvent | ( | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vl::GhostCameraManipulator, and vl::TrackballManipulator.

virtual void vl::UIEventListener::mouseUpEvent | ( | EMouseButton | ,
 |  | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vl::TrackballManipulator.

virtual void vl::UIEventListener::mouseDownEvent | ( | EMouseButton | ,
 |  | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vl::TrackballManipulator.

virtual void vl::UIEventListener::mouseWheelEvent ( int ) [inline, virtual]

virtual void vl::UIEventListener::keyPressEvent | ( | unsigned | short,
 |  | EKey |  |
 | ) |  |  | [inline, virtual]

virtual void vl::UIEventListener::keyReleaseEvent | ( | unsigned | short,
 |  | EKey |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vlut::Applet.

virtual void vl::UIEventListener::resizeEvent | ( | int | ,
 |  | int |  |
 | ) |  |  | [inline, virtual]

Reimplemented in vlut::Applet.

virtual void vl::UIEventListener::destroyEvent ( ) [inline, virtual]

Reimplemented in vlut::Applet.

virtual void vl::UIEventListener::runEvent ( ) [inline, virtual]

Reimplemented in vl::GhostCameraManipulator, and vlut::Applet.

virtual void vl::UIEventListener::visibilityEvent ( bool ) [inline, virtual]

virtual void vl::UIEventListener::fileDroppedEvent ( const std::vector< String > & ) [inline, virtual]

virtual void vl::UIEventListener::openglContextBoundEvent ( OpenGLContext * ) [inline, virtual]

Reimplemented in vlut::Applet.

void UIEventListener::setRank ( int rank )

int UIEventListener::rank ( ) const

OpenGLContext * UIEventListener::openglContext ( )

Returns the OpenGL context to which this UIEventListener is bound or NULL if no context is bound.

virtual void vl::UIEventListener::setEnabled ( bool enabled ) [inline, virtual]

Enables or disables a UIEventListener.

Note:
When an UIEventListener is enabled its prepareToReconnect() method is called so that it can be appropriately setup before it starts to receive events.

virtual void vl::UIEventListener::prepareToReconnect ( ) [inline, virtual]

Reimplement this in order to react to a setEnabled(true), see setEnabled() for more information.

Reimplemented in vl::GhostCameraManipulator, and vl::TrackballManipulator.

bool vl::UIEventListener::isEnabled ( ) const [inline]

bool vl::UIEventListener::operator< ( const UIEventListener & other ) const [inline]

Friends And Related Function Documentation

friend class OpenGLContext [friend]

Member Data Documentation

OpenGLContext* vl::UIEventListener::mOpenGLContext [protected]

int vl::UIEventListener::mRank [protected]

bool vl::UIEventListener::mEnabled [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/UIEventListener.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::Uniform Class Reference

vl::Uniform

vl::Uniform Class Reference

Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram. More...

#include <Uniform.hpp>

Inheritance diagram for vl::Uniform:

vl::Object

List of all members.

Public Types

enum EUniformType {
NONE = 0x0, UT_Float, UT_Float2, UT_Float3,
UT_Float4, UT_Int, UT_Int2, UT_Int3,
UT_Int4, UT_UInt, UT_UInt2, UT_UInt3,
UT_UInt4, UT_Mat2, UT_Mat3, UT_Mat4,
UT_Mat2x3, UT_Mat3x2, UT_Mat2x4, UT_Mat4x2,
UT_Mat3x4, UT_Mat4x3
}

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Uniform ()
Uniform (const std::string &name)
void | setUniform1i (int count, const int *value)
void | setUniform2i (int count, const int *value)
void | setUniform3i (int count, const int *value)
void | setUniform4i (int count, const int *value)
void | setUniform1ui (int count, const unsigned int *value)
void | setUniform2ui (int count, const unsigned int *value)
void | setUniform3ui (int count, const unsigned int *value)
void | setUniform4ui (int count, const unsigned int *value)
void | setUniform1f (int count, const float *value)
void | setUniform2f (int count, const float *value)
void | setUniform3f (int count, const float *value)
void | setUniform4f (int count, const float *value)
void | setUniformMatrix2f (int count, const float *value)
void | setUniformMatrix3f (int count, const float *value)
void | setUniformMatrix4f (int count, const float *value)
void | setUniformMatrix2x3f (int count, const float *value)
void | setUniformMatrix3x2f (int count, const float *value)
void | setUniformMatrix2x4f (int count, const float *value)
void | setUniformMatrix4x2f (int count, const float *value)
void | setUniformMatrix3x4f (int count, const float *value)
void | setUniformMatrix4x3f (int count, const float *value)
void | setUniform (int count, const ivec2 *value)
void | setUniform (int count, const ivec3 *value)
void | setUniform (int count, const ivec4 *value)
void | setUniform (int count, const uvec2 *value)
void | setUniform (int count, const uvec3 *value)
void | setUniform (int count, const uvec4 *value)
void | setUniform (int count, const fvec2 *value)
void | setUniform (int count, const fvec3 *value)
void | setUniform (int count, const fvec4 *value)
void | setUniform (int count, const fmat2 *value)
void | setUniform (int count, const fmat3 *value)
void | setUniform (int count, const fmat4 *value)
void | setUniform (const int &value)
void | setUniform (const ivec2 &value)
void | setUniform (const ivec3 &value)
void | setUniform (const ivec4 &value)
void | setUniform (const unsigned int &value)
void | setUniform (const uvec2 &value)
void | setUniform (const uvec3 &value)
void | setUniform (const uvec4 &value)
void | setUniform (const float &value)
void | setUniform (const fvec2 &value)
void | setUniform (const fvec3 &value)
void | setUniform (const fvec4 &value)
void | setUniform (const fmat2 &value)
void | setUniform (const fmat3 &value)
void | setUniform (const fmat4 &value)
void | getUniform (float *value)
void | getUniform (int *value)
void | getUniform (unsigned int *value)
void | getUniform (ivec2 *value)
void | getUniform (ivec3 *value)
void | getUniform (ivec4 *value)
void | getUniform (uvec2 *value)
void | getUniform (uvec3 *value)
void | getUniform (uvec4 *value)
void | getUniform (fvec2 *value)
void | getUniform (fvec3 *value)
void | getUniform (fvec4 *value)
void | getUniform (fmat2 *value)
void | getUniform (fmat3 *value)
void | getUniform (fmat4 *value)
EUniformType | type () const
int | count () const

Protected Member Functions

void | initFloat (int count)
void | initInt (int count)
void | initUInt (int count)

Protected Attributes

std::vector< float > | mFloatData
std::vector< int > | mIntData
std::vector< unsigned int > | mUIntData
EUniformType mType

Friends

class | GLSLProgram

Detailed Description

Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram.

See also:
  • GLSLProgram
  • Shader
  • Actor
  • UniformSet

Member Enumeration Documentation

enum vl::Uniform::EUniformType

Enumerator:
NONE
UT_Float
UT_Float2
UT_Float3
UT_Float4
UT_Int
UT_Int2
UT_Int3
UT_Int4
UT_UInt
UT_UInt2
UT_UInt3
UT_UInt4
UT_Mat2
UT_Mat3
UT_Mat4
UT_Mat2x3
UT_Mat3x2
UT_Mat2x4
UT_Mat4x2
UT_Mat3x4
UT_Mat4x3

Constructor & Destructor Documentation

vl::Uniform::Uniform ( ) [inline]

vl::Uniform::Uniform ( const std::string & name ) [inline]

Member Function Documentation

virtual const char* vl::Uniform::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::Uniform::setUniform1i | ( | int | count,
 |  | const int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform2i | ( | int | count,
 |  | const int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform3i | ( | int | count,
 |  | const int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform4i | ( | int | count,
 |  | const int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform1ui | ( | int | count,
 |  | const unsigned int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform2ui | ( | int | count,
 |  | const unsigned int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform3ui | ( | int | count,
 |  | const unsigned int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform4ui | ( | int | count,
 |  | const unsigned int * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform1f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform2f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform3f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform4f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix2f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix3f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix4f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix2x3f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix3x2f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix2x4f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix4x2f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix3x4f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniformMatrix4x3f | ( | int | count,
 |  | const float * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const ivec2 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const ivec3 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const ivec4 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const uvec2 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const uvec3 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const uvec4 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fvec2 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fvec3 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fvec4 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fmat2 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fmat3 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform | ( | int | count,
 |  | const fmat4 * | value |
 | ) |  |  | [inline]

void vl::Uniform::setUniform ( const int & value ) [inline]

void vl::Uniform::setUniform ( const ivec2 & value ) [inline]

void vl::Uniform::setUniform ( const ivec3 & value ) [inline]

void vl::Uniform::setUniform ( const ivec4 & value ) [inline]

void vl::Uniform::setUniform ( const unsigned int & value ) [inline]

void vl::Uniform::setUniform ( const uvec2 & value ) [inline]

void vl::Uniform::setUniform ( const uvec3 & value ) [inline]

void vl::Uniform::setUniform ( const uvec4 & value ) [inline]

void vl::Uniform::setUniform ( const float & value ) [inline]

void vl::Uniform::setUniform ( const fvec2 & value ) [inline]

void vl::Uniform::setUniform ( const fvec3 & value ) [inline]

void vl::Uniform::setUniform ( const fvec4 & value ) [inline]

void vl::Uniform::setUniform ( const fmat2 & value ) [inline]

void vl::Uniform::setUniform ( const fmat3 & value ) [inline]

void vl::Uniform::setUniform ( const fmat4 & value ) [inline]

void vl::Uniform::getUniform ( float * value ) [inline]

void vl::Uniform::getUniform ( int * value ) [inline]

void vl::Uniform::getUniform ( unsigned int * value ) [inline]

void vl::Uniform::getUniform ( ivec2 * value ) [inline]

void vl::Uniform::getUniform ( ivec3 * value ) [inline]

void vl::Uniform::getUniform ( ivec4 * value ) [inline]

void vl::Uniform::getUniform ( uvec2 * value ) [inline]

void vl::Uniform::getUniform ( uvec3 * value ) [inline]

void vl::Uniform::getUniform ( uvec4 * value ) [inline]

void vl::Uniform::getUniform ( fvec2 * value ) [inline]

void vl::Uniform::getUniform ( fvec3 * value ) [inline]

void vl::Uniform::getUniform ( fvec4 * value ) [inline]

void vl::Uniform::getUniform ( fmat2 * value ) [inline]

void vl::Uniform::getUniform ( fmat3 * value ) [inline]

void vl::Uniform::getUniform ( fmat4 * value ) [inline]

EUniformType vl::Uniform::type ( ) const [inline]

int vl::Uniform::count ( ) const [inline]

void vl::Uniform::initFloat ( int count ) [inline, protected]

void vl::Uniform::initInt ( int count ) [inline, protected]

void vl::Uniform::initUInt ( int count ) [inline, protected]

Friends And Related Function Documentation

friend class GLSLProgram [friend]

Member Data Documentation

std::vector<float> vl::Uniform::mFloatData [protected]

std::vector<int> vl::Uniform::mIntData [protected]

std::vector<unsigned int> vl::Uniform::mUIntData [protected]

EUniformType vl::Uniform::mType [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Uniform.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::UniformSet Class Reference

vl::UniformSet

vl::UniformSet Class Reference

A set of Uniform objects managed by a Shader. More...

#include <Uniform.hpp>

Inheritance diagram for vl::UniformSet:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
UniformSet ()
void | setUniform (Uniform *uniform, bool check_for_doubles=true)
const std::vector< ref
< Uniform > > & 		uniforms () const
void | eraseUniform (const std::string &name)
void | eraseUniform (const Uniform *uniform)
void | eraseAllUniforms ()
Uniform * | gocUniform (const std::string &name)
Uniform * | getUniform (const std::string &name)
const Uniform * | getUniform (const std::string &name) const

Protected Attributes

std::vector< ref< Uniform > > | mUniforms

Detailed Description

A set of Uniform objects managed by a Shader.

See also:
Shader, Effect, Actor

Constructor & Destructor Documentation

vl::UniformSet::UniformSet ( ) [inline]

Member Function Documentation

virtual const char* vl::UniformSet::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vl::UniformSet::setUniform | ( | Uniform * | uniform,
 |  | bool | check_for_doubles = true |
 | ) |  |  | [inline]

const std::vector< ref<Uniform> >& vl::UniformSet::uniforms ( ) const [inline]

void vl::UniformSet::eraseUniform ( const std::string & name ) [inline]

void vl::UniformSet::eraseUniform ( const Uniform * uniform ) [inline]

void vl::UniformSet::eraseAllUniforms ( ) [inline]

Uniform* vl::UniformSet::gocUniform ( const std::string & name ) [inline]

Uniform* vl::UniformSet::getUniform ( const std::string & name ) [inline]

const Uniform* vl::UniformSet::getUniform ( const std::string & name ) const [inline]

Member Data Documentation

std::vector< ref<Uniform> > vl::UniformSet::mUniforms [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Uniform.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::Vector2< scalar_type > Class Template Reference

vl::Vector2

vl::Vector2< scalar_type > Class Template Reference

The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2. More...

#include <Vector2.hpp>

List of all members.

Public Member Functions

Vector2 (const Vector2 &other)
Vector2 ()
template<class T >
Vector2 (const T &other)
Vector2 (scalar_type x, scalar_type y)
scalar_type * | ptr ()
const scalar_type * | ptr () const
const scalar_type & | x () const
const scalar_type & | y () const
scalar_type & | x ()
scalar_type & | y ()
const scalar_type & | r () const
const scalar_type & | g () const
scalar_type & | r ()
scalar_type & | g ()
const scalar_type & | s () const
const scalar_type & | t () const
scalar_type & | s ()
scalar_type & | t ()
Vector2 | operator+ (const Vector2 &other) const
Vector2 | operator- (const Vector2 &other) const
Vector2 | operator* (const Vector2 &other) const
Vector2 | operator/ (const Vector2 &other) const
Vector2 | operator+ (scalar_type val) const
Vector2 | operator- (scalar_type val) const
Vector2 | operator* (scalar_type val) const
Vector2 | operator/ (scalar_type val) const
Vector2 | operator- () const
Vector2 & | operator+= (const Vector2 &other)
Vector2 & | operator-= (const Vector2 &other)
Vector2 & | operator*= (const Vector2 &other)
Vector2 & | operator/= (const Vector2 &other)
Vector2 & | operator+= (scalar_type val)
Vector2 & | operator-= (scalar_type val)
Vector2 & | operator*= (scalar_type val)
Vector2 & | operator/= (scalar_type val)
Vector2 & | operator= (const Vector2 &other)
Vector2 & | operator= (scalar_type val)
bool | operator== (const Vector2 &other) const
bool | operator!= (const Vector2 &other) const
bool | operator< (const Vector2 &other) const
scalar_type & | operator[] (unsigned i)
const scalar_type & | operator[] (unsigned i) const
scalar_type | length () const
scalar_type | lengthSquared () const
bool | isNull () const
const Vector2 & | normalize ()

Static Public Attributes

static const int | scalar_count = 2

Protected Attributes

scalar_type | mScalar [scalar_count]

Detailed Description

template<typename scalar_type>
class vl::Vector2< scalar_type >

The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2.

See also:
Vector4, Vector3, Matrix4, Matrix3, Matrix2

Constructor & Destructor Documentation

template<typename scalar_type>
vl::Vector2< scalar_type >::Vector2 ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
vl::Vector2< scalar_type >::Vector2 ( ) [inline]

template<typename scalar_type>
template<class T >
vl::Vector2< scalar_type >::Vector2 ( const T & other ) [inline, explicit]

template<typename scalar_type>
vl::Vector2< scalar_type >::Vector2 | ( | scalar_type | x,
 |  | scalar_type | y |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type>
scalar_type* vl::Vector2< scalar_type >::ptr ( ) [inline]

template<typename scalar_type>
const scalar_type* vl::Vector2< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::x ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::y ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::x ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::y ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::r ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::g ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::r ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::g ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::s ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::t ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::s ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::t ( ) [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator+ ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator- ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator* ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator/ ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator+ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator- ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator* ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator/ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector2 vl::Vector2< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator+= ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator-= ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator*= ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator/= ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator+= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator-= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator*= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator/= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator= ( const Vector2< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector2& vl::Vector2< scalar_type >::operator= ( scalar_type val ) [inline]

template<typename scalar_type>
bool vl::Vector2< scalar_type >::operator== ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector2< scalar_type >::operator!= ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector2< scalar_type >::operator< ( const Vector2< scalar_type > & other ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector2< scalar_type >::operator[] ( unsigned i ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector2< scalar_type >::operator[] ( unsigned i ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector2< scalar_type >::length ( ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector2< scalar_type >::lengthSquared ( ) const [inline]

template<typename scalar_type>
bool vl::Vector2< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type>
const Vector2& vl::Vector2< scalar_type >::normalize ( ) [inline]

Member Data Documentation

template<typename scalar_type>
const int vl::Vector2< scalar_type >::scalar_count = 2 [static]

template<typename scalar_type>
scalar_type vl::Vector2< scalar_type >::mScalar[scalar_count] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector2.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::Vector3< scalar_type > Class Template Reference

vl::Vector3

vl::Vector3< scalar_type > Class Template Reference

The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3. More...

#include <Vector3.hpp>

List of all members.

Public Member Functions

Vector3 (const Vector3 &other)
Vector3 ()
template<class T >
Vector3 (const T &other)
Vector3 (scalar_type x, scalar_type y, scalar_type z)
Vector3 (const Vector2< scalar_type > &v, scalar_type z)
scalar_type * | ptr ()
const scalar_type * | ptr () const
const scalar_type & | x () const
const scalar_type & | y () const
const scalar_type & | z () const
scalar_type & | x ()
scalar_type & | y ()
scalar_type & | z ()
const scalar_type & | r () const
const scalar_type & | g () const
const scalar_type & | b () const
scalar_type & | r ()
scalar_type & | g ()
scalar_type & | b ()
const scalar_type & | s () const
const scalar_type & | t () const
const scalar_type & | p () const
scalar_type & | s ()
scalar_type & | t ()
scalar_type & | p ()
Vector2< scalar_type > | xy () const
Vector2< scalar_type > | st () const
Vector3 | operator+ (const Vector3 &other) const
Vector3 | operator- (const Vector3 &other) const
Vector3 | operator* (const Vector3 &other) const
Vector3 | operator/ (const Vector3 &other) const
Vector3 | operator+ (scalar_type val) const
Vector3 | operator- (scalar_type val) const
Vector3 | operator* (scalar_type val) const
Vector3 | operator/ (scalar_type val) const
Vector3 | operator- () const
Vector3 & | operator+= (const Vector3 &other)
Vector3 & | operator-= (const Vector3 &other)
Vector3 & | operator*= (const Vector3 &other)
Vector3 & | operator/= (const Vector3 &other)
Vector3 & | operator+= (scalar_type val)
Vector3 & | operator-= (scalar_type val)
Vector3 & | operator*= (scalar_type val)
Vector3 & | operator/= (scalar_type val)
Vector3 & | operator= (const Vector3 &other)
Vector3 & | operator= (scalar_type val)
bool | operator== (const Vector3 &other) const
bool | operator!= (const Vector3 &other) const
bool | operator< (const Vector3 &other) const
scalar_type & | operator[] (unsigned i)
const scalar_type & | operator[] (unsigned i) const
scalar_type | length () const
scalar_type | lengthSquared () const
bool | isNull () const
const Vector3 & | normalize ()

Static Public Attributes

static const int | scalar_count = 3

Protected Attributes

scalar_type | mScalar [scalar_count]

Detailed Description

template<typename scalar_type>
class vl::Vector3< scalar_type >

The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3.

See also:
Vector4, Vector2, Matrix4, Matrix3, Matrix2

Constructor & Destructor Documentation

template<typename scalar_type>
vl::Vector3< scalar_type >::Vector3 ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
vl::Vector3< scalar_type >::Vector3 ( ) [inline]

template<typename scalar_type>
template<class T >
vl::Vector3< scalar_type >::Vector3 ( const T & other ) [inline, explicit]

template<typename scalar_type>
vl::Vector3< scalar_type >::Vector3 | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z |
 | ) |  |  | [inline, explicit]

template<typename scalar_type>
vl::Vector3< scalar_type >::Vector3 | ( | const Vector2< scalar_type > & | v,
 |  | scalar_type | z |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type>
scalar_type* vl::Vector3< scalar_type >::ptr ( ) [inline]

template<typename scalar_type>
const scalar_type* vl::Vector3< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::x ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::y ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::z ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::x ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::y ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::z ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::r ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::g ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::b ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::r ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::g ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::b ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::s ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::t ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::p ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::s ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::t ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::p ( ) [inline]

template<typename scalar_type>
Vector2<scalar_type> vl::Vector3< scalar_type >::xy ( ) const [inline]

template<typename scalar_type>
Vector2<scalar_type> vl::Vector3< scalar_type >::st ( ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator+ ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator- ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator* ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator/ ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator+ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator- ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator* ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator/ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector3 vl::Vector3< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator+= ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator-= ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator*= ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator/= ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator+= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator-= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator*= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator/= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator= ( const Vector3< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector3& vl::Vector3< scalar_type >::operator= ( scalar_type val ) [inline]

template<typename scalar_type>
bool vl::Vector3< scalar_type >::operator== ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector3< scalar_type >::operator!= ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector3< scalar_type >::operator< ( const Vector3< scalar_type > & other ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector3< scalar_type >::operator[] ( unsigned i ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector3< scalar_type >::operator[] ( unsigned i ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector3< scalar_type >::length ( ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector3< scalar_type >::lengthSquared ( ) const [inline]

template<typename scalar_type>
bool vl::Vector3< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type>
const Vector3& vl::Vector3< scalar_type >::normalize ( ) [inline]

Member Data Documentation

template<typename scalar_type>
const int vl::Vector3< scalar_type >::scalar_count = 3 [static]

template<typename scalar_type>
scalar_type vl::Vector3< scalar_type >::mScalar[scalar_count] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector3.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::Vector4< scalar_type > Class Template Reference

vl::Vector4

vl::Vector4< scalar_type > Class Template Reference

The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4. More...

#include <Vector4.hpp>

List of all members.

Public Member Functions

Vector4 (const Vector4 &other)
Vector4 ()
template<class T >
Vector4 (const T &other)
Vector4 (scalar_type x, scalar_type y, scalar_type z, scalar_type w)
Vector4 (const Vector3< scalar_type > &v, scalar_type w)
Vector4 (const Vector2< scalar_type > &u, const Vector2< scalar_type > &v)
scalar_type * | ptr ()
const scalar_type * | ptr () const
const scalar_type & | x () const
const scalar_type & | y () const
const scalar_type & | z () const
const scalar_type & | w () const
scalar_type & | x ()
scalar_type & | y ()
scalar_type & | z ()
scalar_type & | w ()
const scalar_type & | r () const
const scalar_type & | g () const
const scalar_type & | b () const
const scalar_type & | a () const
scalar_type & | r ()
scalar_type & | g ()
scalar_type & | b ()
scalar_type & | a ()
const scalar_type & | s () const
const scalar_type & | t () const
const scalar_type & | p () const
const scalar_type & | q () const
scalar_type & | s ()
scalar_type & | t ()
scalar_type & | p ()
scalar_type & | q ()
Vector3< scalar_type > | xyz () const
Vector3< scalar_type > | rgb () const
Vector3< scalar_type > | stp () const
Vector2< scalar_type > | xy () const
Vector2< scalar_type > | rg () const
Vector2< scalar_type > | st () const
Vector4 | operator+ (const Vector4 &other) const
Vector4 | operator- (const Vector4 &other) const
Vector4 | operator* (const Vector4 &other) const
Vector4 | operator/ (const Vector4 &other) const
Vector4 | operator+ (scalar_type val) const
Vector4 | operator- (scalar_type val) const
Vector4 | operator* (scalar_type val) const
Vector4 | operator/ (scalar_type val) const
Vector4 | operator- () const
Vector4 & | operator+= (const Vector4 &other)
Vector4 & | operator-= (const Vector4 &other)
Vector4 & | operator*= (const Vector4 &other)
Vector4 & | operator/= (const Vector4 &other)
Vector4 & | operator+= (scalar_type val)
Vector4 & | operator-= (scalar_type val)
Vector4 & | operator*= (scalar_type val)
Vector4 & | operator/= (scalar_type val)
Vector4 & | operator= (const Vector4 &other)
Vector4 & | operator= (scalar_type val)
bool | operator== (const Vector4 &other) const
bool | operator!= (const Vector4 &other) const
bool | operator< (const Vector4 &other) const
scalar_type & | operator[] (unsigned i)
const scalar_type & | operator[] (unsigned i) const
scalar_type | length () const
scalar_type | lengthSquared () const
bool | isNull () const
const Vector4 & | normalize ()

Static Public Attributes

static const int | scalar_count = 4

Protected Attributes

scalar_type | mScalar [scalar_count]

Detailed Description

template<typename scalar_type>
class vl::Vector4< scalar_type >

The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4.

See also:
Vector3, Vector2, Matrix4, Matrix3, Matrix2

Constructor & Destructor Documentation

template<typename scalar_type>
vl::Vector4< scalar_type >::Vector4 ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
vl::Vector4< scalar_type >::Vector4 ( ) [inline]

template<typename scalar_type>
template<class T >
vl::Vector4< scalar_type >::Vector4 ( const T & other ) [inline, explicit]

template<typename scalar_type>
vl::Vector4< scalar_type >::Vector4 | ( | scalar_type | x,
 |  | scalar_type | y,
 |  | scalar_type | z,
 |  | scalar_type | w |
 | ) |  |  | [inline, explicit]

template<typename scalar_type>
vl::Vector4< scalar_type >::Vector4 | ( | const Vector3< scalar_type > & | v,
 |  | scalar_type | w |
 | ) |  |  | [inline, explicit]

template<typename scalar_type>
vl::Vector4< scalar_type >::Vector4 | ( | const Vector2< scalar_type > & | u,
 |  | const Vector2< scalar_type > & | v |
 | ) |  |  | [inline, explicit]

Member Function Documentation

template<typename scalar_type>
scalar_type* vl::Vector4< scalar_type >::ptr ( ) [inline]

template<typename scalar_type>
const scalar_type* vl::Vector4< scalar_type >::ptr ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::x ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::y ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::z ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::w ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::x ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::y ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::z ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::w ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::r ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::g ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::b ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::a ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::r ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::g ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::b ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::a ( ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::s ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::t ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::p ( ) const [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::q ( ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::s ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::t ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::p ( ) [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::q ( ) [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Vector4< scalar_type >::xyz ( ) const [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Vector4< scalar_type >::rgb ( ) const [inline]

template<typename scalar_type>
Vector3<scalar_type> vl::Vector4< scalar_type >::stp ( ) const [inline]

template<typename scalar_type>
Vector2<scalar_type> vl::Vector4< scalar_type >::xy ( ) const [inline]

template<typename scalar_type>
Vector2<scalar_type> vl::Vector4< scalar_type >::rg ( ) const [inline]

template<typename scalar_type>
Vector2<scalar_type> vl::Vector4< scalar_type >::st ( ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator+ ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator- ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator* ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator/ ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator+ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator- ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator* ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator/ ( scalar_type val ) const [inline]

template<typename scalar_type>
Vector4 vl::Vector4< scalar_type >::operator- ( ) const [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator+= ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator-= ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator*= ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator/= ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator+= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator-= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator*= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator/= ( scalar_type val ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator= ( const Vector4< scalar_type > & other ) [inline]

template<typename scalar_type>
Vector4& vl::Vector4< scalar_type >::operator= ( scalar_type val ) [inline]

template<typename scalar_type>
bool vl::Vector4< scalar_type >::operator== ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector4< scalar_type >::operator!= ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
bool vl::Vector4< scalar_type >::operator< ( const Vector4< scalar_type > & other ) const [inline]

template<typename scalar_type>
scalar_type& vl::Vector4< scalar_type >::operator[] ( unsigned i ) [inline]

template<typename scalar_type>
const scalar_type& vl::Vector4< scalar_type >::operator[] ( unsigned i ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector4< scalar_type >::length ( ) const [inline]

template<typename scalar_type>
scalar_type vl::Vector4< scalar_type >::lengthSquared ( ) const [inline]

template<typename scalar_type>
bool vl::Vector4< scalar_type >::isNull ( ) const [inline]

template<typename scalar_type>
const Vector4& vl::Vector4< scalar_type >::normalize ( ) [inline]

Member Data Documentation

template<typename scalar_type>
const int vl::Vector4< scalar_type >::scalar_count = 4 [static]

template<typename scalar_type>
scalar_type vl::Vector4< scalar_type >::mScalar[scalar_count] [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector4.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: vl::VertexAttributeArray Class Reference

vl::VertexAttributeArray

vl::VertexAttributeArray Class Reference

Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry. More...

#include <VertexAttributeArray.hpp>

Inheritance diagram for vl::VertexAttributeArray:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
VertexAttributeArray (unsigned int location, bool normalize, bool pure_integer, ArrayAbstract *data)
VertexAttributeArray ()
ArrayAbstract * | data () const
The GPU buffer that stores the data.
unsigned int | attribIndex () const
The 'index' parameter of the vertex attribute as used with glVertexAttribPointer() and glEnableVertexAttribArray().
bool | normalize () const
The 'normalized' parameter as used with glVertexAttribPointer().
bool | pureInteger () const
If set to true glVertexAttribIPointer() will be used instead of glVertexAttribPointer().
void | setData (ArrayAbstract *data)
The GPU buffer that stores the data.
void | setAttribIndex (unsigned int index)
The 'index' parameter of the vertex attribute as used with glVertexAttribPointer() and glEnableVertexAttribArray().
void | setNormalize (bool normalize)
The 'normalized' parameter as used with glVertexAttribPointer().
void | setPureInteger (bool pure_integer)
If set to true glVertexAttribIPointer() will be used instead of glVertexAttribPointer().

Protected Attributes

ref< ArrayAbstract > mData
unsigned int | mAttribIndex
bool | mNormalize
bool | mPureInteger

Detailed Description

Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry.

Constructor & Destructor Documentation

vl::VertexAttributeArray::VertexAttributeArray | ( | unsigned int | location,
 |  | bool | normalize,
 |  | bool | pure_integer,
 |  | ArrayAbstract * | data |
 | ) |  |  | [inline]

vl::VertexAttributeArray::VertexAttributeArray ( ) [inline]

Member Function Documentation

virtual const char* vl::VertexAttributeArray::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

ArrayAbstract* vl::VertexAttributeArray::data ( ) const [inline]

The GPU buffer that stores the data.

unsigned int vl::VertexAttributeArray::attribIndex ( ) const [inline]

The 'index' parameter of the vertex attribute as used with glVertexAttribPointer() and glEnableVertexAttribArray().

See also:
  • http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
  • http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml

bool vl::VertexAttributeArray::normalize ( ) const [inline]

The 'normalized' parameter as used with glVertexAttribPointer().

See also:
  • http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml

bool vl::VertexAttributeArray::pureInteger ( ) const [inline]

If set to true glVertexAttribIPointer() will be used instead of glVertexAttribPointer().

This feature requires GL_EXT_gpu_shader4.

See also:
  • http://developer.download.nvidia.com/opengl/specs/GL_EXT_gpu_shader4.txt

void vl::VertexAttributeArray::setData ( ArrayAbstract * data ) [inline]

The GPU buffer that stores the data.

void vl::VertexAttributeArray::setAttribIndex ( unsigned int index ) [inline]

The 'index' parameter of the vertex attribute as used with glVertexAttribPointer() and glEnableVertexAttribArray().

See also:
  • http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
  • http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml

void vl::VertexAttributeArray::setNormalize ( bool normalize ) [inline]

The 'normalized' parameter as used with glVertexAttribPointer().

See also:
  • http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml

void vl::VertexAttributeArray::setPureInteger ( bool pure_integer ) [inline]

If set to true glVertexAttribIPointer() will be used instead of glVertexAttribPointer().

This feature requires GL_EXT_gpu_shader4.

See also:
  • http://developer.download.nvidia.com/opengl/specs/GL_EXT_gpu_shader4.txt

Member Data Documentation

ref<ArrayAbstract> vl::VertexAttributeArray::mData [protected]

unsigned int vl::VertexAttributeArray::mAttribIndex [protected]

bool vl::VertexAttributeArray::mNormalize [protected]

bool vl::VertexAttributeArray::mPureInteger [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VertexAttributeArray.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::VertexMapper Class Reference

vl::VertexMapper

vl::VertexMapper Class Reference

Generates a set of new vertices from the old one. More...

#include <DoubleVertexRemover.hpp>

Inheritance diagram for vl::VertexMapper:

vl::Object vl::DoubleVertexRemover

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ref< ArrayAbstract > | regenerate (ArrayAbstract *data, const std::vector< unsigned int > &map_new_to_old) const
Regenerates a new Array based on the given mapping.

Detailed Description

Generates a set of new vertices from the old one.

Member Function Documentation

virtual const char* vl::VertexMapper::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::DoubleVertexRemover.

ref< ArrayAbstract > VertexMapper::regenerate | ( | ArrayAbstract * | data,
 |  | const std::vector< unsigned int > & | map_new_to_old |
 | ) |  |  | const

Regenerates a new Array based on the given mapping.

data The array to be regenerated map_new_to_old Specifies the mapping from the old vetices to the new one. The i-th vertex of the new vertex array will use the map_new_to_old[i]-th vertex of the old array, that is, map_new_to_old[i] specifies the old vertex to be used to generate the new i-th vertex.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: vl::Viewport Class Reference

vl::Viewport

vl::Viewport Class Reference

Implements the viewport and clearing settings associated to a Camera. More...

#include <Viewport.hpp>

Inheritance diagram for vl::Viewport:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Viewport ()
Viewport (int x, int y, int w, int h)
void | activate () const
bool | null ()
void | set (int x, int y, int w, int h)
void | setX (int x)
int | x () const
void | setY (int y)
int | y () const
void | setWidth (int width)
int | width () const
void | setHeight (int height)
int | height () const
fvec2 | center () const
RectI | rect () const
Returns the rectangular area that defines the viewport computed as RectI(x(), y(), x()+width()-1, y()+height()-1).
void | setClearColor (float r, float g, float b, float a)
void | setClearColor (const fvec4 &color)
const fvec4 & | clearColor () const
void | setClearColorInt (int r, int g, int b, int a)
void | setClearColorInt (const ivec4 &color)
const ivec4 & | clearColorInt () const
void | setClearColorUInt (unsigned int r, unsigned int g, unsigned int b, unsigned int a)
void | setClearColorUInt (const uvec4 &color)
const uvec4 & | clearColorUInt () const
void | setClearStencil (int stencil)
int | clearStencil () const
void | setClearDepth (Real depth)
Real | clearDepth () const
void | setClearFlags (EClearFlags clear_flags)
EClearFlags | clearFlags () const
void | setClearColorMode (EClearColorMode mode)
EClearColorMode | clearColorMode () const
bool | isPointInside (int x, int y, int render_target_height) const
Returns true if the given point is inside the Viewport.

Protected Attributes

fvec4 mClearColor
ivec4 mClearColorInt
uvec4 mClearColorUInt
Real mClearDepth
int | mClearStencil
EClearFlags mClearFlags
EClearColorMode mClearColorMode
int | mX
int | mY
int | mWidth
int | mHeight

Detailed Description

Implements the viewport and clearing settings associated to a Camera.

Supports glClearColor, glClearColorIiEXT and glClearColorIuiEXT (see GL_EXT_texture_integer).

See also:
Camera, Rendering, Renderer

Constructor & Destructor Documentation

Viewport::Viewport ( )

Viewport::Viewport | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h
 | ) |  |

Member Function Documentation

virtual const char* vl::Viewport::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void Viewport::activate ( ) const

bool vl::Viewport::null ( ) [inline]

void vl::Viewport::set | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h |
 | ) |  |  | [inline]

void vl::Viewport::setX ( int x ) [inline]

int vl::Viewport::x ( ) const [inline]

void vl::Viewport::setY ( int y ) [inline]

int vl::Viewport::y ( ) const [inline]

void vl::Viewport::setWidth ( int width ) [inline]

int vl::Viewport::width ( ) const [inline]

void vl::Viewport::setHeight ( int height ) [inline]

int vl::Viewport::height ( ) const [inline]

fvec2 vl::Viewport::center ( ) const [inline]

RectI vl::Viewport::rect ( ) const [inline]

Returns the rectangular area that defines the viewport computed as RectI(x(), y(), x()+width()-1, y()+height()-1).

void vl::Viewport::setClearColor | ( | float | r,
 |  | float | g,
 |  | float | b,
 |  | float | a |
 | ) |  |  | [inline]

void vl::Viewport::setClearColor ( const fvec4 & color ) [inline]

const fvec4& vl::Viewport::clearColor ( ) const [inline]

void vl::Viewport::setClearColorInt | ( | int | r,
 |  | int | g,
 |  | int | b,
 |  | int | a |
 | ) |  |  | [inline]

void vl::Viewport::setClearColorInt ( const ivec4 & color ) [inline]

const ivec4& vl::Viewport::clearColorInt ( ) const [inline]

void vl::Viewport::setClearColorUInt | ( | unsigned int | r,
 |  | unsigned int | g,
 |  | unsigned int | b,
 |  | unsigned int | a |
 | ) |  |  | [inline]

void vl::Viewport::setClearColorUInt ( const uvec4 & color ) [inline]

const uvec4& vl::Viewport::clearColorUInt ( ) const [inline]

void vl::Viewport::setClearStencil ( int stencil ) [inline]

int vl::Viewport::clearStencil ( ) const [inline]

void vl::Viewport::setClearDepth ( Real depth ) [inline]

Real vl::Viewport::clearDepth ( ) const [inline]

void vl::Viewport::setClearFlags ( EClearFlags clear_flags ) [inline]

EClearFlags vl::Viewport::clearFlags ( ) const [inline]

void vl::Viewport::setClearColorMode ( EClearColorMode mode ) [inline]

EClearColorMode vl::Viewport::clearColorMode ( ) const [inline]

bool Viewport::isPointInside | ( | int | x,
 |  | int | y,
 |  | int | render_target_height |
 | ) |  |  | const

Returns true if the given point is inside the Viewport.

Member Data Documentation

fvec4 vl::Viewport::mClearColor [protected]

ivec4 vl::Viewport::mClearColorInt [protected]

uvec4 vl::Viewport::mClearColorUInt [protected]

Real vl::Viewport::mClearDepth [protected]

int vl::Viewport::mClearStencil [protected]

EClearFlags vl::Viewport::mClearFlags [protected]

EClearColorMode vl::Viewport::mClearColorMode [protected]

int vl::Viewport::mX [protected]

int vl::Viewport::mY [protected]

int vl::Viewport::mWidth [protected]

int vl::Viewport::mHeight [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::VirtualDirectory Class Reference

vl::VirtualDirectory

vl::VirtualDirectory Class Reference

Abstact class representing a directory of files. More...

#include <VirtualDirectory.hpp>

Inheritance diagram for vl::VirtualDirectory:

vl::Object vl::DiskDirectory vl::MemoryDirectory vl::ZippedDirectory

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
VirtualDirectory (const String &path="/")
Constructor.
virtual bool | setPath (const String &path)
Changes the path name of a VirtualDirectory. Must not be an empty string.
virtual const String & | path () const
bool | fileExists (const String &name) const
Checks the existence of a file in the directory.
virtual ref< VirtualFile > | file (const String &name) const =0
Returns the VirtualFile with the given name if any, NULL otherwise.
virtual void | listFilesRecursive (std::vector< String > &file_list) const =0
Returns the list of files contained in the VirtualDirectory.
virtual void | listFilesRecursive (std::vector< String > &file_list, const String &match) const
Returns the list of files contained in the VirtualDirectory that match the expression 'match'.
virtual void | listFiles (std::vector< String > &file_list, bool append=false) const =0
virtual void | listSubDirs (std::vector< String > &dirs, bool append=false) const =0
virtual ref< VirtualDirectory > | subDir (const String &subdir_name) const =0

Protected Member Functions

String | translatePath (const String &p) const

Protected Attributes

String mPath

Detailed Description

Abstact class representing a directory of files.

See also:
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

vl::VirtualDirectory::VirtualDirectory ( const String & path = "/" ) [inline]

Constructor.

Parameters:
path Defines the path name of the virtual dirctory, must be a non empty string.

Member Function Documentation

virtual const char* vl::VirtualDirectory::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

bool VirtualDirectory::setPath ( const String & path ) [virtual]

Changes the path name of a VirtualDirectory. Must not be an empty string.

Reimplemented in vl::MemoryDirectory, and vl::ZippedDirectory.

virtual const String& vl::VirtualDirectory::path ( ) const [inline, virtual]

bool vl::VirtualDirectory::fileExists ( const String & name ) const [inline]

Checks the existence of a file in the directory.

virtual ref<VirtualFile> vl::VirtualDirectory::file ( const String & name ) const [pure virtual]

Returns the VirtualFile with the given name if any, NULL otherwise.

Implemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

virtual void vl::VirtualDirectory::listFilesRecursive ( std::vector< String > & file_list ) const [pure virtual]

Returns the list of files contained in the VirtualDirectory.

If there are subdirectories the files will be searched recursively.

Implemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

virtual void vl::VirtualDirectory::listFilesRecursive | ( | std::vector< String > & | file_list,
 |  | const String & | match |
 | ) |  |  | const [inline, virtual]

Returns the list of files contained in the VirtualDirectory that match the expression 'match'.

The match parameter must be of the type "*abc" or "*abc*" or "abc*" or "*".

virtual void vl::VirtualDirectory::listFiles | ( | std::vector< String > & | file_list,
 |  | bool | append = false |
 | ) |  |  | const [pure virtual]

Implemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

virtual void vl::VirtualDirectory::listSubDirs | ( | std::vector< String > & | dirs,
 |  | bool | append = false |
 | ) |  |  | const [pure virtual]

Implemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

virtual ref<VirtualDirectory> vl::VirtualDirectory::subDir ( const String & subdir_name ) const [pure virtual]

Implemented in vl::DiskDirectory, vl::MemoryDirectory, and vl::ZippedDirectory.

String VirtualDirectory::translatePath ( const String & p ) const [protected]

Member Data Documentation

String vl::VirtualDirectory::mPath [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::VirtualFile Class Reference

vl::VirtualFile

vl::VirtualFile Class Reference

An abstract class representing a file. More...

#include <VirtualFile.hpp>

Inheritance diagram for vl::VirtualFile:

vl::Object vl::DiskFile vl::GZipCodec vl::MemoryFile vl::ZippedFile

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
VirtualFile ()
~VirtualFile ()
unsigned int | crc32 ()
MD5CheckSum md5 ()
virtual bool | open (EOpenMode mode)=0
virtual bool | isOpen () const =0
virtual bool | exists () const =0
virtual void | close ()=0
virtual long long | size () const =0
virtual ref< VirtualFile > | clone () const =0
VirtualFile & | operator= (const VirtualFile &other)
const String & | path () const
void | setPath (const String &name)
Renames the file. Use carefully this function, you shouldn't rename a VirtualFile managed by a VirtualDirectory.
long long | peek (void *buffer, long long byte_count)
Reads byte_count bytes and returns to the original position.
long long | read (void *buffer, long long byte_count)
long long | write (const void *buffer, long long byte_count)
long long | position () const
bool | seekSet (long long offset)
bool | seekCur (long long offset)
bool | seekEnd (long long offset)
bool | endOfFile () const
long long | load (std::vector< unsigned char > &data)
Loads the entire file in the specified vector.
long long | load (void *buffer, long long max=-1)
Loads the entire file in the specified buffer.
float | readFloat (bool little_endian_data=true)
long long | readFloat (void *buffer, long long count)
double | readDouble (bool little_endian_data=true)
long long | readDouble (void *buffer, long long count)
unsigned char | readUByte ()
long long | readUByte (void *buffer, long long count)
char | readSByte ()
long long | readSByte (void *buffer, long long count)
unsigned long long | readUInt64 (bool little_endian_data=true)
long long | readUInt64 (void *buffer, long long count, bool little_endian_data=true)
long long | readSInt64 (bool little_endian_data=true)
long long | readSInt64 (void *buffer, long long count, bool little_endian_data=true)
unsigned int | readUInt32 (bool little_endian_data=true)
long long | readUInt32 (void *buffer, long long count, bool little_endian_data=true)
int | readSInt32 (bool little_endian_data=true)
long long | readSInt32 (void *buffer, long long count, bool little_endian_data=true)
unsigned short | readUInt16 (bool little_endian_data=true)
long long | readUInt16 (void *buffer, long long count, bool little_endian_data=true)
short | readSInt16 (bool little_endian_data=true)
long long | readSInt16 (void *buffer, long long count, bool little_endian_data=true)
long long | writeUInt32 (unsigned long data, bool little_endian=true)
long long | writeUInt16 (unsigned short data, bool little_endian=true)
long long | writeUInt8 (unsigned char data)
long long | writeSInt32 (long data, bool little_endian=true)
long long | writeSInt16 (short data, bool little_endian=true)
long long | writeSInt8 (char data)

Protected Member Functions

VirtualFile (const VirtualFile &other)
virtual long long | read_Implementation (void *buffer, long long byte_count)=0
virtual long long | write_Implementation (const void *buffer, long long byte_count)=0
virtual long long | position_Implementation () const =0
virtual bool | seekSet_Implementation (long long offset)=0

Protected Attributes

String mPath

Detailed Description

An abstract class representing a file.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • DiskFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

vl::VirtualFile::VirtualFile ( const VirtualFile & other ) [inline, protected]

vl::VirtualFile::VirtualFile ( ) [inline]

vl::VirtualFile::~VirtualFile ( ) [inline]

Member Function Documentation

virtual const char* vl::VirtualFile::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

Reimplemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

unsigned int VirtualFile::crc32 ( )

MD5CheckSum VirtualFile::md5 ( )

virtual bool vl::VirtualFile::open ( EOpenMode mode ) [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual bool vl::VirtualFile::isOpen ( ) const [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual bool vl::VirtualFile::exists ( ) const [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual void vl::VirtualFile::close ( ) [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual long long vl::VirtualFile::size ( ) const [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual ref<VirtualFile> vl::VirtualFile::clone ( ) const [pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

VirtualFile& vl::VirtualFile::operator= ( const VirtualFile & other ) [inline]

const String& vl::VirtualFile::path ( ) const [inline]

void vl::VirtualFile::setPath ( const String & name ) [inline]

Renames the file. Use carefully this function, you shouldn't rename a VirtualFile managed by a VirtualDirectory.

long long VirtualFile::peek | ( | void * | buffer,
 |  | long long | byte_count
 | ) |  |

Reads byte_count bytes and returns to the original position.

Returns the number of bytes read.

long long VirtualFile::read | ( | void * | buffer,
 |  | long long | byte_count
 | ) |  |

long long VirtualFile::write | ( | const void * | buffer,
 |  | long long | byte_count
 | ) |  |

long long VirtualFile::position ( ) const

bool VirtualFile::seekSet ( long long offset )

bool VirtualFile::seekCur ( long long offset )

bool VirtualFile::seekEnd ( long long offset )

bool vl::VirtualFile::endOfFile ( ) const [inline]

long long VirtualFile::load ( std::vector< unsigned char > & data )

Loads the entire file in the specified vector.

Returns the number of bytes read. The file must be closed before calling this function.

long long VirtualFile::load | ( | void * | buffer,
 |  | long long | max = -1
 | ) |  |

Loads the entire file in the specified buffer.

Returns the number of bytes read. The file must be closed before calling this function.

float VirtualFile::readFloat ( bool little_endian_data = true )

long long VirtualFile::readFloat | ( | void * | buffer,
 |  | long long | count
 | ) |  |

double VirtualFile::readDouble ( bool little_endian_data = true )

long long VirtualFile::readDouble | ( | void * | buffer,
 |  | long long | count
 | ) |  |

unsigned char VirtualFile::readUByte ( )

long long VirtualFile::readUByte | ( | void * | buffer,
 |  | long long | count
 | ) |  |

char VirtualFile::readSByte ( )

long long VirtualFile::readSByte | ( | void * | buffer,
 |  | long long | count
 | ) |  |

unsigned long long VirtualFile::readUInt64 ( bool little_endian_data = true )

long long VirtualFile::readUInt64 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

long long VirtualFile::readSInt64 ( bool little_endian_data = true )

long long VirtualFile::readSInt64 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

unsigned int VirtualFile::readUInt32 ( bool little_endian_data = true )

long long VirtualFile::readUInt32 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

int VirtualFile::readSInt32 ( bool little_endian_data = true )

long long VirtualFile::readSInt32 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

unsigned short VirtualFile::readUInt16 ( bool little_endian_data = true )

long long VirtualFile::readUInt16 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

short VirtualFile::readSInt16 ( bool little_endian_data = true )

long long VirtualFile::readSInt16 | ( | void * | buffer,
 |  | long long | count,
 |  | bool | little_endian_data = true
 | ) |  |

long long VirtualFile::writeUInt32 | ( | unsigned long | data,
 |  | bool | little_endian = true
 | ) |  |

long long VirtualFile::writeUInt16 | ( | unsigned short | data,
 |  | bool | little_endian = true
 | ) |  |

long long VirtualFile::writeUInt8 ( unsigned char data )

long long VirtualFile::writeSInt32 | ( | long | data,
 |  | bool | little_endian = true
 | ) |  |

long long VirtualFile::writeSInt16 | ( | short | data,
 |  | bool | little_endian = true
 | ) |  |

long long VirtualFile::writeSInt8 ( char data )

virtual long long vl::VirtualFile::read_Implementation | ( | void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual long long vl::VirtualFile::write_Implementation | ( | const void * | buffer,
 |  | long long | byte_count |
 | ) |  |  | [protected, pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual long long vl::VirtualFile::position_Implementation ( ) const [protected, pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

virtual bool vl::VirtualFile::seekSet_Implementation ( long long offset ) [protected, pure virtual]

Implemented in vl::DiskFile, vl::GZipCodec, vl::MemoryFile, and vl::ZippedFile.

Member Data Documentation

String vl::VirtualFile::mPath [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::VisualizationLibrary Class Reference

vl::VisualizationLibrary

vl::VisualizationLibrary Class Reference

Used to initialize/shutdown VisualizationLibrary and to access important global data. More...

#include <VisualizationLibrary.hpp>

List of all members.

Static Public Member Functions

static void | init ()
Initializes Visualization Library's internal data.
static void | shutdown ()
Releases all the resources acquired by Visualization Library.
static bool | initialized ()
Returns true if init() has been called and shutdown() has not been called yet.
static const char * | versionString ()
Returns the Visualization Library's version string.
static RenderingAbstract * | rendering ()
Returns Visualization Library's rendering root.
static void | setRendering (RenderingAbstract *rendering)
static FileSystem * | fileSystem ()
Returns Visualization Library's default FileSystem.
static FontManager * | fontManager ()
Returns Visualization Library's default FontManager.
static LoadWriterManager * | loadWriterManager ()
Returns Visualization Library's default LoadWriterManager.
static KeyValues * | envVars ()
Returns the environment variables used by Visualization Library.
static StandardLog * | logger ()
Returns the default Log object.
static void * | freeTypeLibrary ()
For internal use only.

Static Protected Member Functions

static void | initEnvVars ()
Initializes the environment variables.

Detailed Description

Used to initialize/shutdown VisualizationLibrary and to access important global data.

Member Function Documentation

void VisualizationLibrary::init ( ) [static]

Initializes Visualization Library's internal data.

void VisualizationLibrary::shutdown ( ) [static]

Releases all the resources acquired by Visualization Library.

bool VisualizationLibrary::initialized ( ) [static]

Returns true if init() has been called and shutdown() has not been called yet.

const char * VisualizationLibrary::versionString ( ) [static]

Returns the Visualization Library's version string.

RenderingAbstract * VisualizationLibrary::rendering ( ) [static]

Returns Visualization Library's rendering root.

void VisualizationLibrary::setRendering ( RenderingAbstract * rendering ) [static]

FileSystem * VisualizationLibrary::fileSystem ( ) [static]

Returns Visualization Library's default FileSystem.

FontManager * VisualizationLibrary::fontManager ( ) [static]

Returns Visualization Library's default FontManager.

LoadWriterManager * VisualizationLibrary::loadWriterManager ( ) [static]

Returns Visualization Library's default LoadWriterManager.

KeyValues * VisualizationLibrary::envVars ( ) [static]

Returns the environment variables used by Visualization Library.

Can also be used to globally pass parameters across different parts of an application.

StandardLog * VisualizationLibrary::logger ( ) [static]

Returns the default Log object.

void * VisualizationLibrary::freeTypeLibrary ( ) [static]

For internal use only.

void VisualizationLibrary::initEnvVars ( ) [static, protected]

Initializes the environment variables.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: vl::WriteCallback Class Reference

vl::WriteCallback

vl::WriteCallback Class Reference

Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback. More...

#include <LoadWriterManager.hpp>

Inheritance diagram for vl::WriteCallback:

vl::Object

List of all members.

Public Member Functions

virtual void operator() (ResourceDatabase *db)=0

Detailed Description

Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback.

Member Function Documentation

virtual void vl::WriteCallback::operator() ( ResourceDatabase * db ) [pure virtual]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: vl::ZippedDirectory Class Reference

vl::ZippedDirectory

vl::ZippedDirectory Class Reference

A VirtualDirectory capable of reading files from a .zip file. More...

#include <ZippedDirectory.hpp>

Inheritance diagram for vl::ZippedDirectory:

vl::VirtualDirectory vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ZippedDirectory ()
ZippedDirectory (const String &zip_file)
ZippedDirectory (VirtualFile *zip_file)
bool | setPath (const String &name)
Changes the path name of a VirtualDirectory. Must not be an empty string.
VirtualFile * | sourceZipFile () const
void | setSourceZipFile (VirtualFile *file)
void | reset ()
Sets the source zip file to NULL and disposes all the files contained in this directory.
ref< VirtualFile > | file (const String &name) const
Returns the VirtualFile with the given name if any, NULL otherwise.
ref< ZippedFile > | zippedFile (const String &name) const
Accepts absolute and relative paths.
void | listFilesRecursive (std::vector< String > &file_list) const
Returns the list of files contained in the VirtualDirectory.
int | zippedFileCount () const
ZippedFile * | zippedFile (int index) const
void | listSubDirs (std::vector< String > &dirs, bool append=false) const
ref< ZippedDirectory > | zippedSubDir (const String &subdir_name) const
ref< VirtualDirectory > | subDir (const String &subdir_name) const
void | listFiles (std::vector< String > &file_list, bool append=false) const
bool | isCorrupted ()

Protected Member Functions

bool | init ()

Protected Attributes

std::map< String, ref
< ZippedFile > > 		mFiles
ref< VirtualFile > mSourceZipFile

Detailed Description

A VirtualDirectory capable of reading files from a .zip file.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • MemoryFile
  • ZippedFile

Constructor & Destructor Documentation

ZippedDirectory::ZippedDirectory ( )

ZippedDirectory::ZippedDirectory ( const String & zip_file )

ZippedDirectory::ZippedDirectory ( VirtualFile * zip_file )

Member Function Documentation

virtual const char* vl::ZippedDirectory::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualDirectory.

bool ZippedDirectory::setPath ( const String & path ) [virtual]

Changes the path name of a VirtualDirectory. Must not be an empty string.

Reimplemented from vl::VirtualDirectory.

VirtualFile * ZippedDirectory::sourceZipFile ( ) const

void ZippedDirectory::setSourceZipFile ( VirtualFile * file )

void ZippedDirectory::reset ( )

Sets the source zip file to NULL and disposes all the files contained in this directory.

ref< VirtualFile > ZippedDirectory::file ( const String & name ) const [virtual]

Returns the VirtualFile with the given name if any, NULL otherwise.

Implements vl::VirtualDirectory.

ref< ZippedFile > ZippedDirectory::zippedFile ( const String & name ) const

Accepts absolute and relative paths.

void ZippedDirectory::listFilesRecursive ( std::vector< String > & file_list ) const [virtual]

Returns the list of files contained in the VirtualDirectory.

If there are subdirectories the files will be searched recursively.

Implements vl::VirtualDirectory.

int ZippedDirectory::zippedFileCount ( ) const

ZippedFile * ZippedDirectory::zippedFile ( int index ) const

void ZippedDirectory::listSubDirs | ( | std::vector< String > & | dirs,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

ref< ZippedDirectory > ZippedDirectory::zippedSubDir ( const String & subdir_name ) const

ref<VirtualDirectory> vl::ZippedDirectory::subDir ( const String & subdir_name ) const [inline, virtual]

Implements vl::VirtualDirectory.

void ZippedDirectory::listFiles | ( | std::vector< String > & | file_list,
 |  | bool | append = false |
 | ) |  |  | const [virtual]

Implements vl::VirtualDirectory.

bool ZippedDirectory::isCorrupted ( )

bool ZippedDirectory::init ( ) [protected]

Member Data Documentation

std::map< String, ref<ZippedFile> > vl::ZippedDirectory::mFiles [protected]

ref<VirtualFile> vl::ZippedDirectory::mSourceZipFile [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vl::ZippedFile Class Reference

vl::ZippedFile

vl::ZippedFile Class Reference

A VirtualFile used to read a file contained in a .zip archive. More...

#include <ZippedFile.hpp>

Inheritance diagram for vl::ZippedFile:

vl::VirtualFile vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ZippedFile ()
~ZippedFile ()
ZippedFileInfo * | zippedFileInfo () const
void | setZippedFileInfo (ZippedFileInfo *info)
virtual bool | exists () const
This returns true if zippedFileInfo() has been properly set up but does not check the existence of this file in the source zip file.
virtual bool | open (EOpenMode mode)
virtual bool | isOpen () const
virtual void | close ()
virtual long long | size () const
bool | extract (char *destination, bool check_sum=true)
ZippedFile & | operator= (const ZippedFile &other)
virtual ref< VirtualFile > | clone () const
void | resetStream ()

Protected Member Functions

virtual long long | read_Implementation (void *buffer, long long bytes_to_read)
virtual long long | write_Implementation (const void *, long long)
virtual bool | fillUncompressedBuffer ()
virtual long long | position_Implementation () const
virtual bool | seekSet_Implementation (long long)

Protected Attributes

ref< ZippedFileInfo > mZippedFileInfo
long long | mReadBytes
z_stream_s * | mZStream
unsigned char | mZipBufferIn [CHUNK_SIZE]
unsigned char | mZipBufferOut [CHUNK_SIZE]
std::vector< char > | mUncompressedBuffer
int | mUncompressedBufferPtr

Static Protected Attributes

static const int | CHUNK_SIZE = 128*1024

Detailed Description

A VirtualFile used to read a file contained in a .zip archive.

See also:
  • VirtualDirectory
  • DiskDirectory
  • MemoryDirectory
  • ZippedDirectory
  • FileSystem
  • VirtualFile
  • DiskFile
  • MemoryFile

Constructor & Destructor Documentation

ZippedFile::ZippedFile ( )

ZippedFile::~ZippedFile ( )

Member Function Documentation

virtual const char* vl::ZippedFile::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::VirtualFile.

ZippedFileInfo * ZippedFile::zippedFileInfo ( ) const

void ZippedFile::setZippedFileInfo ( ZippedFileInfo * info )

bool ZippedFile::exists ( ) const [virtual]

This returns true if zippedFileInfo() has been properly set up but does not check the existence of this file in the source zip file.

To do so call ZippedDirectory::exists().

Implements vl::VirtualFile.

bool ZippedFile::open ( EOpenMode mode ) [virtual]

Implements vl::VirtualFile.

bool ZippedFile::isOpen ( ) const [virtual]

Implements vl::VirtualFile.

void ZippedFile::close ( ) [virtual]

Implements vl::VirtualFile.

long long ZippedFile::size ( ) const [virtual]

Implements vl::VirtualFile.

bool ZippedFile::extract | ( | char * | destination,
 |  | bool | check_sum = true
 | ) |  |

ZippedFile& vl::ZippedFile::operator= ( const ZippedFile & other ) [inline]

ref< VirtualFile > ZippedFile::clone ( ) const [virtual]

Implements vl::VirtualFile.

void ZippedFile::resetStream ( )

long long ZippedFile::read_Implementation | ( | void * | buffer,
 |  | long long | bytes_to_read |
 | ) |  |  | [protected, virtual]

Implements vl::VirtualFile.

virtual long long vl::ZippedFile::write_Implementation | ( | const void * | ,
 |  | long long |  |
 | ) |  |  | [inline, protected, virtual]

Implements vl::VirtualFile.

bool ZippedFile::fillUncompressedBuffer ( ) [protected, virtual]

virtual long long vl::ZippedFile::position_Implementation ( ) const [inline, protected, virtual]

Implements vl::VirtualFile.

bool ZippedFile::seekSet_Implementation ( long long pos ) [protected, virtual]

Implements vl::VirtualFile.

Member Data Documentation

ref<ZippedFileInfo> vl::ZippedFile::mZippedFileInfo [protected]

long long vl::ZippedFile::mReadBytes [protected]

z_stream_s* vl::ZippedFile::mZStream [protected]

const int vl::ZippedFile::CHUNK_SIZE = 128*1024 [static, protected]

unsigned char vl::ZippedFile::mZipBufferIn[CHUNK_SIZE] [protected]

unsigned char vl::ZippedFile::mZipBufferOut[CHUNK_SIZE] [protected]

std::vector<char> vl::ZippedFile::mUncompressedBuffer [protected]

int vl::ZippedFile::mUncompressedBufferPtr [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vl::ZippedFileInfo Class Reference

vl::ZippedFileInfo

vl::ZippedFileInfo Class Reference

Collects the information about a ZippedFile. More...

#include <ZippedFile.hpp>

Inheritance diagram for vl::ZippedFileInfo:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
ZippedFileInfo ()
unsigned short | versionNeeded () const
unsigned short | generalPurposeFlag () const
unsigned short | compressionMethod () const
unsigned int | crc32 () const
unsigned int | compressedSize () const
unsigned int | uncompressedSize () const
unsigned short | fileNameLength () const
unsigned short | extraFieldLength () const
int | second () const
int | minute () const
int | hour () const
int | day () const
int | month () const
int | year () const
const String & | path () const
unsigned int | zippedFileOffset () const
VirtualFile * | sourceZipFile () const
void | setSourceZipFile (VirtualFile *file)

Public Attributes

unsigned short | mVersionNeeded
unsigned short | mGeneralPurposeFlag
unsigned short | mCompressionMethod
unsigned int | mCRC32
unsigned int | mCompressedSize
unsigned int | mUncompressedSize
unsigned short | mFileNameLength
unsigned short | mExtraFieldLength
int | mSecond
int | mMinute
int | mHour
int | mDay
int | mMonth
int | mYear
String mFileName
unsigned int | mZippedFileOffset
ref< VirtualFile > mSourceZipFile

Friends

class | ZippedFile
class | ZippedDirectory

Detailed Description

Collects the information about a ZippedFile.

Constructor & Destructor Documentation

vl::ZippedFileInfo::ZippedFileInfo ( ) [inline]

Member Function Documentation

virtual const char* vl::ZippedFileInfo::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

unsigned short vl::ZippedFileInfo::versionNeeded ( ) const [inline]

unsigned short vl::ZippedFileInfo::generalPurposeFlag ( ) const [inline]

unsigned short vl::ZippedFileInfo::compressionMethod ( ) const [inline]

unsigned int vl::ZippedFileInfo::crc32 ( ) const [inline]

unsigned int vl::ZippedFileInfo::compressedSize ( ) const [inline]

unsigned int vl::ZippedFileInfo::uncompressedSize ( ) const [inline]

unsigned short vl::ZippedFileInfo::fileNameLength ( ) const [inline]

unsigned short vl::ZippedFileInfo::extraFieldLength ( ) const [inline]

int vl::ZippedFileInfo::second ( ) const [inline]

int vl::ZippedFileInfo::minute ( ) const [inline]

int vl::ZippedFileInfo::hour ( ) const [inline]

int vl::ZippedFileInfo::day ( ) const [inline]

int vl::ZippedFileInfo::month ( ) const [inline]

int vl::ZippedFileInfo::year ( ) const [inline]

const String& vl::ZippedFileInfo::path ( ) const [inline]

unsigned int vl::ZippedFileInfo::zippedFileOffset ( ) const [inline]

VirtualFile* vl::ZippedFileInfo::sourceZipFile ( ) const [inline]

void vl::ZippedFileInfo::setSourceZipFile ( VirtualFile * file ) [inline]

Friends And Related Function Documentation

friend class ZippedFile [friend]

friend class ZippedDirectory [friend]

Member Data Documentation

unsigned short vl::ZippedFileInfo::mVersionNeeded

unsigned short vl::ZippedFileInfo::mGeneralPurposeFlag

unsigned short vl::ZippedFileInfo::mCompressionMethod

unsigned int vl::ZippedFileInfo::mCRC32

unsigned int vl::ZippedFileInfo::mCompressedSize

unsigned int vl::ZippedFileInfo::mUncompressedSize

unsigned short vl::ZippedFileInfo::mFileNameLength

unsigned short vl::ZippedFileInfo::mExtraFieldLength

int vl::ZippedFileInfo::mSecond

int vl::ZippedFileInfo::mMinute

int vl::ZippedFileInfo::mHour

int vl::ZippedFileInfo::mDay

int vl::ZippedFileInfo::mMonth

int vl::ZippedFileInfo::mYear

String vl::ZippedFileInfo::mFileName

unsigned int vl::ZippedFileInfo::mZippedFileOffset

ref<VirtualFile> vl::ZippedFileInfo::mSourceZipFile

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vlGLUT::GLUTWindow Class Reference

vlGLUT::GLUTWindow

vlGLUT::GLUTWindow Class Reference

The GLUTWindow class implements an OpenGLContext using the GLUT API. More...

#include <GLUTWindow.hpp>

Inheritance diagram for vlGLUT::GLUTWindow:

vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

GLUTWindow ()
GLUTWindow (const vl::String &title, const vl::OpenGLContextFormat &info, int x, int y, int width, int height)
bool | initGLUTWindow (const vl::String &title, const vl::OpenGLContextFormat &info, int x, int y, int width, int height)
Initializes and shows a GLUT window.
~GLUTWindow ()
virtual void | setMouseVisible (bool visible)
virtual void | setMousePosition (int x, int y)
void | quitApplication ()
Quits the progra calling the C function exit(0).
void | update ()
bool | setFullscreen (bool fs)
void | makeCurrent ()
void | destroy ()
void | updateOverlay ()
void | swapBuffers ()
void | setWindowTitle (const vl::String &title)
int | handle () const
void | setPosition (int x, int y)
void | setSize (int w, int h)
vl::ivec2 | position () const
vl::ivec2 | size () const
void | show ()
void | hide ()
void | getFocus ()

Protected Member Functions

void | initKeymap ()
vl::EKey | mapAsciiKey (unsigned char ascii)
void | updateModifiers ()

Static Protected Member Functions

static vl::EKey | mapSpecialKey (int special_key)
static void | glut_keyboard_func (unsigned char ch, int x, int y)
static void | glut_keyboard_up_func (unsigned char ch, int x, int y)
static void | glut_special_func (int key, int x, int y)
static void | glut_special_up_func (int key, int x, int y)
static void | glut_mouse_func (int button, int state, int x, int y)
static void | glut_motion_func (int x, int y)
static void | glut_passive_motion_func (int x, int y)
static void | glut_mouse_wheel_func (int a, int rotation, int c, int d)
static void | glut_visibility_func (int visibility)
static void | glut_reshape_func (int w, int h)
static void | glut_display_func ()
static void | glut_wmclose_func ()
static void | glut_close_func ()
static void | glut_idle_func ()

Protected Attributes

std::map< unsigned char, vl::EKey > | mKeymap
int | mHandle
bool | mInited

Static Protected Attributes

static std::map< int,
GLUTWindow * > 		mWinMap

Detailed Description

The GLUTWindow class implements an OpenGLContext using the GLUT API.

Constructor & Destructor Documentation

GLUTWindow::GLUTWindow ( )

GLUTWindow::GLUTWindow | ( | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | info,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height
 | ) |  |

vlGLUT::GLUTWindow::~GLUTWindow ( ) [inline]

Member Function Documentation

bool GLUTWindow::initGLUTWindow | ( | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | info,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height
 | ) |  |

Initializes and shows a GLUT window.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

void GLUTWindow::setMouseVisible ( bool visible ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::setMousePosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void vlGLUT::GLUTWindow::quitApplication ( ) [inline, virtual]

Quits the progra calling the C function exit(0).

Reimplemented from vl::OpenGLContext.

void GLUTWindow::update ( ) [virtual]

Reimplemented from vl::OpenGLContext.

bool GLUTWindow::setFullscreen ( bool fs ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::makeCurrent ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::destroy ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::updateOverlay ( )

void GLUTWindow::swapBuffers ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::setWindowTitle ( const vl::String & title ) [virtual]

Reimplemented from vl::OpenGLContext.

int vlGLUT::GLUTWindow::handle ( ) const [inline]

void GLUTWindow::setPosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::setSize | ( | int | w,
 |  | int | h |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

vl::ivec2 GLUTWindow::position ( ) const [virtual]

Reimplemented from vl::OpenGLContext.

vl::ivec2 GLUTWindow::size ( ) const [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::show ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::hide ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::getFocus ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void GLUTWindow::initKeymap ( ) [protected]

vl::EKey GLUTWindow::mapAsciiKey ( unsigned char ascii ) [protected]

vl::EKey GLUTWindow::mapSpecialKey ( int special_key ) [static, protected]

void GLUTWindow::updateModifiers ( ) [protected]

void GLUTWindow::glut_keyboard_func | ( | unsigned char | ch,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_keyboard_up_func | ( | unsigned char | ch,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_special_func | ( | int | key,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_special_up_func | ( | int | key,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_mouse_func | ( | int | button,
 |  | int | state,
 |  | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_motion_func | ( | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_passive_motion_func | ( | int | x,
 |  | int | y |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_mouse_wheel_func | ( | int | a,
 |  | int | rotation,
 |  | int | c,
 |  | int | d |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_visibility_func ( int visibility ) [static, protected]

void GLUTWindow::glut_reshape_func | ( | int | w,
 |  | int | h |
 | ) |  |  | [static, protected]

void GLUTWindow::glut_display_func ( ) [static, protected]

void GLUTWindow::glut_wmclose_func ( ) [static, protected]

void GLUTWindow::glut_close_func ( ) [static, protected]

void GLUTWindow::glut_idle_func ( ) [static, protected]

Member Data Documentation

std::map<unsigned char, vl::EKey> vlGLUT::GLUTWindow::mKeymap [protected]

int vlGLUT::GLUTWindow::mHandle [protected]

bool vlGLUT::GLUTWindow::mInited [protected]

std::map< int, GLUTWindow * > GLUTWindow::mWinMap [static, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vlMFC::MFCWindow Class Reference

vlMFC::MFCWindow

vlMFC::MFCWindow Class Reference

The MFCWindow class is an MFC CWnd with the functionalities of a Win32Context. More...

#include <MFCWindow.hpp>

Inheritance diagram for vlMFC::MFCWindow:

vlWin32::Win32Context vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

MFCWindow ()
virtual | ~MFCWindow ()
bool | initMFCWindow (CWnd *parent, MFCWindow *share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x=0, int y=0, int width=640, int height=480)
Creates the window and initializes the OpenGL rendering context.
virtual void | destroy ()
calls destroyWindow() and dispatches the destroy event to the UIEventListener objects
void | destroyWindow ()
Destroyes the window and the OpenGL rendering context.
HWND | hwnd () const
Returns the Win32 window handle.
afx_msg void | OnPaint ()
afx_msg void | OnClose ()
afx_msg int | OnCreate (LPCREATESTRUCT lpCreateStruct)
afx_msg void | OnKeyDown (UINT nChar, UINT nRepCnt, UINT nFlags)
afx_msg void | OnKeyUp (UINT nChar, UINT nRepCnt, UINT nFlags)
afx_msg void | OnLButtonDblClk (UINT nFlags, CPoint point)
afx_msg void | OnLButtonDown (UINT nFlags, CPoint point)
afx_msg void | OnLButtonUp (UINT nFlags, CPoint point)
afx_msg void | OnMButtonDblClk (UINT nFlags, CPoint point)
afx_msg void | OnMButtonDown (UINT nFlags, CPoint point)
afx_msg void | OnMButtonUp (UINT nFlags, CPoint point)
afx_msg void | OnMouseMove (UINT nFlags, CPoint point)
afx_msg BOOL | OnMouseWheel (UINT nFlags, short zDelta, CPoint pt)
afx_msg void | OnRButtonDblClk (UINT nFlags, CPoint point)
afx_msg void | OnRButtonDown (UINT nFlags, CPoint point)
afx_msg void | OnRButtonUp (UINT nFlags, CPoint point)
afx_msg void | OnSize (UINT nType, int cx, int cy)
afx_msg void | OnTimer (UINT_PTR nIDEvent)
afx_msg void | OnDropFiles (HDROP hDropInfo)

Protected Member Functions

void | CountAndCapture ()
void | CountAndRelease ()

Protected Attributes

int | mMouseDownCount

Static Protected Attributes

static CString | mClassName

Detailed Description

The MFCWindow class is an MFC CWnd with the functionalities of a Win32Context.

Constructor & Destructor Documentation

vlMFC::MFCWindow::MFCWindow ( ) [inline]

virtual vlMFC::MFCWindow::~MFCWindow ( ) [inline, virtual]

Member Function Documentation

bool MFCWindow::initMFCWindow | ( | CWnd * | parent,
 |  | MFCWindow * | share_context,
 |  | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | fmt,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | width = 640,
 |  | int | height = 480
 | ) |  |

Creates the window and initializes the OpenGL rendering context.

void MFCWindow::destroy ( ) [virtual]

calls destroyWindow() and dispatches the destroy event to the UIEventListener objects

Reimplemented from vl::OpenGLContext.

void MFCWindow::destroyWindow ( )

Destroyes the window and the OpenGL rendering context.

HWND vlMFC::MFCWindow::hwnd ( ) const [inline, virtual]

Returns the Win32 window handle.

Implements vlWin32::Win32Context.

void MFCWindow::OnPaint ( )

void MFCWindow::OnClose ( )

int MFCWindow::OnCreate ( LPCREATESTRUCT lpCreateStruct )

void MFCWindow::OnKeyDown | ( | UINT | nChar,
 |  | UINT | nRepCnt,
 |  | UINT | nFlags
 | ) |  |

void MFCWindow::OnKeyUp | ( | UINT | nChar,
 |  | UINT | nRepCnt,
 |  | UINT | nFlags
 | ) |  |

void MFCWindow::OnLButtonDblClk | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnLButtonDown | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnLButtonUp | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnMButtonDblClk | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnMButtonDown | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnMButtonUp | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnMouseMove | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

BOOL MFCWindow::OnMouseWheel | ( | UINT | nFlags,
 |  | short | zDelta,
 |  | CPoint | pt
 | ) |  |

void MFCWindow::OnRButtonDblClk | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnRButtonDown | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnRButtonUp | ( | UINT | nFlags,
 |  | CPoint | point
 | ) |  |

void MFCWindow::OnSize | ( | UINT | nType,
 |  | int | cx,
 |  | int | cy
 | ) |  |

afx_msg void vlMFC::MFCWindow::OnTimer ( UINT_PTR nIDEvent )

void MFCWindow::OnDropFiles ( HDROP hDropInfo )

void MFCWindow::CountAndCapture ( ) [protected]

void MFCWindow::CountAndRelease ( ) [protected]

Member Data Documentation

int vlMFC::MFCWindow::mMouseDownCount [protected]

CString MFCWindow::mClassName [static, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vlMolecule::Atom Class Reference

vlMolecule::Atom

vlMolecule::Atom Class Reference

The Atom class represents an atom to be used with the Molecule class. More...

#include <Atom.hpp>

Inheritance diagram for vlMolecule::Atom:

vl::Object

List of all members.

Public Member Functions

Atom ()
Atom (const Atom &other)
Atom & | operator= (const Atom &other)
Assignment operator: does not assign the adjacent atoms.
bool | isAtomAdjacent (Atom *atom) const
const std::vector< vl::ref
< Atom > > & 		adjacentAtoms () const
std::vector< vl::ref< Atom > > & | adjacentAtoms ()
EAtomType | atomType () const
void | setAtomType (EAtomType type)
unsigned int | id () const
void | setId (unsigned int id)
const vl::fvec3 & | coordinates () const
void | setCoordinates (const vl::fvec3 &coordinates)
float | radius () const
void | setRadius (float radius)
void | setVisited (bool visited)
bool | visited () const
void | setAtomName (const std::string &name)
const std::string & | atomName () const
const vl::fvec4 & | color () const
void | setColor (const vl::fvec4 &color)
bool | visible () const
void | setVisible (bool visible)
void | setShowAtomName (bool show)
Defines whether the atom name should be rendered or not. See also Molecule::setShowAtomNames().
bool | showAtomName () const
Defines whether the atom name should be rendered or not. See also Molecule::setShowAtomNames().

Protected Attributes

vl::fvec4 mColor
vl::fvec3 mCoordinates
EAtomType mAtomType
float | mRadius
std::vector< vl::ref< Atom > > | mAdjacentAtoms
std::string | mAtomName
unsigned int | mId
bool | mVisited
bool | mVisible
bool | mShowAtomName

Detailed Description

The Atom class represents an atom to be used with the Molecule class.

See also:
  • Molecule Visualization Tutorial
  • Molecule
  • Bond

Constructor & Destructor Documentation

vlMolecule::Atom::Atom ( ) [inline]

vlMolecule::Atom::Atom ( const Atom & other ) [inline]

Member Function Documentation

Atom& vlMolecule::Atom::operator= ( const Atom & other ) [inline]

Assignment operator: does not assign the adjacent atoms.

bool vlMolecule::Atom::isAtomAdjacent ( Atom * atom ) const [inline]

const std::vector< vl::ref<Atom> >& vlMolecule::Atom::adjacentAtoms ( ) const [inline]

std::vector< vl::ref<Atom> >& vlMolecule::Atom::adjacentAtoms ( ) [inline]

EAtomType vlMolecule::Atom::atomType ( ) const [inline]

void vlMolecule::Atom::setAtomType ( EAtomType type ) [inline]

unsigned int vlMolecule::Atom::id ( ) const [inline]

void vlMolecule::Atom::setId ( unsigned int id ) [inline]

const vl::fvec3& vlMolecule::Atom::coordinates ( ) const [inline]

void vlMolecule::Atom::setCoordinates ( const vl::fvec3 & coordinates ) [inline]

float vlMolecule::Atom::radius ( ) const [inline]

void vlMolecule::Atom::setRadius ( float radius ) [inline]

void vlMolecule::Atom::setVisited ( bool visited ) [inline]

bool vlMolecule::Atom::visited ( ) const [inline]

void vlMolecule::Atom::setAtomName ( const std::string & name ) [inline]

const std::string& vlMolecule::Atom::atomName ( ) const [inline]

const vl::fvec4& vlMolecule::Atom::color ( ) const [inline]

void vlMolecule::Atom::setColor ( const vl::fvec4 & color ) [inline]

bool vlMolecule::Atom::visible ( ) const [inline]

void vlMolecule::Atom::setVisible ( bool visible ) [inline]

void vlMolecule::Atom::setShowAtomName ( bool show ) [inline]

Defines whether the atom name should be rendered or not. See also Molecule::setShowAtomNames().

bool vlMolecule::Atom::showAtomName ( ) const [inline]

Defines whether the atom name should be rendered or not. See also Molecule::setShowAtomNames().

Member Data Documentation

vl::fvec4 vlMolecule::Atom::mColor [protected]

vl::fvec3 vlMolecule::Atom::mCoordinates [protected]

EAtomType vlMolecule::Atom::mAtomType [protected]

float vlMolecule::Atom::mRadius [protected]

std::vector< vl::ref<Atom> > vlMolecule::Atom::mAdjacentAtoms [protected]

std::string vlMolecule::Atom::mAtomName [protected]

unsigned int vlMolecule::Atom::mId [protected]

bool vlMolecule::Atom::mVisited [protected]

bool vlMolecule::Atom::mVisible [protected]

bool vlMolecule::Atom::mShowAtomName [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Atom.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlMolecule::AtomInfo Class Reference

vlMolecule::AtomInfo

vlMolecule::AtomInfo Class Reference

Encapsulates information regarding an atom type. More...

#include <chem_database.hpp>

List of all members.

Public Member Functions

AtomInfo (EAtomType type, const char *name, const char *symbol, int atomic_num, double atomic_mass, double melting_pt, double boiling_pt, double electroneg, double electron_aff, int valence, double calculated_r, double empirical_r, double covalent_r, double vdw_r, unsigned int cpk_color, unsigned int rasmol_color)
Constructor.
EAtomType | type () const
Returns the type of an atom.
const char * | name () const
Returns the name of the atom.
const char * | symbol () const
Returns the symbol of the atom.
int | atomicNumber () const
Returns the atom's atomic number.
double | atomicMass () const
Returns the atom mass.
double | meltingPoint () const
Returns the element's melting point in Kelvin.
double | boilingPoint () const
Returns the element's boiling point in Kelvin.
double | electronegativity () const
Returns the atom electronegativity.
double | electronAffinity () const
Returns the electron affinity in Kj/mol.
int | valence () const
Returns the valence of the atom.
double | calculatedRadius () const
Returns the atom's calculated radius in Angstroms.
double | empiricalRadius () const
Returns the atom's empirical radius in Angstroms.
double | covalentRadius () const
Returns the atom's covalent radius in Angstroms.
double | vanDerWaalsRadius () const
Returns the atom's van der Waals radius in Angstroms.
vl::fvec4 | cpkColor () const
Returns the atom's CPK color.
vl::fvec4 | rasmolColor () const
Returns the atom's RasMol color.

Protected Attributes

EAtomType mType
const char * | mName
const char * | mSymbol
int | mAtomicNumber
int | mValence
unsigned int | mCPKColor
unsigned int | mRasMolColor
double | mAtomicMass
double | mMeltingPoint
double | mBoilingPoint
double | mElectronegativity
double | mElectronAffinity
double | mCalculatedRadius
double | mEmpiricalRadius
double | mCovalentRadius
double | mVanDerWaalsRadius

Detailed Description

Encapsulates information regarding an atom type.

Constructor & Destructor Documentation

vlMolecule::AtomInfo::AtomInfo | ( | EAtomType | type,
 |  | const char * | name,
 |  | const char * | symbol,
 |  | int | atomic_num,
 |  | double | atomic_mass,
 |  | double | melting_pt,
 |  | double | boiling_pt,
 |  | double | electroneg,
 |  | double | electron_aff,
 |  | int | valence,
 |  | double | calculated_r,
 |  | double | empirical_r,
 |  | double | covalent_r,
 |  | double | vdw_r,
 |  | unsigned int | cpk_color,
 |  | unsigned int | rasmol_color |
 | ) |  |  | [inline]

Constructor.

Member Function Documentation

EAtomType vlMolecule::AtomInfo::type ( ) const [inline]

Returns the type of an atom.

const char* vlMolecule::AtomInfo::name ( ) const [inline]

Returns the name of the atom.

const char* vlMolecule::AtomInfo::symbol ( ) const [inline]

Returns the symbol of the atom.

int vlMolecule::AtomInfo::atomicNumber ( ) const [inline]

Returns the atom's atomic number.

double vlMolecule::AtomInfo::atomicMass ( ) const [inline]

Returns the atom mass.

double vlMolecule::AtomInfo::meltingPoint ( ) const [inline]

Returns the element's melting point in Kelvin.

double vlMolecule::AtomInfo::boilingPoint ( ) const [inline]

Returns the element's boiling point in Kelvin.

double vlMolecule::AtomInfo::electronegativity ( ) const [inline]

Returns the atom electronegativity.

double vlMolecule::AtomInfo::electronAffinity ( ) const [inline]

Returns the electron affinity in Kj/mol.

int vlMolecule::AtomInfo::valence ( ) const [inline]

Returns the valence of the atom.

double vlMolecule::AtomInfo::calculatedRadius ( ) const [inline]

Returns the atom's calculated radius in Angstroms.

double vlMolecule::AtomInfo::empiricalRadius ( ) const [inline]

Returns the atom's empirical radius in Angstroms.

double vlMolecule::AtomInfo::covalentRadius ( ) const [inline]

Returns the atom's covalent radius in Angstroms.

double vlMolecule::AtomInfo::vanDerWaalsRadius ( ) const [inline]

Returns the atom's van der Waals radius in Angstroms.

vl::fvec4 vlMolecule::AtomInfo::cpkColor ( ) const [inline]

Returns the atom's CPK color.

vl::fvec4 vlMolecule::AtomInfo::rasmolColor ( ) const [inline]

Returns the atom's RasMol color.

Member Data Documentation

EAtomType vlMolecule::AtomInfo::mType [protected]

const char* vlMolecule::AtomInfo::mName [protected]

const char* vlMolecule::AtomInfo::mSymbol [protected]

int vlMolecule::AtomInfo::mAtomicNumber [protected]

int vlMolecule::AtomInfo::mValence [protected]

unsigned int vlMolecule::AtomInfo::mCPKColor [protected]

unsigned int vlMolecule::AtomInfo::mRasMolColor [protected]

double vlMolecule::AtomInfo::mAtomicMass [protected]

double vlMolecule::AtomInfo::mMeltingPoint [protected]

double vlMolecule::AtomInfo::mBoilingPoint [protected]

double vlMolecule::AtomInfo::mElectronegativity [protected]

double vlMolecule::AtomInfo::mElectronAffinity [protected]

double vlMolecule::AtomInfo::mCalculatedRadius [protected]

double vlMolecule::AtomInfo::mEmpiricalRadius [protected]

double vlMolecule::AtomInfo::mCovalentRadius [protected]

double vlMolecule::AtomInfo::mVanDerWaalsRadius [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlMolecule::Bond Class Reference

vlMolecule::Bond

vlMolecule::Bond Class Reference

The Bond class represents a bond to be used with the Molecule class. More...

#include <Bond.hpp>

Inheritance diagram for vlMolecule::Bond:

vl::Object

List of all members.

Public Member Functions

Bond ()
Bond (const Bond &other)
unsigned int | id () const
void | setId (unsigned int id)
void | setBondType (EBondType type)
EBondType | bondType () const
void | setAtom1 (Atom *atom)
Atom * | atom1 () const
void | setAtom2 (Atom *atom)
Atom * | atom2 () const
void | setVisible (bool visible)
bool | visible () const
void | setColor (const vl::fvec4 &color)
const vl::fvec4 & | color () const
void | setUseAtomColors (bool use_atom_color)
bool | useAtomColors () const
float | radius () const
void | setRadius (float radius)

Protected Attributes

vl::fvec4 mColor
float | mRadius
Atom * mAtom1
Atom * mAtom2
EBondType mType
unsigned int | mId
bool | mVisible
bool | mUseAtomColors

Detailed Description

The Bond class represents a bond to be used with the Molecule class.

See also:
  • Molecule Visualization Tutorial
  • Molecule
  • Atom

Constructor & Destructor Documentation

vlMolecule::Bond::Bond ( ) [inline]

vlMolecule::Bond::Bond ( const Bond & other ) [inline]

Member Function Documentation

unsigned int vlMolecule::Bond::id ( ) const [inline]

void vlMolecule::Bond::setId ( unsigned int id ) [inline]

void vlMolecule::Bond::setBondType ( EBondType type ) [inline]

EBondType vlMolecule::Bond::bondType ( ) const [inline]

void vlMolecule::Bond::setAtom1 ( Atom * atom ) [inline]

Atom* vlMolecule::Bond::atom1 ( ) const [inline]

void vlMolecule::Bond::setAtom2 ( Atom * atom ) [inline]

Atom* vlMolecule::Bond::atom2 ( ) const [inline]

void vlMolecule::Bond::setVisible ( bool visible ) [inline]

bool vlMolecule::Bond::visible ( ) const [inline]

void vlMolecule::Bond::setColor ( const vl::fvec4 & color ) [inline]

const vl::fvec4& vlMolecule::Bond::color ( ) const [inline]

void vlMolecule::Bond::setUseAtomColors ( bool use_atom_color ) [inline]

bool vlMolecule::Bond::useAtomColors ( ) const [inline]

float vlMolecule::Bond::radius ( ) const [inline]

void vlMolecule::Bond::setRadius ( float radius ) [inline]

Member Data Documentation

vl::fvec4 vlMolecule::Bond::mColor [protected]

float vlMolecule::Bond::mRadius [protected]

Atom* vlMolecule::Bond::mAtom1 [protected]

Atom* vlMolecule::Bond::mAtom2 [protected]

EBondType vlMolecule::Bond::mType [protected]

unsigned int vlMolecule::Bond::mId [protected]

bool vlMolecule::Bond::mVisible [protected]

bool vlMolecule::Bond::mUseAtomColors [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Bond.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlMolecule::Molecule Class Reference

vlMolecule::Molecule

vlMolecule::Molecule Class Reference

The Molecule class is used to manage and render 3D molecular structures. More...

#include <Molecule.hpp>

Inheritance diagram for vlMolecule::Molecule:

vl::Object

List of all members.

Public Member Functions

Molecule ()
~Molecule ()
Molecule (const Molecule &other)
Molecule & | operator= (const Molecule &other)
void | reset ()
void | setMoleculeName (const std::string &name)
const std::string | moleculeName () const
unsigned int | id () const
void | setId (unsigned int id)
vl::KeyValues * tags ()
const vl::KeyValues * | tags () const
const std::vector< vl::ref
< Atom > > & 		atoms () const
std::vector< vl::ref< Atom > > & | atoms ()
int | atomCount () const
Atom * | atom (int index) const
void | addAtom (Atom *atom)
void | eraseAtom (Atom *atom)
void | eraseAtom (int index)
void | eraseAllAtoms ()
const std::vector< vl::ref
< Bond > > & 		bonds () const
std::vector< vl::ref< Bond > > & | bonds ()
int | bondCount () const
Bond * | bond (int index) const
Bond * | bond (Atom *a1, Atom *a2)
void | addBond (Bond *bond)
Bond * | addBond (Atom *a1, Atom *a2)
void | eraseBond (Bond *bond)
void | eraseBond (int bond)
void | eraseBond (Atom *a1, Atom *a2)
void | eraseBond (int a1, int a2)
void | eraseAllBonds ()
void | computeAtomAdjacency ()
void | incidentBonds (std::vector< Bond * > &inc_bonds, Atom *atom)
const std::vector< vl::ref
< Atom > > & 		cycle (int i) const
Returns the i-th cycle.
std::vector< vl::ref< Atom > > & | cycle (int i)
Returns the i-th cycle.
const std::vector< std::vector
< vl::ref< Atom > > > & 		cycles () const
Returns the list of cycles.
std::vector< std::vector
< vl::ref< Atom > > > & 		cycles ()
Returns the list of cycles.
void | prepareForRendering ()
Generates the geometry representing the current molecule, atom and bond settings.
const vl::ActorTree * | actorTree () const
The vl::ActorTree node containing the Actor[s] representing the molecule.
vl::ActorTree * actorTree ()
The vl::ActorTree node containing the Actor[s] representing the molecule.
void | setCPKAtomColors ()
Sets all the atoms' color to their CPK color.
void | setAtomColors (const vl::fvec4 &color)
Sets all the atoms' color to the specified color.
void | setCalculatedAtomRadii (float percentage=1.0f)
Sets all the atoms' radii to their calculated atom radii.
void | setEmpiricalAtomRadii (float percentage=1.0f)
Sets all the atoms' radii to their empirical atom radii.
void | setCovalentAtomRadii (float percentage=1.0f)
Sets all the atoms' radii to their covalent atom radii.
void | setVanDerWaalsAtomRadii (float percentage=1.0f)
Sets all the atoms' radii to their van der Waals atom radii.
void | setAtomRadii (float radius)
Sets all the atoms' radii to the specified one.
void | setBondRadii (float radius)
Sets all the bonds' radii to the specified one.
void | setAtomTypeVisible (EAtomType type, bool visible)
void | setMoleculeStyle (EMoleculeStyle style)
The rendering style of the molecule.
EMoleculeStyle | moleculeStyle () const
The rendering style of the molecule.
void | setAtomDetail (int detail)
Geometrical detail used to render the atoms, usually between 0 and 3 (default is 2).
int | atomDetail () const
Geometrical detail used to render the atoms, usually between 0 and 3 (default is 2).
void | setBondDetail (int detail)
Geometrical detail used to render the bonds, usually between 5 and 50 (default is 20).
int | bondDetail () const
Geometrical detail used to render the bonds, usually between 5 and 50 (default is 20).
float | ringOffset () const
void | setRingOffset (float offset)
void | setAromaticBondsColor (const vl::fvec4 &color)
void | setAromaticRingColor (const vl::fvec4 &color)
const vl::fvec4 & | aromaticRingColor () const
float | lineWidth () const
bool | smoothLines () const
void | setLineWidth (float w)
void | setSmoothLines (bool smooth)
vl::Transform * transformTree ()
The transform tree used by the generated bonds, atoms and labels.
const vl::Transform * | transformTree () const
The transform tree used by the generated bonds, atoms and labels.
vl::Text * atomLabelTemplate ()
The text settings to be used to render the atom labels.
const vl::Text * | atomLabelTemplate () const
The text settings to be used to render the atom labels.
void | setShowAtomNames (bool show)
Globally defines whether the atom names should be rendered or not. See also Atom::setShowAtomName().
bool | showAtomNames () const
Globally defines whether the atom names should be rendered or not. See also Atom::setShowAtomName().
const vl::Effect * | atomLabelEffect () const
The vl::Effect used to render the atom labels.
vl::Effect * atomLabelEffect ()
The vl::Effect used to render the atom labels.

Protected Member Functions

void | prepareAtomInsert (int bonus=100)
void | prepareBondInsert (int bonus=100)
void | wireframeStyle ()
void | atomsStyle ()
void | ballAndStickStyle ()
void | sticksStyle ()
void | generateRings ()
void | generateAtomLabels ()
void | generateAtomLabel (const Atom *atom, vl::Transform *tr)

Protected Attributes

vl::fvec4 mAromaticRingColor
vl::ref< vl::ActorTree > mActorTree
vl::ref< vl::Transform > mTransformTree
std::vector< vl::ref< Atom > > | mAtoms
std::vector< vl::ref< Bond > > | mBonds
std::vector< std::vector
< vl::ref< Atom > > > 		mCycles
std::string | mMoleculeName
vl::ref< vl::KeyValues > mTags
vl::ref< vl::Text > mAtomLabelTemplate
vl::ref< vl::Effect > mAtomLabelEffect
unsigned int | mId
EMoleculeStyle mMoleculeStyle
int | mAtomDetail
int | mBondDetail
float | mRingOffset
float | mLineWidth
bool | mSmoothLines
bool | mShowAtomNames

Detailed Description

The Molecule class is used to manage and render 3D molecular structures.

See also:
  • Molecule Visualization Tutorial
  • Atom
  • Bond

Constructor & Destructor Documentation

Molecule::Molecule ( )

vlMolecule::Molecule::~Molecule ( ) [inline]

vlMolecule::Molecule::Molecule ( const Molecule & other ) [inline]

Member Function Documentation

Molecule & Molecule::operator= ( const Molecule & other )

void Molecule::reset ( )

void vlMolecule::Molecule::setMoleculeName ( const std::string & name ) [inline]

const std::string vlMolecule::Molecule::moleculeName ( ) const [inline]

unsigned int vlMolecule::Molecule::id ( ) const [inline]

void vlMolecule::Molecule::setId ( unsigned int id ) [inline]

vl::KeyValues* vlMolecule::Molecule::tags ( ) [inline]

const vl::KeyValues* vlMolecule::Molecule::tags ( ) const [inline]

const std::vector< vl::ref<Atom> >& vlMolecule::Molecule::atoms ( ) const [inline]

std::vector< vl::ref<Atom> >& vlMolecule::Molecule::atoms ( ) [inline]

int vlMolecule::Molecule::atomCount ( ) const [inline]

Atom * Molecule::atom ( int index ) const

void Molecule::addAtom ( Atom * atom )

void Molecule::eraseAtom ( Atom * atom )

void Molecule::eraseAtom ( int index )

void Molecule::eraseAllAtoms ( )

const std::vector< vl::ref<Bond> >& vlMolecule::Molecule::bonds ( ) const [inline]

std::vector< vl::ref<Bond> >& vlMolecule::Molecule::bonds ( ) [inline]

int vlMolecule::Molecule::bondCount ( ) const [inline]

Bond * Molecule::bond ( int index ) const

Bond * Molecule::bond | ( | Atom * | a1,
 |  | Atom * | a2
 | ) |  |

void Molecule::addBond ( Bond * bond )

Bond * Molecule::addBond | ( | Atom * | a1,
 |  | Atom * | a2
 | ) |  |

void Molecule::eraseBond ( Bond * bond )

void Molecule::eraseBond ( int bond )

void Molecule::eraseBond | ( | Atom * | a1,
 |  | Atom * | a2
 | ) |  |

void Molecule::eraseBond | ( | int | a1,
 |  | int | a2
 | ) |  |

void Molecule::eraseAllBonds ( )

void Molecule::computeAtomAdjacency ( )

void Molecule::incidentBonds | ( | std::vector< Bond * > & | inc_bonds,
 |  | Atom * | atom
 | ) |  |

const std::vector< vl::ref<Atom> >& vlMolecule::Molecule::cycle ( int i ) const [inline]

Returns the i-th cycle.

std::vector< vl::ref<Atom> >& vlMolecule::Molecule::cycle ( int i ) [inline]

Returns the i-th cycle.

const std::vector< std::vector< vl::ref<Atom> > >& vlMolecule::Molecule::cycles ( ) const [inline]

Returns the list of cycles.

std::vector< std::vector< vl::ref<Atom> > >& vlMolecule::Molecule::cycles ( ) [inline]

Returns the list of cycles.

void Molecule::prepareForRendering ( )

Generates the geometry representing the current molecule, atom and bond settings.

The actors, geometry, and transforms generated by this function can be found in actorTree() and transformTree().

const vl::ActorTree* vlMolecule::Molecule::actorTree ( ) const [inline]

The vl::ActorTree node containing the Actor[s] representing the molecule.

vl::ActorTree* vlMolecule::Molecule::actorTree ( ) [inline]

The vl::ActorTree node containing the Actor[s] representing the molecule.

void Molecule::setCPKAtomColors ( )

Sets all the atoms' color to their CPK color.

void Molecule::setAtomColors ( const vl::fvec4 & color )

Sets all the atoms' color to the specified color.

void Molecule::setCalculatedAtomRadii ( float percentage = 1.0f )

Sets all the atoms' radii to their calculated atom radii.

void Molecule::setEmpiricalAtomRadii ( float percentage = 1.0f )

Sets all the atoms' radii to their empirical atom radii.

void Molecule::setCovalentAtomRadii ( float percentage = 1.0f )

Sets all the atoms' radii to their covalent atom radii.

void Molecule::setVanDerWaalsAtomRadii ( float percentage = 1.0f )

Sets all the atoms' radii to their van der Waals atom radii.

void Molecule::setAtomRadii ( float radius )

Sets all the atoms' radii to the specified one.

void Molecule::setBondRadii ( float radius )

Sets all the bonds' radii to the specified one.

void Molecule::setAtomTypeVisible | ( | EAtomType | type,
 |  | bool | visible
 | ) |  |

void vlMolecule::Molecule::setMoleculeStyle ( EMoleculeStyle style ) [inline]

The rendering style of the molecule.

EMoleculeStyle vlMolecule::Molecule::moleculeStyle ( ) const [inline]

The rendering style of the molecule.

void vlMolecule::Molecule::setAtomDetail ( int detail ) [inline]

Geometrical detail used to render the atoms, usually between 0 and 3 (default is 2).

int vlMolecule::Molecule::atomDetail ( ) const [inline]

Geometrical detail used to render the atoms, usually between 0 and 3 (default is 2).

void vlMolecule::Molecule::setBondDetail ( int detail ) [inline]

Geometrical detail used to render the bonds, usually between 5 and 50 (default is 20).

int vlMolecule::Molecule::bondDetail ( ) const [inline]

Geometrical detail used to render the bonds, usually between 5 and 50 (default is 20).

float vlMolecule::Molecule::ringOffset ( ) const [inline]

void vlMolecule::Molecule::setRingOffset ( float offset ) [inline]

void Molecule::setAromaticBondsColor ( const vl::fvec4 & color )

void vlMolecule::Molecule::setAromaticRingColor ( const vl::fvec4 & color ) [inline]

const vl::fvec4& vlMolecule::Molecule::aromaticRingColor ( ) const [inline]

float vlMolecule::Molecule::lineWidth ( ) const [inline]

bool vlMolecule::Molecule::smoothLines ( ) const [inline]

void vlMolecule::Molecule::setLineWidth ( float w ) [inline]

void vlMolecule::Molecule::setSmoothLines ( bool smooth ) [inline]

vl::Transform* vlMolecule::Molecule::transformTree ( ) [inline]

The transform tree used by the generated bonds, atoms and labels.

const vl::Transform* vlMolecule::Molecule::transformTree ( ) const [inline]

The transform tree used by the generated bonds, atoms and labels.

vl::Text* vlMolecule::Molecule::atomLabelTemplate ( ) [inline]

The text settings to be used to render the atom labels.

const vl::Text* vlMolecule::Molecule::atomLabelTemplate ( ) const [inline]

The text settings to be used to render the atom labels.

void vlMolecule::Molecule::setShowAtomNames ( bool show ) [inline]

Globally defines whether the atom names should be rendered or not. See also Atom::setShowAtomName().

bool vlMolecule::Molecule::showAtomNames ( ) const [inline]

Globally defines whether the atom names should be rendered or not. See also Atom::setShowAtomName().

const vl::Effect* vlMolecule::Molecule::atomLabelEffect ( ) const [inline]

The vl::Effect used to render the atom labels.

vl::Effect* vlMolecule::Molecule::atomLabelEffect ( ) [inline]

The vl::Effect used to render the atom labels.

void vlMolecule::Molecule::prepareAtomInsert ( int bonus = 100 ) [inline, protected]

void vlMolecule::Molecule::prepareBondInsert ( int bonus = 100 ) [inline, protected]

void Molecule::wireframeStyle ( ) [protected]

void Molecule::atomsStyle ( ) [protected]

void Molecule::ballAndStickStyle ( ) [protected]

void Molecule::sticksStyle ( ) [protected]

void Molecule::generateRings ( ) [protected]

void Molecule::generateAtomLabels ( ) [protected]

void Molecule::generateAtomLabel | ( | const Atom * | atom,
 |  | vl::Transform * | tr |
 | ) |  |  | [protected]

Member Data Documentation

vl::fvec4 vlMolecule::Molecule::mAromaticRingColor [protected]

vl::ref<vl::ActorTree> vlMolecule::Molecule::mActorTree [protected]

vl::ref<vl::Transform> vlMolecule::Molecule::mTransformTree [protected]

std::vector< vl::ref<Atom> > vlMolecule::Molecule::mAtoms [protected]

std::vector< vl::ref<Bond> > vlMolecule::Molecule::mBonds [protected]

std::vector< std::vector< vl::ref<Atom> > > vlMolecule::Molecule::mCycles [protected]

std::string vlMolecule::Molecule::mMoleculeName [protected]

vl::ref<vl::KeyValues> vlMolecule::Molecule::mTags [protected]

vl::ref<vl::Text> vlMolecule::Molecule::mAtomLabelTemplate [protected]

vl::ref<vl::Effect> vlMolecule::Molecule::mAtomLabelEffect [protected]

unsigned int vlMolecule::Molecule::mId [protected]

EMoleculeStyle vlMolecule::Molecule::mMoleculeStyle [protected]

int vlMolecule::Molecule::mAtomDetail [protected]

int vlMolecule::Molecule::mBondDetail [protected]

float vlMolecule::Molecule::mRingOffset [protected]

float vlMolecule::Molecule::mLineWidth [protected]

bool vlMolecule::Molecule::mSmoothLines [protected]

bool vlMolecule::Molecule::mShowAtomNames [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.cpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule_rendering.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlMolecule::RingExtractor Class Reference

vlMolecule::RingExtractor

vlMolecule::RingExtractor Class Reference

The RingExtractor class traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection. More...

#include <RingExtractor.hpp>

List of all members.

Public Member Functions

RingExtractor (Molecule *mol)
void | setMolecule (Molecule *mol)
Molecule * | molecule () const
void | run ()
void | bootstrap ()
void | depthFirstVisit (Atom *atom, std::vector< vl::ref< Atom > > &current_path)
void | keepAromaticCycles ()
void | sortCycles ()
void | keepPlanarCycles (float epsilon)
void | removeDoubles ()
void | keepMinimalCycles ()

Protected Attributes

Molecule * mMolecule

Detailed Description

The RingExtractor class traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection.

Constructor & Destructor Documentation

vlMolecule::RingExtractor::RingExtractor ( Molecule * mol ) [inline]

Member Function Documentation

void vlMolecule::RingExtractor::setMolecule ( Molecule * mol ) [inline]

Molecule* vlMolecule::RingExtractor::molecule ( ) const [inline]

void vlMolecule::RingExtractor::run ( ) [inline]

void vlMolecule::RingExtractor::bootstrap ( ) [inline]

void vlMolecule::RingExtractor::depthFirstVisit | ( | Atom * | atom,
 |  | std::vector< vl::ref< Atom > > & | current_path |
 | ) |  |  | [inline]

void vlMolecule::RingExtractor::keepAromaticCycles ( ) [inline]

void vlMolecule::RingExtractor::sortCycles ( ) [inline]

void vlMolecule::RingExtractor::keepPlanarCycles ( float epsilon ) [inline]

void vlMolecule::RingExtractor::removeDoubles ( ) [inline]

void vlMolecule::RingExtractor::keepMinimalCycles ( ) [inline]

Member Data Documentation

Molecule* vlMolecule::RingExtractor::mMolecule [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/RingExtractor.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlQt4::Qt4Widget Class Reference

vlQt4::Qt4Widget

vlQt4::Qt4Widget Class Reference

The Qt4Widget class implements an OpenGLContext using the Trolltech's Qt4 API. More...

#include <Qt4Widget.hpp>

Inheritance diagram for vlQt4::Qt4Widget:

vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

Qt4Widget (QWidget *parent=NULL, const QGLWidget *shareWidget=NULL, Qt::WindowFlags f=0)
void | dragEnterEvent (QDragEnterEvent *ev)
void | dropEvent (QDropEvent *ev)
bool | initQt4Widget (const vl::String &title, const vl::OpenGLContextFormat &info, const QGLContext *shareContext=0, int x=0, int y=0, int width=640, int height=480)
virtual void | setContinuousUpdate (bool continuous)
void | initializeGL ()
void | resizeGL (int width, int height)
void | paintGL ()
void | update ()
virtual void | setWindowTitle (const vl::String &title)
virtual bool | setFullscreen (bool fullscreen)
virtual void | quitApplication ()
Asks to the windowing system that is managing the OpenGLContext to quit the application.
virtual void | destroy ()
virtual void | show ()
virtual void | hide ()
virtual void | setPosition (int x, int y)
virtual vl::ivec2 | position () const
virtual void | setSize (int w, int h)
virtual vl::ivec2 | size () const
void | swapBuffers ()
void | makeCurrent ()
void | setMousePosition (int x, int y)
void | mouseMoveEvent (QMouseEvent *ev)
void | mousePressEvent (QMouseEvent *ev)
void | mouseReleaseEvent (QMouseEvent *ev)
void | wheelEvent (QWheelEvent *ev)
void | keyPressEvent (QKeyEvent *ev)
void | keyReleaseEvent (QKeyEvent *ev)
virtual void | setMouseVisible (bool visible)
virtual void | getFocus ()

Protected Member Functions

void | translateKeyEvent (QKeyEvent *ev, unsigned short &unicode_out, vl::EKey &key_out)

Protected Attributes

QTimer | mUpdateTimer

Detailed Description

The Qt4Widget class implements an OpenGLContext using the Trolltech's Qt4 API.

Constructor & Destructor Documentation

vlQt4::Qt4Widget::Qt4Widget | ( | QWidget * | parent = NULL,
 |  | const QGLWidget * | shareWidget = NULL,
 |  | Qt::WindowFlags | f = 0 |
 | ) |  |  | [inline]

Member Function Documentation

void vlQt4::Qt4Widget::dragEnterEvent ( QDragEnterEvent * ev ) [inline]

void vlQt4::Qt4Widget::dropEvent ( QDropEvent * ev ) [inline]

bool vlQt4::Qt4Widget::initQt4Widget | ( | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | info,
 |  | const QGLContext * | shareContext = 0,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | width = 640,
 |  | int | height = 480 |
 | ) |  |  | [inline]

virtual void vlQt4::Qt4Widget::setContinuousUpdate ( bool continuous ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlQt4::Qt4Widget::initializeGL ( ) [inline]

void vlQt4::Qt4Widget::resizeGL | ( | int | width,
 |  | int | height |
 | ) |  |  | [inline]

void vlQt4::Qt4Widget::paintGL ( ) [inline]

void vlQt4::Qt4Widget::update ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::setWindowTitle ( const vl::String & title ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual bool vlQt4::Qt4Widget::setFullscreen ( bool fullscreen ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::quitApplication ( ) [inline, virtual]

Asks to the windowing system that is managing the OpenGLContext to quit the application.

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::destroy ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::show ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::hide ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::setPosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual vl::ivec2 vlQt4::Qt4Widget::position ( ) const [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::setSize | ( | int | w,
 |  | int | h |
 | ) |  |  | [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual vl::ivec2 vlQt4::Qt4Widget::size ( ) const [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlQt4::Qt4Widget::swapBuffers ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlQt4::Qt4Widget::makeCurrent ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlQt4::Qt4Widget::setMousePosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlQt4::Qt4Widget::mouseMoveEvent ( QMouseEvent * ev ) [inline]

void vlQt4::Qt4Widget::mousePressEvent ( QMouseEvent * ev ) [inline]

void vlQt4::Qt4Widget::mouseReleaseEvent ( QMouseEvent * ev ) [inline]

void vlQt4::Qt4Widget::wheelEvent ( QWheelEvent * ev ) [inline]

void vlQt4::Qt4Widget::keyPressEvent ( QKeyEvent * ev ) [inline]

void vlQt4::Qt4Widget::keyReleaseEvent ( QKeyEvent * ev ) [inline]

virtual void vlQt4::Qt4Widget::setMouseVisible ( bool visible ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

virtual void vlQt4::Qt4Widget::getFocus ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

void Qt4Widget::translateKeyEvent | ( | QKeyEvent * | ev,
 |  | unsigned short & | unicode_out,
 |  | vl::EKey & | key_out |
 | ) |  |  | [protected]

Member Data Documentation

QTimer vlQt4::Qt4Widget::mUpdateTimer [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlSDL::SDLWindow Class Reference

vlSDL::SDLWindow

vlSDL::SDLWindow Class Reference

The SDLWindow class implements an OpenGLContext using the SDL API. More...

#include <SDLWindow.hpp>

Inheritance diagram for vlSDL::SDLWindow:

vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

SDLWindow ()
SDLWindow (const vl::String &title, const vl::OpenGLContextFormat &info, int x=0, int y=0, int width=640, int height=480)
bool | initSDLWindow (const vl::String &title, const vl::OpenGLContextFormat &info, int x=0, int y=0, int width=640, int height=480)
~SDLWindow ()
void | setPosition (int x, int y)
virtual void | swapBuffers ()
void | translateEvent (SDL_Event *ev)
void | destroy ()
void | quitApplication ()
Quits the event loop.
void | setWindowTitle (const vl::String &)
void | setMouseVisible (bool visible)
void | setMousePosition (int x, int y)
void | update ()
void | makeCurrent ()

Static Public Member Functions

static SDL_Surface * | sdlSurface ()

Static Protected Attributes

static SDL_Surface * | mScreen = NULL

Detailed Description

The SDLWindow class implements an OpenGLContext using the SDL API.

Note:
SDL notifies Unicode codes only on key-press events not on release events.

Constructor & Destructor Documentation

SDLWindow::SDLWindow ( )

SDLWindow::SDLWindow | ( | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | info,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | width = 640,
 |  | int | height = 480
 | ) |  |

SDLWindow::~SDLWindow ( )

Member Function Documentation

bool SDLWindow::initSDLWindow | ( | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | info,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | width = 640,
 |  | int | height = 480
 | ) |  |

void SDLWindow::setPosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void SDLWindow::swapBuffers ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void SDLWindow::translateEvent ( SDL_Event * ev )

void SDLWindow::destroy ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void SDLWindow::quitApplication ( ) [virtual]

Quits the event loop.

Reimplemented from vl::OpenGLContext.

void SDLWindow::setWindowTitle ( const vl::String & title ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlSDL::SDLWindow::setMouseVisible ( bool visible ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

void vlSDL::SDLWindow::setMousePosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [inline, virtual]

Reimplemented from vl::OpenGLContext.

void SDLWindow::update ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlSDL::SDLWindow::makeCurrent ( ) [inline, virtual]

Reimplemented from vl::OpenGLContext.

static SDL_Surface* vlSDL::SDLWindow::sdlSurface ( ) [inline, static]

Member Data Documentation

SDL_Surface * SDLWindow::mScreen = NULL [static, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlut::Applet Class Reference

vlut::Applet

vlut::Applet Class Reference

The Applet class is an utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline. More...

#include <Applet.hpp>

Inheritance diagram for vlut::Applet:

vl::UIEventListener vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
Applet ()
~Applet ()
void | initialize ()
virtual void | openglContextBoundEvent (vl::OpenGLContext *openglContext)
void | keyReleaseEvent (unsigned short, vl::EKey key)
virtual void | destroyEvent ()
void | runEvent ()
void | resizeEvent (int w, int h)
vl::SceneManagerActorTree * sceneManager ()
const vl::SceneManagerActorTree * | sceneManager () const
vl::GhostCameraManipulator * ghostCamera ()
vl::TrackballManipulator * trackball ()
double | fps () const
virtual void | run ()=0
virtual void | initEvent ()=0
virtual void | shutdown ()=0

Protected Member Functions

void | bindManipulators (vl::Rendering *rendering)

Protected Attributes

vl::ref
< vl::GhostCameraManipulator > 		mFly
vl::ref< vl::TrackballManipulator > mTrackball
vl::ref
< vl::SceneManagerActorTree > 		mSceneManagerActorTree
int | mFrameCount
double | mStartTime
double | mFPS

Detailed Description

The Applet class is an utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline.

Constructor & Destructor Documentation

Applet::Applet ( )

vlut::Applet::~Applet ( ) [inline]

Member Function Documentation

virtual const char* vlut::Applet::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::UIEventListener.

void Applet::initialize ( )

void Applet::openglContextBoundEvent ( vl::OpenGLContext * openglContext ) [virtual]

Reimplemented from vl::UIEventListener.

void Applet::keyReleaseEvent | ( | unsigned | short,
 |  | vl::EKey | key |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

void Applet::destroyEvent ( ) [virtual]

Reimplemented from vl::UIEventListener.

void Applet::runEvent ( ) [virtual]

Reimplemented from vl::UIEventListener.

void Applet::resizeEvent | ( | int | w,
 |  | int | h |
 | ) |  |  | [virtual]

Reimplemented from vl::UIEventListener.

vl::SceneManagerActorTree* vlut::Applet::sceneManager ( ) [inline]

const vl::SceneManagerActorTree* vlut::Applet::sceneManager ( ) const [inline]

vl::GhostCameraManipulator* vlut::Applet::ghostCamera ( ) [inline]

vl::TrackballManipulator* vlut::Applet::trackball ( ) [inline]

double vlut::Applet::fps ( ) const [inline]

virtual void vlut::Applet::run ( ) [pure virtual]

virtual void vlut::Applet::initEvent ( ) [pure virtual]

Reimplemented from vl::UIEventListener.

virtual void vlut::Applet::shutdown ( ) [pure virtual]

void Applet::bindManipulators ( vl::Rendering * rendering ) [protected]

Member Data Documentation

vl::ref<vl::GhostCameraManipulator> vlut::Applet::mFly [protected]

vl::ref<vl::TrackballManipulator> vlut::Applet::mTrackball [protected]

vl::ref<vl::SceneManagerActorTree> vlut::Applet::mSceneManagerActorTree [protected]

int vlut::Applet::mFrameCount [protected]

double vlut::Applet::mStartTime [protected]

double vlut::Applet::mFPS [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlVG::SceneManagerVectorGraphics Class Reference

vlVG::SceneManagerVectorGraphics

vlVG::SceneManagerVectorGraphics Class Reference

The SceneManagerVectorGraphics class is a SceneManager that contains VectorGraphics objects. More...

#include <SceneManagerVectorGraphics.hpp>

Inheritance diagram for vlVG::SceneManagerVectorGraphics:

vl::SceneManager vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
SceneManagerVectorGraphics ()
void | setActorRenderRankStart (int rank_start)
Defines the Actor's render rank to be used when extracting them from the scene manager during the rendering.
int | actorRenderRankStart () const
Returns the rendering rank start value used during the rendering of the VectorGraphics objects. See setActorRenderRankStart() for more information.
virtual void | appendVisibleActors (vl::ActorCollection &queue, const vl::Camera *)
Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.
virtual void | appendActors (vl::ActorCollection &queue)
Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.
vl::Collection< VectorGraphics > * vectorGraphicObjects ()
Returns the list of VectorGraphics objects bound to a SceneManagerVectorGraphics.
const vl::Collection
< VectorGraphics > * 		vectorGraphicObjects () const
Returns the list of VectorGraphics objects bound to a SceneManagerVectorGraphics.

Protected Attributes

vl::Collection< VectorGraphics > mVectorGraphicObjects
int | mActorRenderRankStart

Detailed Description

The SceneManagerVectorGraphics class is a SceneManager that contains VectorGraphics objects.

The VectorGraphics objects are rendered in the order in which they are added to the SceneManagerVectorGraphics.

See also:
  • vl::Actor
  • vl::ActorKdTree
  • vl::ActorTree
  • vl::SceneManager
  • vl::SceneManagerBVH
  • vl::SceneManagerActorKdTree
  • vl::SceneManagerActorTree
  • vl::SceneManagerPortals

Constructor & Destructor Documentation

vlVG::SceneManagerVectorGraphics::SceneManagerVectorGraphics ( ) [inline]

Member Function Documentation

virtual const char* vlVG::SceneManagerVectorGraphics::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::SceneManager.

void vlVG::SceneManagerVectorGraphics::setActorRenderRankStart ( int rank_start ) [inline]

Defines the Actor's render rank to be used when extracting them from the scene manager during the rendering.

During the rendering when the Actor[s] are extracted they are assigned a progressive render rank starting from rank_start so that they are rendered in the same order in which they were created by their VectorGraphics. Also the order in which a VectorGraphics is inserted in the SceneManagerVectorGraphics determines the rendering order.

int vlVG::SceneManagerVectorGraphics::actorRenderRankStart ( ) const [inline]

Returns the rendering rank start value used during the rendering of the VectorGraphics objects. See setActorRenderRankStart() for more information.

virtual void vlVG::SceneManagerVectorGraphics::appendVisibleActors | ( | vl::ActorCollection & | list,
 |  | const vl::Camera * | camera |
 | ) |  |  | [inline, virtual]

Performs frustum culling and appends the enabled and visible Actor[s] to the given ActorCollection.

See also enableMask(), Actor::enableMask()

Implements vl::SceneManager.

virtual void vlVG::SceneManagerVectorGraphics::appendActors ( vl::ActorCollection & list ) [inline, virtual]

Appends all the Actor[s] contained in the scene manager without performing frustum culling or checking enable masks.

Implements vl::SceneManager.

vl::Collection<VectorGraphics>* vlVG::SceneManagerVectorGraphics::vectorGraphicObjects ( ) [inline]

Returns the list of VectorGraphics objects bound to a SceneManagerVectorGraphics.

const vl::Collection<VectorGraphics>* vlVG::SceneManagerVectorGraphics::vectorGraphicObjects ( ) const [inline]

Returns the list of VectorGraphics objects bound to a SceneManagerVectorGraphics.

Member Data Documentation

vl::Collection<VectorGraphics> vlVG::SceneManagerVectorGraphics::mVectorGraphicObjects [protected]

int vlVG::SceneManagerVectorGraphics::mActorRenderRankStart [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/SceneManagerVectorGraphics.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlVG::VectorGraphics Class Reference

vlVG::VectorGraphics

vlVG::VectorGraphics Class Reference

The VectorGraphics class is used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics. More...

#include <VectorGraphics.hpp>

Inheritance diagram for vlVG::VectorGraphics:

vl::Object

List of all members.

Classes

class | ImageState
class | State

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
VectorGraphics ()
const vl::ActorCollection * | actors () const
Returns the list of Actor[s] generated by a VectorGraphics object.
vl::ActorCollection * actors ()
Returns the list of Actor[s] generated by a VectorGraphics object.
vl::Actor * | drawLine (double x1, double y1, double x2, double y2)
Renders a line starting a point <x1,y1> and ending at point <x2,y2>.
vl::Actor * | drawLines (const std::vector< vl::dvec2 > &ln)
Renders a set of lines. The 'ln' parameter shoud contain N pairs of vl::dvec2. Each pair defines a line segment.
vl::Actor * | drawLineStrip (const std::vector< vl::dvec2 > &ln)
Renders a line passing through the points defined by 'ln'.
vl::Actor * | drawLineLoop (const std::vector< vl::dvec2 > &ln)
Renders a closed line passing through the points defined by 'ln'.
vl::Actor * | fillPolygon (const std::vector< vl::dvec2 > &poly)
Renders a convex polygon whose corners are defined by 'poly'.
vl::Actor * | fillTriangles (const std::vector< vl::dvec2 > &triangles)
Renders a set of triangles. The 'triangles' parameters must contain N triplets of vl::dvec2. Each triplet defines a triangle.
vl::Actor * | fillTriangleFan (const std::vector< vl::dvec2 > &fan)
Renders a triangle fan.
vl::Actor * | fillTriangleStrip (const std::vector< vl::dvec2 > &strip)
Renders a strip of triangles as defined by the OpenGL primitive GL_TRIANGLE_STRIP.
vl::Actor * | fillQuads (const std::vector< vl::dvec2 > &quads)
Renders a set of rectangles as defined by the OpenGL primitive GL_QUADS.
vl::Actor * | fillQuadStrip (const std::vector< vl::dvec2 > &quad_strip)
Renders a set of rectangles as defined by the OpenGL primitive GL_QUAD_STRIP.
vl::Actor * | drawPoint (double x, double y)
Renders a single point. This is only an utility function. If you want to draw many points use drawPoints(const std::vector<vl::dvec2>& pt) instead.
vl::Actor * | drawPoints (const std::vector< vl::dvec2 > &pt)
Renders a set of points using the currently set pointSize(), color() and image().
vl::Actor * | drawEllipse (double origx, double origy, double xaxis, double yaxis, int segments=64)
Renders the outline of an ellipse.
vl::Actor * | fillEllipse (double origx, double origy, double xaxis, double yaxis, int segments=64)
Renders an ellipse.
vl::Actor * | drawQuad (double left, double bottom, double right, double top)
Utility function that renders the outline of a quad.
vl::Actor * | fillQuad (double left, double bottom, double right, double top)
Utility function that renders a single quad.
void | startDrawing ()
Starts the drawing process.
void | continueDrawing ()
Continues the rendering on a VectorGraphics object.
void | endDrawing (bool release_cache=true)
Ends the rendering on a VectorGraphics and releases the resources used during the Actor generation process.
void | clear ()
Resets the VectorGraphics removing all the graphics objects and resetting its internal state.
void | setColor (const vl::fvec4 &color)
The current color. Note that the current color also modulates the currently active image.
const vl::fvec4 & | color () const
The current color. Note that the current color also modulates the currently active image.
void | setPointSize (int size)
The current point size.
int | pointSize () const
The current point size.
void | setImage (vl::Image *image)
The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.
const vl::Image * | image () const
The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.
vl::Image * image ()
The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.
void | setPoint (vl::Image *image)
Utility function equivalent to 'setImage(image); setPointSize(image->width());'.
void | setTextureMode (ETextureMode mode)
The current texture mode.
ETextureMode | textureMode () const
The current texture mode.
void | setLogicOp (vl::ELogicOp op)
The current logic operation, see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information.
vl::ELogicOp | logicOp () const
The current logic operation.
void | setLineWidth (float width)
The current line width, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information.
float | lineWidth () const
The current line width.
void | setPointSmoothing (bool smooth)
The current point smoothing mode.
bool | pointSmoothing () const
The current point smoothing mode.
void | setLineSmoothing (bool smooth)
The current line smoothing mode.
bool | lineSmoothing () const
The current line smoothing mode.
void | setPolygonSmoothing (bool smooth)
The current polygon smoothing mode.
bool | polygonSmoothing () const
The current polygon smoothing mode.
void | setLineStipple (ELineStipple stipple)
The current line stipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information.
void | setLineStipple (unsigned short stipple)
The current line stipple.
unsigned short | lineStipple () const
The current line stipple.
void | setPolygonStipple (EPolygonStipple stipple)
The current polygon stipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information.
void | setPolygonStipple (unsigned char *stipple)
The current polygon stipple.
const unsigned char * | polygonStipple () const
The current polygon stipple.
unsigned char * | polygonStipple ()
The current polygon stipple.
void | setAlphaFunc (vl::EFunction func, float ref_value)
The current alpha function, see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information.
void | getAlphaFunc (vl::EFunction &func, float &ref_value) const
The current alpha function.
void | setBlendFunc (vl::EBlendFactor src_rgb, vl::EBlendFactor dst_rgb, vl::EBlendFactor src_alpha, vl::EBlendFactor dst_alpha)
The current blending factor, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information.
void | getBlendFunc (vl::EBlendFactor &src_rgb, vl::EBlendFactor &dst_rgb, vl::EBlendFactor &src_alpha, vl::EBlendFactor &dst_alpha) const
The current blending factor.
void | setBlendEquation (vl::EBlendEquation rgb_eq, vl::EBlendEquation alpha_eq)
The current blend equation, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml for more information.
void | getBlendEquation (vl::EBlendEquation &rgb_eq, vl::EBlendEquation &alpha_eq) const
The current blend equation.
void | setColorMask (bool r, bool g, bool b, bool a)
The current color mask, see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information.
const vl::ivec4 & | colorMask () const
The current color mask.
void | setStencilTestEnabled (bool enabled)
If set to 'true' the stencil test and operations will be enabled.
bool | stencilTestEnabled () const
If set to 'true' the stencil test and operations will be enabled.
void | setStencilMask (unsigned int mask)
Current stencil mask, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml for more information.
unsigned int | stencilMask () const
Current stencil mask.
void | setStencilOp (vl::EStencilOp sfail, vl::EStencilOp dpfail, vl::EStencilOp dppass)
Current stencil operation, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml for more information.
void | getStencilOp (vl::EStencilOp &sfail, vl::EStencilOp &dpfail, vl::EStencilOp &dppass)
Current stencil operation.
void | setStencilFunc (vl::EFunction func, int refval, unsigned int mask)
The current stencil function, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml for more information.
void | getStencilFunc (vl::EFunction &func, int &refval, unsigned int &mask)
The current stencil function.
void | setFont (const vl::String &name, int size, bool smooth=false)
Sets the current Font.
void | setFont (const vl::Font *font)
Sets the current Font.
void | setDefaultFont ()
Sets the default Font.
const vl::Font * | font () const
Returns the current Font.
void | setScissor (int x, int y, int width, int height)
Defines the scissor box and enables the scissor test.
const vl::Scissor * | scissor () const
Returns the currently active Scissor.
void | removeScissor ()
Disables the Scissor test and clipping.
vl::Actor * | clearColor (const vl::fvec4 &color, int x=0, int y=0, int w=-1, int h=-1)
Clears the specific area of the viewport.
vl::Actor * | clearStencil (int clear_val, int x=0, int y=0, int w=-1, int h=-1)
Clears the specific area of the viewport.
vl::Actor * | drawText (vl::Text *text)
Draw the specified Text object.
vl::Actor * | drawText (int x, int y, const vl::String &text, int alignment=vl::AlignBottom|vl::AlignLeft)
Draws the specified text at the specified position.
vl::Actor * | drawText (const vl::String &text, int alignment=vl::AlignBottom|vl::AlignLeft)
Draws the specified text.
vl::Actor * | drawActor (vl::Actor *actor, vl::Transform *transform=NULL, bool keep_effect=false)
Draws the specified Actor with the specified Transform.
vl::Actor * | drawActorCopy (vl::Actor *actor, vl::Transform *transform=NULL)
Like drawActor() but instead of drawing the given actor creates a copy of it and draws that.
const vl::dmat4 & | matrix () const
Returns the current transform matrix.
void | setMatrix (const vl::dmat4 &matrix)
Sets the current transform matrix.
void | resetMatrix ()
Resets the current transform matrix.
void | rotate (double deg)
Performs a rotation of 'deg' degrees around the z axis.
void | translate (double x, double y, double z=0.0)
Translates the current transform matrix.
void | scale (double x, double y, double z=1.0)
Scales the current transform matrix.
void | pushMatrix ()
Pushes the current matrix in the matrix stack in order to restore it later with popMatrix().
void | popMatrix ()
Pops the top most matrix in the matrix stack and sets it as the current matrix.
const std::vector< vl::dmat4 > & | matrixStack () const
Returns the matrix stack.
void | pushState ()
Pushes the current VectorGraphics state (including the matrix state) in the state stack in order to restore it later with popState().
void | popState ()
Pops the top most state in the state stack and sets it as the current state.
void | pushScissor (int x, int y, int w, int h)
Pushes the current scissor in the scissor stack in order to restore it later with popScissor() and activates a new one.
void | popScissor ()
Pops the top most scissor in the scissor stack and sets it as the current scissor.
const std::vector< vl::ref
< vl::Scissor > > & 		scissorStack () const
Returns the scissor stack.
void | setTransform (vl::Transform *transform)
Binds the given Transform to all the Actor[s] that have been generated so far.
vl::Effect * currentEffect ()
Returns the Effect representing the current VectorGraphic's state.

Detailed Description

The VectorGraphics class is used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics.

The VectorGraphics object is basically nothing more than an container of Actor[s] generated by functions like drawLines(), fillTriangles() etc. The Actor[s] are rendered in the order in which they are generated.

The VectorGraphics class features a set of advanced capabilites:

  • Matrix transformations and matrix stack
  • State stack
  • All the blending operations supported by OpenGL
  • All the stencil operations supported by OpenGL
  • Texture mapping on all the primitives with automatic texture coordinate generation
  • Several primitives like lines, points, quads, triangles, line strips, triangle strips, ellipses etc.
  • Polygon and line stipple
  • Text rendering
  • Scissor test to clip the objects against a rectangular region
  • Line and point smoothing
  • Color logic operations

For more information please refer to the 2D Vector Graphics page.

Constructor & Destructor Documentation

vlVG::VectorGraphics::VectorGraphics ( ) [inline]

Member Function Documentation

virtual const char* vlVG::VectorGraphics::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

const vl::ActorCollection* vlVG::VectorGraphics::actors ( ) const [inline]

Returns the list of Actor[s] generated by a VectorGraphics object.

vl::ActorCollection* vlVG::VectorGraphics::actors ( ) [inline]

Returns the list of Actor[s] generated by a VectorGraphics object.

vl::Actor* vlVG::VectorGraphics::drawLine | ( | double | x1,
 |  | double | y1,
 |  | double | x2,
 |  | double | y2 |
 | ) |  |  | [inline]

Renders a line starting a point <x1,y1> and ending at point <x2,y2>.

vl::Actor* vlVG::VectorGraphics::drawLines ( const std::vector< vl::dvec2 > & ln ) [inline]

Renders a set of lines. The 'ln' parameter shoud contain N pairs of vl::dvec2. Each pair defines a line segment.

vl::Actor* vlVG::VectorGraphics::drawLineStrip ( const std::vector< vl::dvec2 > & ln ) [inline]

Renders a line passing through the points defined by 'ln'.

vl::Actor* vlVG::VectorGraphics::drawLineLoop ( const std::vector< vl::dvec2 > & ln ) [inline]

Renders a closed line passing through the points defined by 'ln'.

vl::Actor* vlVG::VectorGraphics::fillPolygon ( const std::vector< vl::dvec2 > & poly ) [inline]

Renders a convex polygon whose corners are defined by 'poly'.

vl::Actor* vlVG::VectorGraphics::fillTriangles ( const std::vector< vl::dvec2 > & triangles ) [inline]

Renders a set of triangles. The 'triangles' parameters must contain N triplets of vl::dvec2. Each triplet defines a triangle.

vl::Actor* vlVG::VectorGraphics::fillTriangleFan ( const std::vector< vl::dvec2 > & fan ) [inline]

Renders a triangle fan.

vl::Actor* vlVG::VectorGraphics::fillTriangleStrip ( const std::vector< vl::dvec2 > & strip ) [inline]

Renders a strip of triangles as defined by the OpenGL primitive GL_TRIANGLE_STRIP.

vl::Actor* vlVG::VectorGraphics::fillQuads ( const std::vector< vl::dvec2 > & quads ) [inline]

Renders a set of rectangles as defined by the OpenGL primitive GL_QUADS.

vl::Actor* vlVG::VectorGraphics::fillQuadStrip ( const std::vector< vl::dvec2 > & quad_strip ) [inline]

Renders a set of rectangles as defined by the OpenGL primitive GL_QUAD_STRIP.

vl::Actor* vlVG::VectorGraphics::drawPoint | ( | double | x,
 |  | double | y |
 | ) |  |  | [inline]

Renders a single point. This is only an utility function. If you want to draw many points use drawPoints(const std::vector<vl::dvec2>& pt) instead.

vl::Actor* vlVG::VectorGraphics::drawPoints ( const std::vector< vl::dvec2 > & pt ) [inline]

Renders a set of points using the currently set pointSize(), color() and image().

vl::Actor* vlVG::VectorGraphics::drawEllipse | ( | double | origx,
 |  | double | origy,
 |  | double | xaxis,
 |  | double | yaxis,
 |  | int | segments = 64 |
 | ) |  |  | [inline]

Renders the outline of an ellipse.

vl::Actor* vlVG::VectorGraphics::fillEllipse | ( | double | origx,
 |  | double | origy,
 |  | double | xaxis,
 |  | double | yaxis,
 |  | int | segments = 64 |
 | ) |  |  | [inline]

Renders an ellipse.

vl::Actor* vlVG::VectorGraphics::drawQuad | ( | double | left,
 |  | double | bottom,
 |  | double | right,
 |  | double | top |
 | ) |  |  | [inline]

Utility function that renders the outline of a quad.

vl::Actor* vlVG::VectorGraphics::fillQuad | ( | double | left,
 |  | double | bottom,
 |  | double | right,
 |  | double | top |
 | ) |  |  | [inline]

Utility function that renders a single quad.

void vlVG::VectorGraphics::startDrawing ( ) [inline]

Starts the drawing process.

You have to call this function before calling any of the fill* and draw* functions. This function will erase all the previously generated content of the VectorGraphics.

void vlVG::VectorGraphics::continueDrawing ( ) [inline]

Continues the rendering on a VectorGraphics object.

This function will reset the VectorGraphics state and matrix but will not erase the previously generated graphics.

void vlVG::VectorGraphics::endDrawing ( bool release_cache = true ) [inline]

Ends the rendering on a VectorGraphics and releases the resources used during the Actor generation process.

If you intend to continue the rendering or to add new graphics objects later set 'release_cache' to false.

void vlVG::VectorGraphics::clear ( ) [inline]

Resets the VectorGraphics removing all the graphics objects and resetting its internal state.

void vlVG::VectorGraphics::setColor ( const vl::fvec4 & color ) [inline]

The current color. Note that the current color also modulates the currently active image.

const vl::fvec4& vlVG::VectorGraphics::color ( ) const [inline]

The current color. Note that the current color also modulates the currently active image.

void vlVG::VectorGraphics::setPointSize ( int size ) [inline]

The current point size.

int vlVG::VectorGraphics::pointSize ( ) const [inline]

The current point size.

void vlVG::VectorGraphics::setImage ( vl::Image * image ) [inline]

The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.

const vl::Image* vlVG::VectorGraphics::image ( ) const [inline]

The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.

vl::Image* vlVG::VectorGraphics::image ( ) [inline]

The current image used to texture the rendered objects. Note that the current color also modulates the currently active image.

void vlVG::VectorGraphics::setPoint ( vl::Image * image ) [inline]

Utility function equivalent to 'setImage(image); setPointSize(image->width());'.

void vlVG::VectorGraphics::setTextureMode ( ETextureMode mode ) [inline]

The current texture mode.

ETextureMode vlVG::VectorGraphics::textureMode ( ) const [inline]

The current texture mode.

void vlVG::VectorGraphics::setLogicOp ( vl::ELogicOp op ) [inline]

The current logic operation, see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information.

vl::ELogicOp vlVG::VectorGraphics::logicOp ( ) const [inline]

The current logic operation.

void vlVG::VectorGraphics::setLineWidth ( float width ) [inline]

The current line width, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information.

float vlVG::VectorGraphics::lineWidth ( ) const [inline]

The current line width.

void vlVG::VectorGraphics::setPointSmoothing ( bool smooth ) [inline]

The current point smoothing mode.

bool vlVG::VectorGraphics::pointSmoothing ( ) const [inline]

The current point smoothing mode.

void vlVG::VectorGraphics::setLineSmoothing ( bool smooth ) [inline]

The current line smoothing mode.

bool vlVG::VectorGraphics::lineSmoothing ( ) const [inline]

The current line smoothing mode.

void vlVG::VectorGraphics::setPolygonSmoothing ( bool smooth ) [inline]

The current polygon smoothing mode.

bool vlVG::VectorGraphics::polygonSmoothing ( ) const [inline]

The current polygon smoothing mode.

void vlVG::VectorGraphics::setLineStipple ( ELineStipple stipple ) [inline]

The current line stipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information.

void vlVG::VectorGraphics::setLineStipple ( unsigned short stipple ) [inline]

The current line stipple.

unsigned short vlVG::VectorGraphics::lineStipple ( ) const [inline]

The current line stipple.

void vlVG::VectorGraphics::setPolygonStipple ( EPolygonStipple stipple ) [inline]

The current polygon stipple, see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information.

void vlVG::VectorGraphics::setPolygonStipple ( unsigned char * stipple ) [inline]

The current polygon stipple.

const unsigned char* vlVG::VectorGraphics::polygonStipple ( ) const [inline]

The current polygon stipple.

unsigned char* vlVG::VectorGraphics::polygonStipple ( ) [inline]

The current polygon stipple.

void vlVG::VectorGraphics::setAlphaFunc | ( | vl::EFunction | func,
 |  | float | ref_value |
 | ) |  |  | [inline]

The current alpha function, see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information.

void vlVG::VectorGraphics::getAlphaFunc | ( | vl::EFunction & | func,
 |  | float & | ref_value |
 | ) |  |  | const [inline]

The current alpha function.

void vlVG::VectorGraphics::setBlendFunc | ( | vl::EBlendFactor | src_rgb,
 |  | vl::EBlendFactor | dst_rgb,
 |  | vl::EBlendFactor | src_alpha,
 |  | vl::EBlendFactor | dst_alpha |
 | ) |  |  | [inline]

The current blending factor, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information.

void vlVG::VectorGraphics::getBlendFunc | ( | vl::EBlendFactor & | src_rgb,
 |  | vl::EBlendFactor & | dst_rgb,
 |  | vl::EBlendFactor & | src_alpha,
 |  | vl::EBlendFactor & | dst_alpha |
 | ) |  |  | const [inline]

The current blending factor.

void vlVG::VectorGraphics::setBlendEquation | ( | vl::EBlendEquation | rgb_eq,
 |  | vl::EBlendEquation | alpha_eq |
 | ) |  |  | [inline]

The current blend equation, see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml for more information.

void vlVG::VectorGraphics::getBlendEquation | ( | vl::EBlendEquation & | rgb_eq,
 |  | vl::EBlendEquation & | alpha_eq |
 | ) |  |  | const [inline]

The current blend equation.

void vlVG::VectorGraphics::setColorMask | ( | bool | r,
 |  | bool | g,
 |  | bool | b,
 |  | bool | a |
 | ) |  |  | [inline]

The current color mask, see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information.

const vl::ivec4& vlVG::VectorGraphics::colorMask ( ) const [inline]

The current color mask.

void vlVG::VectorGraphics::setStencilTestEnabled ( bool enabled ) [inline]

If set to 'true' the stencil test and operations will be enabled.

bool vlVG::VectorGraphics::stencilTestEnabled ( ) const [inline]

If set to 'true' the stencil test and operations will be enabled.

void vlVG::VectorGraphics::setStencilMask ( unsigned int mask ) [inline]

Current stencil mask, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml for more information.

unsigned int vlVG::VectorGraphics::stencilMask ( ) const [inline]

Current stencil mask.

void vlVG::VectorGraphics::setStencilOp | ( | vl::EStencilOp | sfail,
 |  | vl::EStencilOp | dpfail,
 |  | vl::EStencilOp | dppass |
 | ) |  |  | [inline]

Current stencil operation, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml for more information.

void vlVG::VectorGraphics::getStencilOp | ( | vl::EStencilOp & | sfail,
 |  | vl::EStencilOp & | dpfail,
 |  | vl::EStencilOp & | dppass |
 | ) |  |  | [inline]

Current stencil operation.

void vlVG::VectorGraphics::setStencilFunc | ( | vl::EFunction | func,
 |  | int | refval,
 |  | unsigned int | mask |
 | ) |  |  | [inline]

The current stencil function, see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml for more information.

void vlVG::VectorGraphics::getStencilFunc | ( | vl::EFunction & | func,
 |  | int & | refval,
 |  | unsigned int & | mask |
 | ) |  |  | [inline]

The current stencil function.

void vlVG::VectorGraphics::setFont | ( | const vl::String & | name,
 |  | int | size,
 |  | bool | smooth = false |
 | ) |  |  | [inline]

Sets the current Font.

void vlVG::VectorGraphics::setFont ( const vl::Font * font ) [inline]

Sets the current Font.

void vlVG::VectorGraphics::setDefaultFont ( ) [inline]

Sets the default Font.

const vl::Font* vlVG::VectorGraphics::font ( ) const [inline]

Returns the current Font.

void vlVG::VectorGraphics::setScissor | ( | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height |
 | ) |  |  | [inline]

Defines the scissor box and enables the scissor test.

The parameters are considered in windows coordinates. The Scissor is used to clip the rendering against a specific rectangular area. See also http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information.

const vl::Scissor* vlVG::VectorGraphics::scissor ( ) const [inline]

Returns the currently active Scissor.

void vlVG::VectorGraphics::removeScissor ( ) [inline]

Disables the Scissor test and clipping.

vl::Actor* vlVG::VectorGraphics::clearColor | ( | const vl::fvec4 & | color,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | w = -1,
 |  | int | h = -1 |
 | ) |  |  | [inline]

Clears the specific area of the viewport.

The parameters x y w h define a rectangular area in viewport coordinates that is clipped against the viewport itself.

Note:
The specified rectangular area is not affected by the current matrix transform.

vl::Actor* vlVG::VectorGraphics::clearStencil | ( | int | clear_val,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | w = -1,
 |  | int | h = -1 |
 | ) |  |  | [inline]

Clears the specific area of the viewport.

The parameters x y w h define a rectangular area in viewport coordinates that is clipped against the viewport itself.

Note:
The specified rectangular area is not affected by the current matrix transform.

vl::Actor* vlVG::VectorGraphics::drawText ( vl::Text * text ) [inline]

Draw the specified Text object.

vl::Actor* vlVG::VectorGraphics::drawText | ( | int | x,
 |  | int | y,
 |  | const vl::String & | text,
 |  | int | alignment = vl::AlignBottom|vl::AlignLeft |
 | ) |  |  | [inline]

Draws the specified text at the specified position.

Note that the current matrix transform affect the final position, rotation and scaling of the text.

vl::Actor* vlVG::VectorGraphics::drawText | ( | const vl::String & | text,
 |  | int | alignment = vl::AlignBottom|vl::AlignLeft |
 | ) |  |  | [inline]

Draws the specified text.

vl::Actor* vlVG::VectorGraphics::drawActor | ( | vl::Actor * | actor,
 |  | vl::Transform * | transform = NULL,
 |  | bool | keep_effect = false |
 | ) |  |  | [inline]

Draws the specified Actor with the specified Transform.

If keep_effect is set to 'false' or the Actor's Effect is NULL a default Effect is automatically generated. If 'transform' is non NULL it is bound to the Actor.

vl::Actor* vlVG::VectorGraphics::drawActorCopy | ( | vl::Actor * | actor,
 |  | vl::Transform * | transform = NULL |
 | ) |  |  | [inline]

Like drawActor() but instead of drawing the given actor creates a copy of it and draws that.

This function is useful when you want to crate multiple instances of the same geometry.

const vl::dmat4& vlVG::VectorGraphics::matrix ( ) const [inline]

Returns the current transform matrix.

void vlVG::VectorGraphics::setMatrix ( const vl::dmat4 & matrix ) [inline]

Sets the current transform matrix.

void vlVG::VectorGraphics::resetMatrix ( ) [inline]

Resets the current transform matrix.

void vlVG::VectorGraphics::rotate ( double deg ) [inline]

Performs a rotation of 'deg' degrees around the z axis.

void vlVG::VectorGraphics::translate | ( | double | x,
 |  | double | y,
 |  | double | z = 0.0 |
 | ) |  |  | [inline]

Translates the current transform matrix.

void vlVG::VectorGraphics::scale | ( | double | x,
 |  | double | y,
 |  | double | z = 1.0 |
 | ) |  |  | [inline]

Scales the current transform matrix.

void vlVG::VectorGraphics::pushMatrix ( ) [inline]

Pushes the current matrix in the matrix stack in order to restore it later with popMatrix().

void vlVG::VectorGraphics::popMatrix ( ) [inline]

Pops the top most matrix in the matrix stack and sets it as the current matrix.

const std::vector<vl::dmat4>& vlVG::VectorGraphics::matrixStack ( ) const [inline]

Returns the matrix stack.

void vlVG::VectorGraphics::pushState ( ) [inline]

Pushes the current VectorGraphics state (including the matrix state) in the state stack in order to restore it later with popState().

void vlVG::VectorGraphics::popState ( ) [inline]

Pops the top most state in the state stack and sets it as the current state.

void vlVG::VectorGraphics::pushScissor | ( | int | x,
 |  | int | y,
 |  | int | w,
 |  | int | h |
 | ) |  |  | [inline]

Pushes the current scissor in the scissor stack in order to restore it later with popScissor() and activates a new one.

The 'x', 'y', 'w' and 'h' parameters define the new scissor rectangle. Note that such rectangle is clipped against the currently active one.

void vlVG::VectorGraphics::popScissor ( ) [inline]

Pops the top most scissor in the scissor stack and sets it as the current scissor.

const std::vector< vl::ref<vl::Scissor> >& vlVG::VectorGraphics::scissorStack ( ) const [inline]

Returns the scissor stack.

void vlVG::VectorGraphics::setTransform ( vl::Transform * transform ) [inline]

Binds the given Transform to all the Actor[s] that have been generated so far.

vl::Effect* vlVG::VectorGraphics::currentEffect ( ) [inline]

Returns the Effect representing the current VectorGraphic's state.

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/VectorGraphics.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlVolume::MarchingCubes Class Reference

vlVolume::MarchingCubes

vlVolume::MarchingCubes Class Reference

An efficient implementation of the Marching Cubes algorithm. More...

#include <MarchingCubes.hpp>

List of all members.

Classes

struct | Edge

Public Member Functions

MarchingCubes ()
void | run (bool generate_colors)
void | reset ()
const vl::Collection
< VolumeInfo > * 		volumeInfo () const
vl::Collection< VolumeInfo > * volumeInfo ()
void | updateColor (const vl::fvec3 &color, int volume_index)
void | updateColor (const vl::fvec4 &color, int volume_index)
void | updateAlpha (float alpha, int volume_index)
void | setHighQualityNormals (bool hq)
Select hight quality normals for best rendering quality, select low quality normals for best performances.
bool | highQualityNormals () const
Select hight quality normals for best rendering quality, select low quality normals for best performances.

Public Attributes

vl::ref< vl::ArrayFVec3 > mVertsArray
vl::ref< vl::ArrayFVec3 > mNormsArray
vl::ref< vl::ArrayFVec4 > mColorArray
vl::ref< vl::DrawElementsUInt > mDrawElements

Protected Member Functions

void | computeEdges (Volume *, float threshold)
void | processCube (int x, int y, int z, Volume *vol, float threshold)

Static Protected Attributes

static const int | mTriangleConnectionTable [256][16]
static const int | mCubeEdgeFlags [256]

Detailed Description

An efficient implementation of the Marching Cubes algorithm.

Pictures from the Marching Cubes tutorial.

Constructor & Destructor Documentation

MarchingCubes::MarchingCubes ( )

Member Function Documentation

void MarchingCubes::run ( bool generate_colors )

void MarchingCubes::reset ( )

const vl::Collection<VolumeInfo>* vlVolume::MarchingCubes::volumeInfo ( ) const [inline]

vl::Collection<VolumeInfo>* vlVolume::MarchingCubes::volumeInfo ( ) [inline]

void MarchingCubes::updateColor | ( | const vl::fvec3 & | color,
 |  | int | volume_index
 | ) |  |

void MarchingCubes::updateColor | ( | const vl::fvec4 & | color,
 |  | int | volume_index
 | ) |  |

void MarchingCubes::updateAlpha | ( | float | alpha,
 |  | int | volume_index
 | ) |  |

void vlVolume::MarchingCubes::setHighQualityNormals ( bool hq ) [inline]

Select hight quality normals for best rendering quality, select low quality normals for best performances.

bool vlVolume::MarchingCubes::highQualityNormals ( ) const [inline]

Select hight quality normals for best rendering quality, select low quality normals for best performances.

void MarchingCubes::computeEdges | ( | Volume * | vol,
 |  | float | threshold |
 | ) |  |  | [protected]

void MarchingCubes::processCube | ( | int | x,
 |  | int | y,
 |  | int | z,
 |  | Volume * | vol,
 |  | float | threshold |
 | ) |  |  | [protected]

Member Data Documentation

vl::ref<vl::ArrayFVec3> vlVolume::MarchingCubes::mVertsArray

vl::ref<vl::ArrayFVec3> vlVolume::MarchingCubes::mNormsArray

vl::ref<vl::ArrayFVec4> vlVolume::MarchingCubes::mColorArray

vl::ref<vl::DrawElementsUInt> vlVolume::MarchingCubes::mDrawElements

const int MarchingCubes::mTriangleConnectionTable [static, protected]

const int MarchingCubes::mCubeEdgeFlags [static, protected]

Initial value:

{
  0x000, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
  0x190, 0x099, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
  0x230, 0x339, 0x033, 0x13a, 0x636, 0x73f, 0x435, 0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
  0x3a0, 0x2a9, 0x1a3, 0x0aa, 0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
  0x460, 0x569, 0x663, 0x76a, 0x066, 0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
  0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0x0ff, 0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
  0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x055, 0x15c, 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
  0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0x0cc, 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
  0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0x0cc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
  0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x055, 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
  0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc, 0x3f5, 0x0ff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
  0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x066, 0x76a, 0x663, 0x569, 0x460,
  0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0x0aa, 0x1a3, 0x2a9, 0x3a0,
  0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x033, 0x339, 0x230,
  0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x099, 0x190,
  0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x000
}

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlVolume::SlicedVolume Class Reference

vlVolume::SlicedVolume

vlVolume::SlicedVolume Class Reference

An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices. More...

#include <SlicedVolume.hpp>

Inheritance diagram for vlVolume::SlicedVolume:

vl::Actor vl::Object

List of all members.

Public Member Functions

SlicedVolume ()
Constructor.
void | update (int, vl::Camera *camera, vl::Real)
Virtual function used to update or animate an Actor during the rendering.
virtual void | updateUniforms (vl::Camera *camera)
Updates the uniforms used by the vl::GLSLProgram to render the volume each time the update() function is called.
void | setSliceCount (int count)
Defines the number of slices used to render the volume: more slices generate a better rendering.
int | sliceCount () const
Returns the number of slices used to render the volume.
vl::Geometry * geometry ()
Returns the vl::Geometry associated to a SlicedVolume actor.
const vl::Geometry * | geometry () const
Returns the vl::Geometry associated to a SlicedVolume actor.
vl::Effect * effect ()
Returns the vl::Effect associated to a SlicedVolume actor.
const vl::Effect * | effect () const
Returns the vl::Effect associated to a SlicedVolume actor.
void | setBox (const vl::AABB &box)
Defines the dimensions of the box enclosing the volume.
const vl::AABB & | box () const
Defines the dimensions of the box enclosing the volume.
const vl::fvec3 * | texCoords () const
Returns the texture coordinates assigned to each of the 8 box corners.
vl::fvec3 * texCoords ()
Returns the texture coordinates assigned to each of the 8 box corners.
void | generateTextureCoordinates (const vl::ivec3 &size)
Generates a default set of texture coordinates based on the give texture dimensions.
void | generateTextureCoordinates (int width, int height, int depth)
Generates a default set of texture coordinates based on the give texture dimensions.
void | setVolumeImage (vl::Image *volume)
Defines the image containing the volume to be rendered.
const vl::Image * | transferFunction () const
Returns the 1D image used as transfer function for the volume rendering.
vl::Image * transferFunction ()
Returns the 1D image used as transfer function for the volume rendering.
void | setTransferFunction (vl::Image *tfunc)
Sets the 1D image used as transfer function for the volume rendering. Pass NULL to remove the transfer function.
const vl::Light * | light () const
Returns the light used to illuminate the volume.
vl::Light * light ()
Returns the light used to illuminate the volume.
void | setLight (vl::Light *light)
Defines the light used to illuminate the volume.
const vl::GLSLProgram * | glslProgram () const
Returns the GLSL program used for IF_LUMINANCE volume images.
vl::GLSLProgram * glslProgram ()
Returns the GLSL program used for IF_LUMINANCE volume images.

Static Public Member Functions

static vl::ref< vl::Image > | genRGBAVolume (vl::Image *data, vl::Image *trfunc, const vl::fvec3 &light_dir, bool alpha_from_data=true)
Generates an RGBA image that can be passed to setVolumeImage() based on the given data source and transfer function.
static vl::ref< vl::Image > | genRGBAVolume (vl::Image *data, vl::Image *trfunc, bool alpha_from_data=true)
Generates an RGBA image that can be passed to setVolumeImage() based on the given data source and transfer function.

Protected Attributes

int | mSliceCount
vl::ref< vl::Geometry > mGeometry
vl::ref< vl::Effect > mEffect
vl::AABB mBox
vl::fmat4 mCache
vl::fvec3 | mTexCoord [8]
vl::ref< vl::Image > mTransferFunction
vl::ref< vl::Light > mLight
vl::ref< vl::GLSLProgram > mGLSLProgram

Detailed Description

An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices.

Pictures from the Volume Rendering tutorial.

Using the SlicedVolume class is extremely simple, see below. See also the App_VolumeRendering.hpp example.

By default the constructor installs the following shaders /glsl/volume_luminance_light.fs and /glsl/volume_luminance_light.vs and sets the val_threshold uniform variable to 0.5f.

You can change the GLSLProgram settings in the following way:

 glslProgram()->detachAllShaders();
 glslProgram()->attachShader( new vl::GLSLFragmentShader("/mypath/my_fragment_shader.fs") );
 glslProgram()->attachShader( new vl::GLSLVertexShader("/mypath/my_vertex_shader.fs") );
 glslProgram()->gocUniform("my_uniform")->setUniform(value);

You can also reimplement the updateUniforms() method to update your own uniform variables before every rendering frame.

Using an IF_RGBA volume (no GLSL)
 vl::ref<vlVolume::SlicedVolume> volume = new SlicedVolume;
 // loads an IF_RGBA volume (no transfer function is needed in this case)
 vl::ref<vl::Image> rgba_img = vl::loadImage("myvolume.dat");
 // installs the IF_RGBA volume
 volume->setVolumeImage(rgba_img.get());
 // disable GLSL shader
 volume->setTransferFunction(NULL);

Generating an IF_RGBA volume from an IF_LUMINANCE volume + transfer function (no GLSL)
 vl::ref<vlVolume::SlicedVolume> volume = new SlicedVolume;
 // loads an IF_LUMINANCE volume
 vl::ref<vl::Image> img      = vl::loadImage("myvolume.dat");
 // generates a transfer function
 vl::ref<vl::Image> trfunc   = vl::Image::makeColorSpectrum(128, vlut::black, vlut::blue, vlut::green, vlut::yellow, vlut::red);
 // computes an IF_RGBA volume using the transfer function and with lighting
 vl::ref<vl::Image> rgba_img = vlVolume::SlicedVolume::genRGBAVolume(img.get(), trfunc.get(), vl::fvec3(1.0f,1.0f,0.0f));
 // installs the IF_RGBA volume
 volume->setVolumeImage(rgba_img.get());
 // disable GLSL shader
 volume->setTransferFunction(NULL);

Using IF_LUMINANCE volume + transfer function with GLSL (with dynamic Blinn-Phong lighting)
 vl::ref<vlVolume::SlicedVolume> volume = new SlicedVolume;
 // generates and install a transfer function to be used with an IF_LUMINANCE volume.
 vl::ref<vl::Image> trfunc = vl::Image::makeColorSpectrum(128, vlut::black, vlut::blue, vlut::green, vlut::yellow, vlut::red);
 // setTransferFunction() also enables the GLSL shader
 volume->setTransferFunction(trfunc.get());
 // loads and install an IF_LUMINANCE volume.
 vl::ref<vl::Image> img = vl::loadImage("myvolume.dat");
 volume->setVolumeImage(img.get());

Constructor & Destructor Documentation

SlicedVolume::SlicedVolume ( )

Constructor.

Member Function Documentation

void vlVolume::SlicedVolume::update | ( | int | ,
 |  | vl::Camera * | ,
 |  | vl::Real |  |
 | ) |  |  | [virtual]

Virtual function used to update or animate an Actor during the rendering.

Parameters:
lod | the LOD (level of detail) currently selected for the rendering.
camera | the camera used for the current rendering.
cur_t | the current animation time.
Note:
  • is called after the actor resulted to be visible
  • is called only once per frame
  • is called before setting up the rendering states
See also:
  • ActorRenderingCallback
  • renderingCallbacks()

Reimplemented from vl::Actor.

void SlicedVolume::updateUniforms ( vl::Camera * camera ) [virtual]

Updates the uniforms used by the vl::GLSLProgram to render the volume each time the update() function is called.

You can reimplement this function in order to setup your own uniform variable for your GLSLProgram.

The default implementation of this function updates the following two uniforms:

  • light_position Light position in object space, used to compute Blinn-Phong lighting in /glsl/volume_luminance_light.fs
  • eye_position Camera position in object space, used to compute Blinn-Phong lighting in /glsl/volume_luminance_light.fs

void vlVolume::SlicedVolume::setSliceCount ( int count ) [inline]

Defines the number of slices used to render the volume: more slices generate a better rendering.

int vlVolume::SlicedVolume::sliceCount ( ) const [inline]

Returns the number of slices used to render the volume.

vl::Geometry* vlVolume::SlicedVolume::geometry ( ) [inline]

Returns the vl::Geometry associated to a SlicedVolume actor.

const vl::Geometry* vlVolume::SlicedVolume::geometry ( ) const [inline]

Returns the vl::Geometry associated to a SlicedVolume actor.

vl::Effect* vlVolume::SlicedVolume::effect ( ) [inline]

Returns the vl::Effect associated to a SlicedVolume actor.

Reimplemented from vl::Actor.

const vl::Effect* vlVolume::SlicedVolume::effect ( ) const [inline]

Returns the vl::Effect associated to a SlicedVolume actor.

Reimplemented from vl::Actor.

void SlicedVolume::setBox ( const vl::AABB & box )

Defines the dimensions of the box enclosing the volume.

const vl::AABB& vlVolume::SlicedVolume::box ( ) const [inline]

Defines the dimensions of the box enclosing the volume.

const vl::fvec3* vlVolume::SlicedVolume::texCoords ( ) const [inline]

Returns the texture coordinates assigned to each of the 8 box corners.

vl::fvec3* vlVolume::SlicedVolume::texCoords ( ) [inline]

Returns the texture coordinates assigned to each of the 8 box corners.

void SlicedVolume::generateTextureCoordinates ( const vl::ivec3 & size )

Generates a default set of texture coordinates based on the give texture dimensions.

The texture coordinate generated by this function should be used with TexParameter wrap mode vl::TPW_REPEAT, ie:.

vl::ref<vl::Texture> texture = new vl::Texture;
texture->getTexParameter()->setWrapS(vl::TPW_REPEAT);
texture->getTexParameter()->setWrapT(vl::TPW_REPEAT);
texture->getTexParameter()->setWrapR(vl::TPW_REPEAT);

void vlVolume::SlicedVolume::generateTextureCoordinates | ( | int | width,
 |  | int | height,
 |  | int | depth |
 | ) |  |  | [inline]

Generates a default set of texture coordinates based on the give texture dimensions.

void SlicedVolume::setVolumeImage ( vl::Image * volume )

Defines the image containing the volume to be rendered.

This function also generates a 3D texture based on the given image and generates an appropriate set of texture coordinates.

const vl::Image* vlVolume::SlicedVolume::transferFunction ( ) const [inline]

Returns the 1D image used as transfer function for the volume rendering.

vl::Image* vlVolume::SlicedVolume::transferFunction ( ) [inline]

Returns the 1D image used as transfer function for the volume rendering.

void SlicedVolume::setTransferFunction ( vl::Image * tfunc )

Sets the 1D image used as transfer function for the volume rendering. Pass NULL to remove the transfer function.

Selecting a transfer function != NULL automatically enables the GLSL shader returned by glslProgram().

Call setTransferFunction(NULL) to disable the GLSL program. Based on the img format an appropriate rendering method is selected:

  • If tfunc is NULL then it is assumed that the image set by setVolumeImage() contains already the appropriate colors and alpha values as a result of a transfer function and/or lighting computations (see genRGBAVolume()). This is the preferred method for legacy hardware as it does not require GLSL support but can require 4 times more memory and cannot perform realtime-animated lighting.
  • If tfunc is non-NULL then the image set by setVolumeImage() should have IF_LUMINANCE format() and contains the raw volume data. A GLSL program is used in order to execute the transfer function and the lighting computations. In this case the tranfer function tfunc is used. This method requires GLSL support, needs less memory and can perform realtime-animated Blinn-Phong lighting.

const vl::Light* vlVolume::SlicedVolume::light ( ) const [inline]

Returns the light used to illuminate the volume.

vl::Light* vlVolume::SlicedVolume::light ( ) [inline]

Returns the light used to illuminate the volume.

void vlVolume::SlicedVolume::setLight ( vl::Light * light ) [inline]

Defines the light used to illuminate the volume.

const vl::GLSLProgram* vlVolume::SlicedVolume::glslProgram ( ) const [inline]

Returns the GLSL program used for IF_LUMINANCE volume images.

vl::GLSLProgram* vlVolume::SlicedVolume::glslProgram ( ) [inline]

Returns the GLSL program used for IF_LUMINANCE volume images.

ref< Image > SlicedVolume::genRGBAVolume | ( | vl::Image * | data,
 |  | vl::Image * | trfunc,
 |  | const vl::fvec3 & | light_dir,
 |  | bool | alpha_from_data = true |
 | ) |  |  | [static]

Generates an RGBA image that can be passed to setVolumeImage() based on the given data source and transfer function.

Parameters:
data | The vl::Image used as the volume data source. It must have format() equal to IF_LUMINANCE and type() equal to IT_UNSIGNED_BYTE, IT_UNSIGNED_SHORT or IT_UNSIGNED_FLOAT.
trfunc | An 1D vl::Image used as transfer function that is used to assign to each value in data an RGBA quadruplets in the new image. The vl::Image pointed by trfunc must mast have type() IT_UNSIGNED_BYTE and format() IF_RGBA.
light_dir | The direction of the light in object space.
alpha_from_data | If set to true the alpha channel of the generated image will be taken from data otherwise from the transfer function.

ref< Image > SlicedVolume::genRGBAVolume | ( | vl::Image * | data,
 |  | vl::Image * | trfunc,
 |  | bool | alpha_from_data = true |
 | ) |  |  | [static]

Generates an RGBA image that can be passed to setVolumeImage() based on the given data source and transfer function.

Parameters:
data | The vl::Image used as the volume data source. It must have format() equal to IF_LUMINANCE and type() equal to IT_UNSIGNED_BYTE, IT_UNSIGNED_SHORT or IT_UNSIGNED_FLOAT.
trfunc | An 1D vl::Image used as transfer function that is used to assign to each value in data an RGBA quadruplets in the new image. The vl::Image pointed by trfunc must mast have type() IT_UNSIGNED_BYTE and format() IF_RGBA.
alpha_from_data | If set to true the alpha channel of the generated image will be taken from data otherwise from the transfer function.
Unlike genRGBAVolume(vl::Image* data, vl::Image* trfunc, const vl::fvec3& light_dir, bool alpha_from_data=true) this function does not compute lighting.

Member Data Documentation

int vlVolume::SlicedVolume::mSliceCount [protected]

vl::ref<vl::Geometry> vlVolume::SlicedVolume::mGeometry [protected]

vl::ref<vl::Effect> vlVolume::SlicedVolume::mEffect [protected]

Reimplemented from vl::Actor.

vl::AABB vlVolume::SlicedVolume::mBox [protected]

vl::fmat4 vlVolume::SlicedVolume::mCache [protected]

vl::fvec3 vlVolume::SlicedVolume::mTexCoord[8] [protected]

vl::ref<vl::Image> vlVolume::SlicedVolume::mTransferFunction [protected]

vl::ref<vl::Light> vlVolume::SlicedVolume::mLight [protected]

vl::ref<vl::GLSLProgram> vlVolume::SlicedVolume::mGLSLProgram [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlVolume::Volume Class Reference

vlVolume::Volume

vlVolume::Volume Class Reference

Defines the volume data to be used with a MarchingCube object. More...

#include <MarchingCubes.hpp>

Inheritance diagram for vlVolume::Volume:

vl::Object

List of all members.

Classes

struct | Cube
A Volume cell.

Public Member Functions

Volume ()
virtual const char * | className ()
Returns the name of the class.
void | setup (float *data, const vl::fvec3 &bottom_left, const vl::fvec3 &top_right, const vl::ivec3 &slices)
void | setup (const Volume &)
vl::ref< Volume > | downsample () const
Returns a new volume which is half of the size of the original volume in each direction (thus requires up to 1/8th of the memory).
const float * | values () const
float * | values ()
const float & | value (int i) const
float & | value (int i)
const float & | value (int x, int y, int z) const
float & | value (int x, int y, int z)
void | normalHQ (vl::fvec3 &normal, const vl::fvec3 &v, float dx, float dy, float dz)
Computes a high quality normal (best rendering quality).
void | normalLQ (vl::fvec3 &normal, const vl::fvec3 &v, float dx, float dy, float dz)
Computes a low quality normal (best performances).
float | sampleSmooth (float x, float y, float z) const
Samples the volume using tri-linear interpolation sampling.
float | sampleNearest (float x, float y, float z) const
Samples the volume using nearest point sampling.
vl::fvec3 | coordinate (int x, int y, int z) const
const vl::fvec3 & | bottomLeft () const
const vl::fvec3 & | topRight () const
const vl::ivec3 & | slices () const
vl::fvec3 | size () const
float | computeMinimum () const
float | computeMaximum () const
float | computeAverage () const
float | minimum () const
float | maximum () const
float | average () const
const Volume::Cube & | cube (int x, int y, int z) const
const vl::fvec3 & | cellSize () const
Returns the x/y/z size of a cell.
bool | dataIsDirty () const
Returns true if the internal data hasn't been updated since the last call to setDataDirty() or setup().
void | setDataDirty ()
Notifies that the data of a Volume has changed and that the internal acceleration structures should be recomputed.
void | setupInternalData ()

Protected Attributes

std::vector< float > | mValues
vl::fvec3 mBottomLeft
vl::fvec3 mTopRight
vl::fvec3 mSize
vl::ivec3 mSlices
vl::fvec3 mCellSize
float | mMinimum
float | mMaximum
float | mAverage
bool | mDataIsDirty
std::vector< Cube > | mCubes

Detailed Description

Defines the volume data to be used with a MarchingCube object.

Constructor & Destructor Documentation

Volume::Volume ( )

Member Function Documentation

virtual const char* vlVolume::Volume::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void Volume::setup | ( | float * | data,
 |  | const vl::fvec3 & | bottom_left,
 |  | const vl::fvec3 & | top_right,
 |  | const vl::ivec3 & | slices
 | ) |  |

void Volume::setup ( const Volume & volume )

ref< Volume > Volume::downsample ( ) const

Returns a new volume which is half of the size of the original volume in each direction (thus requires up to 1/8th of the memory).

Use this function when the volume data to be processed is too big or produces too many polygons.

const float* vlVolume::Volume::values ( ) const [inline]

float* vlVolume::Volume::values ( ) [inline]

const float& vlVolume::Volume::value ( int i ) const [inline]

float& vlVolume::Volume::value ( int i ) [inline]

const float& vlVolume::Volume::value | ( | int | x,
 |  | int | y,
 |  | int | z |
 | ) |  |  | const [inline]

float& vlVolume::Volume::value | ( | int | x,
 |  | int | y,
 |  | int | z |
 | ) |  |  | [inline]

void Volume::normalHQ | ( | vl::fvec3 & | normal,
 |  | const vl::fvec3 & | v,
 |  | float | dx,
 |  | float | dy,
 |  | float | dz
 | ) |  |

Computes a high quality normal (best rendering quality).

void Volume::normalLQ | ( | vl::fvec3 & | normal,
 |  | const vl::fvec3 & | v,
 |  | float | dx,
 |  | float | dy,
 |  | float | dz
 | ) |  |

Computes a low quality normal (best performances).

float Volume::sampleSmooth | ( | float | x,
 |  | float | y,
 |  | float | z |
 | ) |  |  | const

Samples the volume using tri-linear interpolation sampling.

float Volume::sampleNearest | ( | float | x,
 |  | float | y,
 |  | float | z |
 | ) |  |  | const

Samples the volume using nearest point sampling.

vl::fvec3 vlVolume::Volume::coordinate | ( | int | x,
 |  | int | y,
 |  | int | z |
 | ) |  |  | const [inline]

const vl::fvec3& vlVolume::Volume::bottomLeft ( ) const [inline]

const vl::fvec3& vlVolume::Volume::topRight ( ) const [inline]

const vl::ivec3& vlVolume::Volume::slices ( ) const [inline]

vl::fvec3 vlVolume::Volume::size ( ) const [inline]

float Volume::computeMinimum ( ) const

float Volume::computeMaximum ( ) const

float Volume::computeAverage ( ) const

float vlVolume::Volume::minimum ( ) const [inline]

float vlVolume::Volume::maximum ( ) const [inline]

float vlVolume::Volume::average ( ) const [inline]

const Volume::Cube& vlVolume::Volume::cube | ( | int | x,
 |  | int | y,
 |  | int | z |
 | ) |  |  | const [inline]

const vl::fvec3& vlVolume::Volume::cellSize ( ) const [inline]

Returns the x/y/z size of a cell.

bool vlVolume::Volume::dataIsDirty ( ) const [inline]

Returns true if the internal data hasn't been updated since the last call to setDataDirty() or setup().

void vlVolume::Volume::setDataDirty ( ) [inline]

Notifies that the data of a Volume has changed and that the internal acceleration structures should be recomputed.

void Volume::setupInternalData ( )

Member Data Documentation

std::vector<float> vlVolume::Volume::mValues [protected]

vl::fvec3 vlVolume::Volume::mBottomLeft [protected]

vl::fvec3 vlVolume::Volume::mTopRight [protected]

vl::fvec3 vlVolume::Volume::mSize [protected]

vl::ivec3 vlVolume::Volume::mSlices [protected]

vl::fvec3 vlVolume::Volume::mCellSize [protected]

float vlVolume::Volume::mMinimum [protected]

float vlVolume::Volume::mMaximum [protected]

float vlVolume::Volume::mAverage [protected]

bool vlVolume::Volume::mDataIsDirty [protected]

std::vector<Cube> vlVolume::Volume::mCubes [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlVolume::VolumeInfo Class Reference

vlVolume::VolumeInfo

vlVolume::VolumeInfo Class Reference

Defines the volume parameters to be used with a MarchingCube and Volume object. More...

#include <MarchingCubes.hpp>

Inheritance diagram for vlVolume::VolumeInfo:

vl::Object

List of all members.

Public Member Functions

virtual const char * | className ()
Returns the name of the class.
VolumeInfo (Volume *vol, float threshold, const vl::fvec4 &color)
VolumeInfo (Volume *vol, float threshold)
void | setColor (const vl::fvec4 &col)
const vl::fvec4 & | color () const
void | setThreshold (float t)
float | threshold () const
void | setVolume (Volume *vol)
Volume * | volume () const
void | setVert0 (int index)
int | vert0 () const
void | setVertC (int count)
int | vertC () const

Protected Attributes

vl::fvec4 mColor
float | mThreshold
vl::ref< Volume > mVolume
int | mVert0
int | mVertC

Detailed Description

Defines the volume parameters to be used with a MarchingCube and Volume object.

Constructor & Destructor Documentation

vlVolume::VolumeInfo::VolumeInfo | ( | Volume * | vol,
 |  | float | threshold,
 |  | const vl::fvec4 & | color |
 | ) |  |  | [inline]

vlVolume::VolumeInfo::VolumeInfo | ( | Volume * | vol,
 |  | float | threshold |
 | ) |  |  | [inline]

Member Function Documentation

virtual const char* vlVolume::VolumeInfo::className ( ) [inline, virtual]

Returns the name of the class.

Reimplemented from vl::Object.

void vlVolume::VolumeInfo::setColor ( const vl::fvec4 & col ) [inline]

const vl::fvec4& vlVolume::VolumeInfo::color ( ) const [inline]

void vlVolume::VolumeInfo::setThreshold ( float t ) [inline]

float vlVolume::VolumeInfo::threshold ( ) const [inline]

void vlVolume::VolumeInfo::setVolume ( Volume * vol ) [inline]

Volume* vlVolume::VolumeInfo::volume ( ) const [inline]

void vlVolume::VolumeInfo::setVert0 ( int index ) [inline]

int vlVolume::VolumeInfo::vert0 ( ) const [inline]

void vlVolume::VolumeInfo::setVertC ( int count ) [inline]

int vlVolume::VolumeInfo::vertC ( ) const [inline]

Member Data Documentation

vl::fvec4 vlVolume::VolumeInfo::mColor [protected]

float vlVolume::VolumeInfo::mThreshold [protected]

vl::ref<Volume> vlVolume::VolumeInfo::mVolume [protected]

int vlVolume::VolumeInfo::mVert0 [protected]

int vlVolume::VolumeInfo::mVertC [protected]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlVolume::VolumePlot Class Reference

vlVolume::VolumePlot

vlVolume::VolumePlot Class Reference

Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm. More...

#include <VolumePlot.hpp>

Inheritance diagram for vlVolume::VolumePlot:

vl::Object

List of all members.

Classes

class | Function
A function to be used with VolumePlot. More...

Public Member Functions

VolumePlot ()
Constructor.
void | compute (const Function &func, float threshold)
Computes the function and generates the plot. This method should be called after all the other methods.
const vl::Actor * | isosurfaceActor () const
The Actor representing the isosurface.
vl::Actor * isosurfaceActor ()
The Actor representing the isosurface.
const vl::Geometry * | isosurfaceGeometry () const
The Geometry representing the isosurface.
vl::Geometry * isosurfaceGeometry ()
The Geometry representing the isosurface.
const vl::Effect * | isosurfaceEffect () const
Used to get/set the rendering options (like color, material, transparency) etc. of the isosurface.
vl::Effect * isosurfaceEffect ()
Used to get/set the rendering options (like color, material, transparency) etc. of the isosurface.
const vl::Effect * | boxEffect () const
Used to get/set the rendering options (like color, material, transparency) etc. of the box.
vl::Effect * boxEffect ()
Used to get/set the rendering options (like color, material, transparency) etc. of the box.
const vl::fvec3 & | minCorner () const
Default value: vl::fvec3(-1,-1,-1).
void | setMinCorner (const vl::fvec3 &min_corner)
Default value: vl::fvec3(-1,-1,-1).
const vl::fvec3 & | maxCorner () const
Default value: vl::fvec3(+1,+1,+1).
void | setMaxCorner (const vl::fvec3 &max_corner)
Default value: vl::fvec3(+1,+1,+1).
vl::Transform * | plotTransform () const
The transform associated to the whole plot.
void | setPlotTransform (vl::Transform *tr)
The transform associated to the whole plot.
const vl::ivec3 & | samplingResolution () const
Default value: vl::ivec3(64,64,64).
void | setSamplingResolution (const vl::ivec3 &size)
Default value: vl::ivec3(64,64,64).
const vl::String & | labelFormat () const
Sets the format of the labels.
void | setLabelFormat (const vl::String &format)
Sets the format of the label to be generated, es. "(%.2n %.2n %.2n)" or "<%.3n, %.3n, %.3n>".
vl::Font * | labelFont () const
The Font to be used for the box labels.
void | setLabelFont (vl::Font *font)
The Font to be used for the box labels.
const vl::Text * | textTemplate () const
A Text used to initialize the plot labels.
vl::Text * textTemplate ()
A Text used to initialize the plot labels.
vl::ActorTree * actorTreeMulti ()
const vl::ActorTree * | actorTreeMulti () const

Protected Member Functions

void | setupLabels (const vl::String &format, const vl::fvec3 &min_corner, const vl::fvec3 &max_corner, vl::Font *font, vl::Transform *root_tr)
void | evaluateFunction (float *scalar, const vl::fvec3 &min_corner, const vl::fvec3 &max_corner, const Function &func)

Protected Attributes

std::vector< vl::ref< vl::Actor > > | mActors
vl::ref< vl::Transform > mPlotTransform
vl::ivec3 mSamplingResolution
vl::String mLabelFormat
vl::ref< vl::Font > mLabelFont
vl::fvec3 mMinCorner
vl::fvec3 mMaxCorner
vl::ref< vl::Geometry > mIsosurfaceGeometry
vl::ref< vl::Actor > mIsosurfaceActor
vl::ref< vl::Effect > mIsosurfaceEffect
vl::ref< vl::Effect > mBoxEffect
vl::ref< vl::Text > mTextTemplate
vl::ref< vl::ActorTree > mActorTreeMulti

Detailed Description

Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm.

Example:

  float range = 5.0f;
  vl::fvec3 min_corner(-range,-range,-range);
  vl::fvec3 max_corner(+range,+range,+range);

  vlVolume::VolumePlot plot;
  // set the function sampling space
  plot.setMinCorner(min_corner);
  plot.setMaxCorner(max_corner);
  // set various rendering options
  plot.isosurfaceEffect()->shader()->gocMaterial()->setSpecular(vlut::white);
  plot.isosurfaceEffect()->shader()->gocMaterial()->setShininess(50.0f);
  plot.isosurfaceEffect()->shader()->gocMaterial()->setDiffuse(vl::fvec4(1.0f,0,0,0.5f));
  plot.isosurfaceEffect()->shader()->enable(vl::EN_BLEND);
  plot.isosurfaceActor()->renderingCallbacks()->push_back( new vl::DepthSortCallback );
  plot.textTemplate()->setColor(vlut::yellow);
  // set the sampling resolution along the x, y and z directions
  plot.setSamplingResolution(vl::ivec3(100,100,100));
  // function computation and plot generation
  plot.compute( my_func(), 0.900f );
  sceneManager()->tree()->addChild(plot.actorTreeMulti());

Constructor & Destructor Documentation

VolumePlot::VolumePlot ( )

Constructor.

Member Function Documentation

void VolumePlot::compute | ( | const Function & | func,
 |  | float | threshold
 | ) |  |

Computes the function and generates the plot. This method should be called after all the other methods.

Parameters:
func | The function to be evaluated at each grid point.
threshold | The isovalue of the isosurface passed to the vlVolume::MarcingCubes algorithm.
sm | The vl::SceneManager that will hold the plot.

const vl::Actor* vlVolume::VolumePlot::isosurfaceActor ( ) const [inline]

The Actor representing the isosurface.

vl::Actor* vlVolume::VolumePlot::isosurfaceActor ( ) [inline]

The Actor representing the isosurface.

const vl::Geometry* vlVolume::VolumePlot::isosurfaceGeometry ( ) const [inline]

The Geometry representing the isosurface.

vl::Geometry* vlVolume::VolumePlot::isosurfaceGeometry ( ) [inline]

The Geometry representing the isosurface.

const vl::Effect* vlVolume::VolumePlot::isosurfaceEffect ( ) const [inline]

Used to get/set the rendering options (like color, material, transparency) etc. of the isosurface.

vl::Effect* vlVolume::VolumePlot::isosurfaceEffect ( ) [inline]

Used to get/set the rendering options (like color, material, transparency) etc. of the isosurface.

const vl::Effect* vlVolume::VolumePlot::boxEffect ( ) const [inline]

Used to get/set the rendering options (like color, material, transparency) etc. of the box.

vl::Effect* vlVolume::VolumePlot::boxEffect ( ) [inline]

Used to get/set the rendering options (like color, material, transparency) etc. of the box.

const vl::fvec3& vlVolume::VolumePlot::minCorner ( ) const [inline]

Default value: vl::fvec3(-1,-1,-1).

void vlVolume::VolumePlot::setMinCorner ( const vl::fvec3 & min_corner ) [inline]

Default value: vl::fvec3(-1,-1,-1).

const vl::fvec3& vlVolume::VolumePlot::maxCorner ( ) const [inline]

Default value: vl::fvec3(+1,+1,+1).

void vlVolume::VolumePlot::setMaxCorner ( const vl::fvec3 & max_corner ) [inline]

Default value: vl::fvec3(+1,+1,+1).

vl::Transform* vlVolume::VolumePlot::plotTransform ( ) const [inline]

The transform associated to the whole plot.

void vlVolume::VolumePlot::setPlotTransform ( vl::Transform * tr ) [inline]

The transform associated to the whole plot.

const vl::ivec3& vlVolume::VolumePlot::samplingResolution ( ) const [inline]

Default value: vl::ivec3(64,64,64).

void vlVolume::VolumePlot::setSamplingResolution ( const vl::ivec3 & size ) [inline]

Default value: vl::ivec3(64,64,64).

const vl::String& vlVolume::VolumePlot::labelFormat ( ) const [inline]

Sets the format of the labels.

void vlVolume::VolumePlot::setLabelFormat ( const vl::String & format ) [inline]

Sets the format of the label to be generated, es. "(%.2n %.2n %.2n)" or "<%.3n, %.3n, %.3n>".

vl::Font* vlVolume::VolumePlot::labelFont ( ) const [inline]

The Font to be used for the box labels.

void vlVolume::VolumePlot::setLabelFont ( vl::Font * font ) [inline]

The Font to be used for the box labels.

const vl::Text* vlVolume::VolumePlot::textTemplate ( ) const [inline]

A Text used to initialize the plot labels.

vl::Text* vlVolume::VolumePlot::textTemplate ( ) [inline]

A Text used to initialize the plot labels.

vl::ActorTree* vlVolume::VolumePlot::actorTreeMulti ( ) [inline]

const vl::ActorTree* vlVolume::VolumePlot::actorTreeMulti ( ) const [inline]

void VolumePlot::setupLabels | ( | const vl::String & | format,
 |  | const vl::fvec3 & | min_corner,
 |  | const vl::fvec3 & | max_corner,
 |  | vl::Font * | font,
 |  | vl::Transform * | root_tr |
 | ) |  |  | [protected]

void VolumePlot::evaluateFunction | ( | float * | scalar,
 |  | const vl::fvec3 & | min_corner,
 |  | const vl::fvec3 & | max_corner,
 |  | const Function & | func |
 | ) |  |  | [protected]

Member Data Documentation

std::vector< vl::ref<vl::Actor> > vlVolume::VolumePlot::mActors [protected]

vl::ref<vl::Transform> vlVolume::VolumePlot::mPlotTransform [protected]

vl::ivec3 vlVolume::VolumePlot::mSamplingResolution [protected]

vl::String vlVolume::VolumePlot::mLabelFormat [protected]

vl::ref< vl::Font > vlVolume::VolumePlot::mLabelFont [protected]

vl::fvec3 vlVolume::VolumePlot::mMinCorner [protected]

vl::fvec3 vlVolume::VolumePlot::mMaxCorner [protected]

vl::ref<vl::Geometry> vlVolume::VolumePlot::mIsosurfaceGeometry [protected]

vl::ref<vl::Actor> vlVolume::VolumePlot::mIsosurfaceActor [protected]

vl::ref<vl::Effect> vlVolume::VolumePlot::mIsosurfaceEffect [protected]

vl::ref<vl::Effect> vlVolume::VolumePlot::mBoxEffect [protected]

vl::ref<vl::Text> vlVolume::VolumePlot::mTextTemplate [protected]

vl::ref<vl::ActorTree> vlVolume::VolumePlot::mActorTreeMulti [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlVolume::VolumePlot::Function Class Reference

vlVolume::VolumePlot::Function

vlVolume::VolumePlot::Function Class Reference

A function to be used with VolumePlot. More...

#include <VolumePlot.hpp>

List of all members.

Public Member Functions

virtual float operator() (float x, float y, float z) const =0

Detailed Description

A function to be used with VolumePlot.

Member Function Documentation

virtual float vlVolume::VolumePlot::Function::operator() | ( | float | x,
 |  | float | y,
 |  | float | z |
 | ) |  |  | const [pure virtual]

The documentation for this class was generated from the following file:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlWin32::Win32Context Class Reference

vlWin32::Win32Context

vlWin32::Win32Context Class Reference

The Win32Context class implements an OpenGLContext using the Win32 API. More...

#include <Win32Context.hpp>

Inheritance diagram for vlWin32::Win32Context:

vl::OpenGLContext vl::Object vlMFC::MFCWindow vlWin32::Win32Window

List of all members.

Public Member Functions

Win32Context ()
Win32Context (int w, int h)
virtual HWND | hwnd () const =0
HDC | hdc () const
HGLRC | hglrc () const
void | shareOpenGLResources (HGLRC hGLRC)
Use this function when you want two OpenGL contexts to share their resources (display lists, textures, shader objects, buffer objects etc.
void | makeCurrent ()
void | update ()
void | swapBuffers ()
void | setWindowTitle (const vl::String &title)
void | show ()
void | hide ()
void | getFocus ()
void | setMouseVisible (bool visible)
void | setMousePosition (int x, int y)
void | setPosition (int x, int y)
vl::ivec2 | position () const
void | setSize (int w, int h)
The actual size of the OpenGL context, i.e.
vl::ivec2 | size () const
The actual size of the OpenGL context, i.e. the client area if this is a window.
void | setWindowSize (int w, int h)
Sets the size of the window. Note that if this Win32Window has window decorations the actual OpenGL context will be smaller than the given w and h parameters.
vl::ivec2 | windowSize () const
Returns the size of the window and not the client area.
bool | setFullscreen (bool fullscreen_on)
void | quitApplication ()
Calls the PostQuitMessage(0) function (Win32 API).

Protected Member Functions

bool | init (HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x, int y, int width, int height)

Protected Attributes

HDC | mHDC
HGLRC | mHGLRC
vl::ivec2 mNormPosit
vl::ivec2 mNormSize
unsigned | mNormFlags

Detailed Description

The Win32Context class implements an OpenGLContext using the Win32 API.

Constructor & Destructor Documentation

vlWin32::Win32Context::Win32Context ( ) [inline]

vlWin32::Win32Context::Win32Context | ( | int | w,
 |  | int | h |
 | ) |  |  | [inline]

Member Function Documentation

virtual HWND vlWin32::Win32Context::hwnd ( ) const [pure virtual]

Implemented in vlWin32::Win32Window, and vlMFC::MFCWindow.

HDC vlWin32::Win32Context::hdc ( ) const [inline]

HGLRC vlWin32::Win32Context::hglrc ( ) const [inline]

void Win32Context::shareOpenGLResources ( HGLRC hGLRC )

Use this function when you want two OpenGL contexts to share their resources (display lists, textures, shader objects, buffer objects etc.

) Equivalent to wglShareLists(this->hglrc(), hGLRC)

Remarks:
If you want to share resources among two or more OpenGL contexts, you must call this function before you start creating any resources.

void Win32Context::makeCurrent ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::update ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::swapBuffers ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::setWindowTitle ( const vl::String & title ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::show ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::hide ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::getFocus ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::setMouseVisible ( bool visible ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::setMousePosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::setPosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

vl::ivec2 Win32Context::position ( ) const [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::setSize | ( | int | w,
 |  | int | h |
 | ) |  |  | [virtual]

The actual size of the OpenGL context, i.e.

the client area if this is a window. Note that if this Win32Window has window decorations the actual window size will be bigger than the given w and h parameters.

Reimplemented from vl::OpenGLContext.

vl::ivec2 Win32Context::size ( ) const [virtual]

The actual size of the OpenGL context, i.e. the client area if this is a window.

Reimplemented from vl::OpenGLContext.

void Win32Context::setWindowSize | ( | int | w,
 |  | int | h
 | ) |  |

Sets the size of the window. Note that if this Win32Window has window decorations the actual OpenGL context will be smaller than the given w and h parameters.

vl::ivec2 Win32Context::windowSize ( ) const

Returns the size of the window and not the client area.

Use the size() method if you need the size of the actual OpenGL rendering context.

Note:
windowSize() can be different from size() because of the space taken by the window caption and decorations.

bool Win32Context::setFullscreen ( bool fullscreen_on ) [virtual]

Reimplemented from vl::OpenGLContext.

void Win32Context::quitApplication ( ) [virtual]

Calls the PostQuitMessage(0) function (Win32 API).

Reimplemented from vl::OpenGLContext.

bool Win32Context::init | ( | HGLRC | share_context,
 |  | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | fmt,
 |  | int | x,
 |  | int | y,
 |  | int | width,
 |  | int | height |
 | ) |  |  | [protected]

Member Data Documentation

HDC vlWin32::Win32Context::mHDC [protected]

HGLRC vlWin32::Win32Context::mHGLRC [protected]

vl::ivec2 vlWin32::Win32Context::mNormPosit [protected]

vl::ivec2 vlWin32::Win32Context::mNormSize [protected]

unsigned vlWin32::Win32Context::mNormFlags [protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlWin32::Win32Window Class Reference

vlWin32::Win32Window

vlWin32::Win32Window Class Reference

The Win32Window class is a Win32Context that can be used as a top or child window. More...

#include <Win32Window.hpp>

Inheritance diagram for vlWin32::Win32Window:

vlWin32::Win32Context vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

Win32Window ()
bool | initWin32Window (HWND parent, HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x=0, int y=0, int width=640, int height=480)
Initializes a new Win32 window with a new OpenGL rendering context.
virtual void | destroy ()
calls destroyWindow() and dispatches the destroy event to the UIEventListener objects
void | destroyWindow ()
Destroyes the window and the OpenGL rendering context.
HWND | hwnd () const
DWORD | style () const
The dwExStyle parameter passed to the Win32 function CreateWindowEx.
void | setStyle (DWORD style)
The dwExStyle parameter passed to the Win32 function CreateWindowEx.
DWORD | exStyle () const
The dwStyle parameter passed to the Win32 function CreateWindowEx.
void | setExStyle (DWORD ex_style)
The dwStyle parameter passed to the Win32 function CreateWindowEx.
const wchar_t * | windowClassName () const
Specifies the value given to the lpClassName parameter passed to CreateWindowEx.
void | setWindowClassName (const wchar_t *name)
Specifies the value given to the lpClassName parameter passed to CreateWindowEx.

Static Public Member Functions

static LONG WINAPI | WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static Win32Window * | getWindow (HWND hWnd)
Returns when a WM_QUIT message is sent or when no more windows are alive.
static const std::map< HWND,
Win32Window * > & 		winMap ()

Static Public Attributes

static const wchar_t * | Win32WindowClassName = L"VisualizationLibraryWindowClass"

Protected Attributes

int | mMouseDownCount
HWND | mHWND
DWORD | mStyle
DWORD | mExStyle
const wchar_t * | mWindowClassName

Static Protected Attributes

static std::map< HWND,
Win32Window * > 		mWinMap

Detailed Description

The Win32Window class is a Win32Context that can be used as a top or child window.

Constructor & Destructor Documentation

Win32Window::Win32Window ( )

Member Function Documentation

LONG WINAPI Win32Window::WindowProc | ( | HWND | hWnd,
 |  | UINT | uMsg,
 |  | WPARAM | wParam,
 |  | LPARAM | lParam |
 | ) |  |  | [static]

bool Win32Window::initWin32Window | ( | HWND | parent,
 |  | HGLRC | share_context,
 |  | const vl::String & | title,
 |  | const vl::OpenGLContextFormat & | fmt,
 |  | int | x = 0,
 |  | int | y = 0,
 |  | int | width = 640,
 |  | int | height = 480
 | ) |  |

Initializes a new Win32 window with a new OpenGL rendering context.

After the initialization to show the window use the show() method.

void Win32Window::destroy ( ) [virtual]

calls destroyWindow() and dispatches the destroy event to the UIEventListener objects

Reimplemented from vl::OpenGLContext.

void Win32Window::destroyWindow ( )

Destroyes the window and the OpenGL rendering context.

HWND vlWin32::Win32Window::hwnd ( ) const [inline, virtual]

Implements vlWin32::Win32Context.

DWORD vlWin32::Win32Window::style ( ) const [inline]

The dwExStyle parameter passed to the Win32 function CreateWindowEx.

void vlWin32::Win32Window::setStyle ( DWORD style ) [inline]

The dwExStyle parameter passed to the Win32 function CreateWindowEx.

DWORD vlWin32::Win32Window::exStyle ( ) const [inline]

The dwStyle parameter passed to the Win32 function CreateWindowEx.

void vlWin32::Win32Window::setExStyle ( DWORD ex_style ) [inline]

The dwStyle parameter passed to the Win32 function CreateWindowEx.

const wchar_t* vlWin32::Win32Window::windowClassName ( ) const [inline]

Specifies the value given to the lpClassName parameter passed to CreateWindowEx.

void vlWin32::Win32Window::setWindowClassName ( const wchar_t * name ) [inline]

Specifies the value given to the lpClassName parameter passed to CreateWindowEx.

Win32Window * Win32Window::getWindow ( HWND hWnd ) [static]

Returns when a WM_QUIT message is sent or when no more windows are alive.

static const std::map< HWND, Win32Window* >& vlWin32::Win32Window::winMap ( ) [inline, static]

Member Data Documentation

const wchar_t * Win32Window::Win32WindowClassName = L"VisualizationLibraryWindowClass" [static]

int vlWin32::Win32Window::mMouseDownCount [protected]

HWND vlWin32::Win32Window::mHWND [protected]

DWORD vlWin32::Win32Window::mStyle [protected]

DWORD vlWin32::Win32Window::mExStyle [protected]

const wchar_t* vlWin32::Win32Window::mWindowClassName [protected]

std::map< HWND, Win32Window * > Win32Window::mWinMap [static, protected]

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlWX::vlWXGLCanvas Class Reference

vlWX::vlWXGLCanvas

vlWX::vlWXGLCanvas Class Reference

The vlWXGLCanvas class implements a vl::OpenGLContext using the wxWidgets library. More...

#include <vlWXGLCanvas.hpp>

Inheritance diagram for vlWX::vlWXGLCanvas:

vl::OpenGLContext vl::Object

List of all members.

Public Member Functions

vlWXGLCanvas (wxWindow *parent, const wxGLContext *shared, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, int *attribList=0, const wxString &name=wxT("vlWXGLCanvas"), const wxPalette &palette=wxNullPalette)
~vlWXGLCanvas ()
void | OnPaint (wxPaintEvent &ev)
void | OnSize (wxSizeEvent &ev)
void | OnEraseBackground (wxEraseEvent &ev)
void | OnKeyDown (wxKeyEvent &ev)
void | OnKeyUp (wxKeyEvent &ev)
void | OnMouseMotion (wxMouseEvent &ev)
void | OnMouseDown (wxMouseEvent &ev)
void | OnMouseUp (wxMouseEvent &ev)
void | OnMouseWheel (wxMouseEvent &ev)
void | OnMouseEnter (wxMouseEvent &ev)
void | OnIdle (wxIdleEvent &ev)
void | OnDropFiles (wxDropFilesEvent &ev)
bool | setFullscreen (bool fullscreen)
void | quitApplication ()
Asks to the windowing system that is managing the OpenGLContext to quit the application.
void | makeCurrent ()
void | swapBuffers ()
void | getFocus ()
void | setMousePosition (int x, int y)
void | update ()
void | setWindowTitle (const vl::String &text)
void | show ()
void | hide ()
void | setPosition (int x, int y)
void | setSize (int w, int h)
vl::ivec2 | position () const
void | setMouseVisible (bool visible)

Detailed Description

The vlWXGLCanvas class implements a vl::OpenGLContext using the wxWidgets library.

Constructor & Destructor Documentation

vlWXGLCanvas::vlWXGLCanvas | ( | wxWindow * | parent,
 |  | const wxGLContext * | shared,
 |  | wxWindowID | id = wxID_ANY,
 |  | const wxPoint & | pos = wxDefaultPosition,
 |  | const wxSize & | size = wxDefaultSize,
 |  | long | style = 0,
 |  | int * | attribList = 0,
 |  | const wxString & | name = wxT("vlWXGLCanvas"),
 |  | const wxPalette & | palette = wxNullPalette
 | ) |  |

vlWX::vlWXGLCanvas::~vlWXGLCanvas ( ) [inline]

Member Function Documentation

void vlWXGLCanvas::OnPaint ( wxPaintEvent & ev )

void vlWXGLCanvas::OnSize ( wxSizeEvent & ev )

void vlWXGLCanvas::OnEraseBackground ( wxEraseEvent & ev )

void vlWXGLCanvas::OnKeyDown ( wxKeyEvent & ev )

void vlWXGLCanvas::OnKeyUp ( wxKeyEvent & ev )

void vlWXGLCanvas::OnMouseMotion ( wxMouseEvent & ev )

void vlWXGLCanvas::OnMouseDown ( wxMouseEvent & ev )

void vlWXGLCanvas::OnMouseUp ( wxMouseEvent & ev )

void vlWXGLCanvas::OnMouseWheel ( wxMouseEvent & ev )

void vlWX::vlWXGLCanvas::OnMouseEnter ( wxMouseEvent & ev )

void vlWXGLCanvas::OnIdle ( wxIdleEvent & ev )

void vlWXGLCanvas::OnDropFiles ( wxDropFilesEvent & ev )

bool vlWXGLCanvas::setFullscreen ( bool fullscreen ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::quitApplication ( ) [virtual]

Asks to the windowing system that is managing the OpenGLContext to quit the application.

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::makeCurrent ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::swapBuffers ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::getFocus ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::setMousePosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::update ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::setWindowTitle ( const vl::String & text ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::show ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::hide ( ) [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::setPosition | ( | int | x,
 |  | int | y |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::setSize | ( | int | w,
 |  | int | h |
 | ) |  |  | [virtual]

Reimplemented from vl::OpenGLContext.

ivec2 vlWXGLCanvas::position ( ) const [virtual]

Reimplemented from vl::OpenGLContext.

void vlWXGLCanvas::setMouseVisible ( bool visible ) [virtual]

Reimplemented from vl::OpenGLContext.

The documentation for this class was generated from the following files:
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.hpp
  • E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Hierarchical Index

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
  • vl::Rect< float >
    • vl::RectF
  • vl::Rect< int >
    • vl::RectI
  • vl::ref< ActorKdTree >
  • vl::ref< ActorTree >
  • vl::ref< VirtualFile >
  • vl::A3DSLoader
  • vl::A3DSMaterial
  • vl::A3DSMaterialFaceMapping
  • vl::A3DSObject
  • vl::A3DSTexture
  • vl::A3DSTriFace
  • vl::A3DSVertex
  • vl::AABB
  • vl::CRC32CheckSum
  • vl::EdgeExtractor::Edge
  • vl::Matrix2< scalar_type >
  • vl::Matrix3< scalar_type >
  • vl::Matrix4< scalar_type >
  • vl::MD5CheckSum
  • vl::Object
    • vl::BufferedStream< unsigned char, 128 *1024 >
      • vl::TextStream
    • vl::Collection< Shader >
      • vl::ShaderSequence
    • vl::Actor
      • vl::MorphingActor
      • vlVolume::SlicedVolume
    • vl::ActorRenderingCallback
      • vl::DepthSortCallback
      • vl::EdgeUpdateCallback
      • vl::MorphingCallback
    • vl::ActorTreeAbstract
      • vl::ActorKdTree
      • vl::ActorTree
    • vl::ArrayAbstract
      • vl::Array< vector_type, scalar_type, gl_size, gl_type >
    • vl::BezierPatch
    • vl::Buffer
      • vl::GLBufferObject
    • vl::BufferedStream< Element_Type, Chunk_Size >
    • vl::Camera
    • vl::CatmullRomInterpolator< T >
    • vl::Collection< T >
    • vl::DrawPixels::Pixels
    • vl::EdgeExtractor
    • vl::Effect
    • vl::EnableSet
    • vl::Extrusion
    • vl::FBOAttachmentAbstract
      • vl::FBORenderbufferAttachment
        • vl::FBOColorBufferAttachment
        • vl::FBODepthBufferAttachment
        • vl::FBODepthStencilBufferAttachment
        • vl::FBOStencilBufferAttachment
      • vl::FBOTexture1DAttachment
      • vl::FBOTexture2DAttachment
      • vl::FBOTexture3DAttachment
      • vl::FBOTextureAttachment
      • vl::FBOTextureLayerAttachment
    • vl::FileSystem
    • vl::Font
    • vl::FontManager
    • vl::Frustum
    • vl::GLSLShader
      • vl::GLSLFragmentShader
      • vl::GLSLGeometryShader
      • vl::GLSLVertexShader
    • vl::Glyph
    • vl::Image
    • vl::Interpolator
      • vl::InterpolatorDouble
        • vl::CatmullRomInterpolatorDouble
        • vl::LinearInterpolatorDouble
      • vl::InterpolatorDVec2
        • vl::CatmullRomInterpolatorDVec2
        • vl::LinearInterpolatorDVec2
      • vl::InterpolatorDVec3
        • vl::CatmullRomInterpolatorDVec3
        • vl::LinearInterpolatorDVec3
      • vl::InterpolatorDVec4
        • vl::CatmullRomInterpolatorDVec4
        • vl::LinearInterpolatorDVec4
      • vl::InterpolatorFloat
        • vl::CatmullRomInterpolatorFloat
        • vl::LinearInterpolatorFloat
      • vl::InterpolatorFVec2
        • vl::CatmullRomInterpolatorFVec2
        • vl::LinearInterpolatorFVec2
      • vl::InterpolatorFVec3
        • vl::CatmullRomInterpolatorFVec3
        • vl::LinearInterpolatorFVec3
      • vl::InterpolatorFVec4
        • vl::CatmullRomInterpolatorFVec4
        • vl::LinearInterpolatorFVec4
    • vl::KeyValues
    • vl::LinearInterpolator< T >
    • vl::LoadCallback
      • vl::GeometryLoadCallback
    • vl::LoadWriterManager
    • vl::LODEvaluator
      • vl::DistanceLODEvaluator
      • vl::PixelLODEvaluator
    • vl::Log
      • vl::StandardLog
    • vl::ObjMaterial
    • vl::ObjMesh
    • vl::OpenGLContext
      • vlGLUT::GLUTWindow
      • vlQt4::Qt4Widget
      • vlSDL::SDLWindow
      • vlWin32::Win32Context
        • vlMFC::MFCWindow
        • vlWin32::Win32Window
      • vlWX::vlWXGLCanvas
    • vl::Plane
    • vl::PlyLoader::PlyElement
    • vl::PlyLoader::PlyPropertyAbstract
      • vl::PlyLoader::PlyScalar
      • vl::PlyLoader::PlyScalarList
    • vl::PolygonSimplifier
    • vl::Portal
    • vl::Primitives
      • vl::DrawArrays
      • vl::DrawElements< index_type, Tgltype, arr_type >
    • vl::RayIntersection
      • vl::RayIntersectionGeometry
    • vl::RayIntersector
    • vl::Renderable
      • vl::Clear
      • vl::DrawPixels
      • vl::Geometry
        • vl::BezierSurface
      • vl::Text
    • vl::Renderer
      • vl::EdgeRenderer
    • vl::RenderingAbstract
      • vl::Rendering
      • vl::RenderingTree
    • vl::RenderingCallback
      • vl::BlitFramebuffer
      • vl::CopyTexSubImage
        • vl::CopyTexSubImage1D
        • vl::CopyTexSubImage2D
        • vl::CopyTexSubImage3D
      • vl::ReadPixels
    • vl::RenderQueue
    • vl::RenderQueueSorter
      • vl::RenderQueueSorterAggressive
      • vl::RenderQueueSorterBasic
      • vl::RenderQueueSorterByRenderable
      • vl::RenderQueueSorterByShader
      • vl::RenderQueueSorterOcclusion
      • vl::RenderQueueSorterStandard
    • vl::RenderState
      • vl::AlphaFunc
      • vl::BlendColor
      • vl::BlendEquation
      • vl::BlendFunc
      • vl::ClipPlane
      • vl::ColorMask
      • vl::CullFace
      • vl::DepthFunc
      • vl::DepthMask
      • vl::DepthRange
      • vl::Fog
      • vl::FrontFace
      • vl::GLSLProgram
      • vl::Hint
      • vl::Light
      • vl::LightModel
      • vl::LineStipple
      • vl::LineWidth
      • vl::LogicOp
      • vl::Material
      • vl::PixelTransfer
      • vl::PointParameter
      • vl::PointSize
      • vl::PolygonMode
      • vl::PolygonOffset
      • vl::PolygonStipple
      • vl::SampleCoverage
      • vl::ShadeModel
      • vl::StencilFunc
      • vl::StencilMask
      • vl::StencilOp
      • vl::TexEnv
      • vl::TexGen
      • vl::TextureMatrix
      • vl::TextureUnit
    • vl::RenderStateSet
    • vl::RenderTarget
      • vl::FBORenderTarget
    • vl::RenderToken
    • vl::ResourceDatabase
    • vl::ResourceLoadWriter
      • vl::LoadWriter3DS
      • vl::LoadWriterAC3D
      • vl::LoadWriterBMP
      • vl::LoadWriterDAT
      • vl::LoadWriterDDS
      • vl::LoadWriterDICOM
      • vl::LoadWriterJPG
      • vl::LoadWriterMD2
      • vl::LoadWriterOBJ
      • vl::LoadWriterPLY
      • vl::LoadWriterPNG
      • vl::LoadWriterSTL
      • vl::LoadWriterTGA
      • vl::LoadWriterTIFF
    • vl::SceneManager
      • vl::SceneManagerBVH< ActorKdTree >
        • vl::SceneManagerActorKdTree
          • vl::Terrain
      • vl::SceneManagerBVH< ActorTree >
        • vl::SceneManagerActorTree
      • vl::SceneManagerBVH< T >
      • vl::SceneManagerPortals
      • vlVG::SceneManagerVectorGraphics
    • vl::Scissor
    • vl::Sector
    • vl::Sector::VisibilityCallback
    • vl::Shader
    • vl::ShaderNode
    • vl::Tessellator
    • vl::TexParameter
    • vl::Texture
    • vl::Texture::SetupParams
    • vl::Time
    • vl::Transform
      • vl::Billboard
    • vl::UIEventListener
      • vl::GhostCameraManipulator
      • vl::TrackballManipulator
      • vlut::Applet
    • vl::Uniform
    • vl::UniformSet
    • vl::VertexAttributeArray
    • vl::VertexMapper
      • vl::DoubleVertexRemover
    • vl::Viewport
    • vl::VirtualDirectory
      • vl::DiskDirectory
      • vl::MemoryDirectory
      • vl::ZippedDirectory
    • vl::VirtualFile
      • vl::DiskFile
      • vl::GZipCodec
      • vl::MemoryFile
      • vl::ZippedFile
    • vl::WriteCallback
    • vl::ZippedFileInfo
    • vlMolecule::Atom
    • vlMolecule::Bond
    • vlMolecule::Molecule
    • vlVG::VectorGraphics
    • vlVolume::Volume
    • vlVolume::VolumeInfo
    • vlVolume::VolumePlot
  • vl::ObjLoader
  • vl::ObjTexture
  • vl::OpenGLContextFormat
  • vl::PlyLoader
  • vl::PolygonSimplifier::QErr
  • vl::PolygonSimplifier::Triangle
  • vl::PolygonSimplifier::Vertex
  • vl::quat
  • vl::Ray
  • vl::Rect< T >
  • vl::ref< T >
  • vl::Say
  • vl::SayArg
  • vl::Sphere
  • vl::STLLoader
  • vl::String
  • vl::TriangleStripGenerator
  • vl::Vector2< scalar_type >
  • vl::Vector3< scalar_type >
  • vl::Vector4< scalar_type >
  • vl::VisualizationLibrary
  • vlMolecule::AtomInfo
  • vlMolecule::RingExtractor
  • vlVolume::MarchingCubes
  • vlVolume::VolumePlot::Function
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- a -

  • a() : vl::Vector4< scalar_type >
  • a2 : vl::PolygonSimplifier::QErr
  • A3DSLoader() : vl::A3DSLoader
  • A3DSMaterial() : vl::A3DSMaterial
  • A3DSTexture() : vl::A3DSTexture
  • A3DSTriFace() : vl::A3DSTriFace
  • A3DSVertex() : vl::A3DSVertex
  • AABB() : vl::AABB
  • aabb() : vl::ActorTreeAbstract
  • ab : vl::PolygonSimplifier::QErr
  • ac : vl::PolygonSimplifier::QErr
  • accumRGBABits() : vl::OpenGLContextFormat
  • acquireData() : vl::String
  • acquireFont() : vl::FontManager
  • activate()
: vl::Camera
, vl::RenderTarget
, vl::Viewport
  • active() : vl::Camera
  • actor() : vl::RayIntersection
  • Actor() : vl::Actor
  • actorAnimationEnabled() : vl::Rendering
  • ActorKdTree() : vl::ActorKdTree
  • actorQueue() : vl::Rendering
  • actorRenderRankStart() : vlVG::SceneManagerVectorGraphics
  • actors()
: vl::RayIntersector
, vl::Sector
, vlVG::VectorGraphics
, vl::ActorTreeAbstract
, vl::RayIntersector
  • ActorTree() : vl::ActorTree
  • actorTree() : vlMolecule::Molecule
  • ActorTreeAbstract() : vl::ActorTreeAbstract
  • actorTreeMulti() : vlVolume::VolumePlot
  • ad : vl::PolygonSimplifier::QErr
  • addActor() : vl::ActorTreeAbstract
  • addAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • addAtom() : vlMolecule::Molecule
  • addBond() : vlMolecule::Molecule
  • addChild()
: vl::ActorTree
, vl::ShaderNode
, vl::Transform
  • addColorAttachment() : vl::FBORenderTarget
  • addDepthAttachment() : vl::FBORenderTarget
  • addDistanceRange() : vl::DistanceLODEvaluator
  • addEdge() : vl::EdgeExtractor
  • addEventListener() : vl::OpenGLContext
  • addFile() : vl::MemoryDirectory
  • addPixelRange() : vl::PixelLODEvaluator
  • addPoint()
: vl::AABB
, vl::RectF
  • addQErr() : vl::PolygonSimplifier::Vertex
  • addStencilAttachment() : vl::FBORenderTarget
  • addTextureAttachment() : vl::FBORenderTarget
  • adjacentAtoms() : vlMolecule::Atom
  • adjacentVertex() : vl::PolygonSimplifier::Vertex
  • adjacentVerticesCount() : vl::PolygonSimplifier::Vertex
  • adjustView()
: vl::Camera
, vl::TrackballManipulator
  • advance() : vl::Glyph
  • align() : vl::DrawPixels::Pixels
  • alignedFree() : vl::Buffer
  • alignedMalloc() : vl::Buffer
  • alignment()
: vl::Buffer
, vl::Text
  • allocate() : vl::Image
  • allocate1D() : vl::Image
  • allocate2D() : vl::Image
  • allocate3D() : vl::Image
  • allocateBuffer() : vl::MemoryFile
  • allocateCubemap() : vl::Image
  • alpha() : vl::ColorMask
  • alphaBias() : vl::PixelTransfer
  • alphaBits() : vl::Image
  • AlphaFunc() : vl::AlphaFunc
  • alphaFunc() : vl::AlphaFunc
  • alphaScale()
: vl::PixelTransfer
, vl::TexEnv
  • alreadyProcessed() : vl::PolygonSimplifier::Vertex
  • alwaysIdentityWorldMatrix() : vl::Transform
  • ambient() : vl::Light
  • ambientColor() : vl::LightModel
  • analyticSolution() : vl::PolygonSimplifier::QErr
  • analyze() : vl::PlyLoader::PlyElement
  • analyzeHeader() : vl::PlyLoader
  • animationStarted() : vl::MorphingActor
  • anisotropy() : vl::TexParameter
  • append() : vl::String
  • appendActors()
: vl::SceneManagerBVH< T >
, vl::ActorTreeAbstract
, vl::SceneManager
, vl::SceneManagerPortals
, vlVG::SceneManagerVectorGraphics
  • appendVisibleActors()
: vl::SceneManager
, vl::ActorTreeAbstract
, vl::SceneManagerBVH< T >
, vl::SceneManagerPortals
, vlVG::SceneManagerVectorGraphics
  • Applet() : vlut::Applet
  • apply()
: vl::RenderState
, vl::LightModel
, vl::BlendFunc
, vl::BlendEquation
, vl::SampleCoverage
, vl::TexGen
, vl::ShadeModel
, vl::Material
, vl::BlendColor
, vl::Fog
, vl::LogicOp
, vl::LineWidth
, vl::PolygonStipple
, vl::AlphaFunc
, vl::DepthMask
, vl::StencilOp
, vl::StencilMask
, vl::TextureMatrix
, vl::PolygonMode
, vl::DepthFunc
, vl::CullFace
, vl::Hint
, vl::TexParameter
, vl::FrontFace
, vl::GLSLProgram
, vl::Light
, vl::TextureUnit
, vl::PolygonOffset
, vl::TexEnv
, vl::StencilFunc
, vl::ColorMask
, vl::LineStipple
, vl::ClipPlane
, vl::PointParameter
, vl::PointSize
, vl::PixelTransfer
, vl::DepthRange
  • applyEnables() : vl::Renderer
  • applyModelViewMatrix() : vl::Camera
  • applyRenderStates() : vl::Renderer
  • applyUniformSet() : vl::GLSLProgram
  • applyViewMatrix() : vl::Camera
  • area() : vl::AABB
  • aromaticRingColor() : vlMolecule::Molecule
  • ArrayAbstract() : vl::ArrayAbstract
  • as() : vl::Object
  • as3x3() : vl::Matrix4< scalar_type >
  • aspectRatio() : vl::Camera
  • at()
: vl::RenderQueue
, vl::Collection< T >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Collection< T >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • atom() : vlMolecule::Molecule
  • Atom() : vlMolecule::Atom
  • atom1() : vlMolecule::Bond
  • atom2() : vlMolecule::Bond
  • atomCount() : vlMolecule::Molecule
  • atomDetail() : vlMolecule::Molecule
  • atomicMass() : vlMolecule::AtomInfo
  • atomicNumber() : vlMolecule::AtomInfo
  • AtomInfo() : vlMolecule::AtomInfo
  • atomLabelEffect() : vlMolecule::Molecule
  • atomLabelTemplate() : vlMolecule::Molecule
  • atomName() : vlMolecule::Atom
  • atoms() : vlMolecule::Molecule
  • atomsStyle() : vlMolecule::Molecule
  • atomType() : vlMolecule::Atom
  • attachShader() : vl::GLSLProgram
  • attribIndex() : vl::VertexAttributeArray
  • automaticDelete() : vl::Object
  • automaticResourceInit() : vl::Rendering
  • average() : vlVolume::Volume
  • axis() : vl::Billboard
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Namespace Index

  • Namespace List
  • Namespace Members

Namespace List

Here is a list of all namespaces with brief descriptions:
vl | Visualization Library namespace
vlGLUT | The GLUT bindings namespace
vlMFC | The MFC bindings namespace
vlMolecule | The Molecule Visualization namespace
vlQt4 | The Qt4 bindings namespace
vlSDL | The SDL bindings namespace
vlut | Visualization Library utility namespace
vlVG | The Vector Graphics namespace
vlVolume | The Volume Rendering namespace
vlWin32 | The Win32 bindings namespace
vlWX | The wxWidgets bindings namespace
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: vl Namespace Reference

  • Namespace List
  • Namespace Members

vl Namespace Reference

Visualization Library namespace. More...

Classes

class | AABB
The AABB class implements an axis-aligned bounding box using vl::Real precision. More...
class | ActorRenderingCallback
The ActorRenderingCallback class defines a callback object to be executed just before an Actor is rendered but after the render states are setup. More...
class | Actor
Associates a Renderable object to an Effect and Transform. More...
class | ActorKdTree
ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree. More...
class | ActorTree
The ActorTree class implements a generic tree whose nodes contain Actor[s]. More...
class | ActorTreeAbstract
The ActorTreeAbstract class implements the interface of a generic tree containing Actor[s] in its nodes. More...
class | ArrayAbstract
The ArrayAbstract class defines an abstract interface to conveniently manipulate data stored in a GLBufferObject. More...
class | Array
The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject. More...
class | BezierPatch
Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class. More...
class | BezierSurface
The BezierSurface class implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch). More...
class | Billboard
A Transform that aligns an Actor towards the camera. More...
class | BlitFramebuffer
A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit. More...
class | Buffer
Implements a buffer whose storage is in local memory. More...
class | BufferedStream
The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile. More...
class | Camera
Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered. More...
class | CatmullRomInterpolator
The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation. More...
class | CatmullRomInterpolatorFVec4
Interpolates vl::fvec4 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorFVec3
Interpolates vl::fvec3 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorFVec2
Interpolates vl::fvec2 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorFloat
Interpolates float values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorDVec4
Interpolates vl::dvec4 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorDVec3
Interpolates vl::dvec3 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorDVec2
Interpolates vl::dvec2 values using a CatmullRomInterpolator. More...
class | CatmullRomInterpolatorDouble
Interpolates double values using a CatmullRomInterpolator. More...
class | Clear
The Clear class is a Renderable used to clear the whole or a portion of the color, stencil or depth buffer. More...
class | ClipPlane
Wraps the OpenGL function glClipPlane(). More...
class | Collection
Reference counted container that encapsulates the base functionalites of an std::vector<>. More...
class | CopyTexSubImage
Wrapper class of the OpenGL function glCopyTexSubImage. More...
class | CopyTexSubImage1D
Wraps glCopyTexSubImage1D, see also CopyTexSubImage. More...
class | CopyTexSubImage2D
Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures. More...
class | CopyTexSubImage3D
Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures. More...
class | CRC32CheckSum
Computes the a CRC32 checksum of a given buffer or VirtualFile. More...
class | DepthSortCallback
The DepthSortCallback class sorts the primitives of the Geometry object bound to the Actor in which the callback is installed. More...
class | DiskDirectory
A VirtualDirectory that operates on reguar disk directories. More...
class | DiskFile
A VirtualFile that operates on regular disk files. More...
class | DistanceLODEvaluator
A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera. More...
class | VertexMapper
Generates a set of new vertices from the old one. More...
class | DoubleVertexRemover
Removes from a Geometry the vertices with the same attributes. More...
class | DrawArrays
Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information. More...
class | DrawElements
Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information. More...
class | DrawPixels
Wraps the OpenGL function glDrawPixels(). More...
class | EdgeExtractor
The EdgeExtractor class extracts the edges from one or more Geometry objects. More...
class | EdgeRenderer
The EdgeRenderer class implements a special Renderer that automatically extracts and renders the edges of the objects in the scene. More...
class | EdgeUpdateCallback
The EdgeUpdateCallback class updates at every frame the edges of an Actor for the purpose of edge-enhancement. More...
class | ShaderSequence
A sequence of Shader objects each of which represent a rendering pass. More...
class | Effect
Defines the sequence of Shader objects used to render an Actor. More...
class | Extrusion
The Extrusion class generates a Geometry extruding a silhouette along a path. More...
class | FileSystem
Manages multiple VirtualDirectory objects. More...
class | Glyph
The Glyph associated to a character of a given Font. More...
class | Font
A font to be used with a Text renderable. More...
class | FontManager
The FontManager class keeps a map associating a font path, size and smoothing flag to a Font object. More...
class | FBOAttachmentAbstract
Abstract class that represents a framebuffer object attachment, i.e. More...
class | FBORenderbufferAttachment
Abstract class that represents a framebuffer renderbuffer attachment, i.e. More...
class | FBOColorBufferAttachment
A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBODepthBufferAttachment
A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOStencilBufferAttachment
A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBODepthStencilBufferAttachment
A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOTexture1DAttachment
A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOTexture2DAttachment
A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOTextureAttachment
A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOTexture3DAttachment
A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBOTextureLayerAttachment
A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | FBORenderTarget
Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension. More...
class | Frustum
A set of planes defining a frustum used for culling purposes (frustum culling). More...
class | Geometry
The Geometry class is a Renderable that implements a polygonal mesh made of polygons, lines and points. More...
class | GeometryLoadCallback
Defines a set of actions to be executed to a Geometry as soon as it is loaded. More...
class | GhostCameraManipulator
The GhostCameraManipulator class is an UIEventListener that controls the position and orientation of a Camera. More...
class | GLBufferObject
The GLBufferObject class is a Buffer that can upload its data on the GPU memory. More...
class | GLSLShader
Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader. More...
class | GLSLVertexShader
Wraps a GLSL vertex shader to be bound to a GLSL program. More...
class | GLSLFragmentShader
Wraps a GLSL fragment shader to be bound to a GLSL program. More...
class | GLSLGeometryShader
Wraps a GLSL geometry shader to be bound to a GLSL program. More...
class | GLSLProgram
Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders. More...
class | GZipCodec
The GZipCodec class is a VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm. More...
class | Image
Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps. More...
class | Interpolator
Abstract class for all the interpolators. More...
class | InterpolatorFVec4
Abstract class that interpolates vl::fvec4 values. More...
class | InterpolatorFVec3
Abstract class that interpolates vl::fvec3 values. More...
class | InterpolatorFVec2
Abstract class that interpolates vl::fvec2 values. More...
class | InterpolatorFloat
Abstract class that interpolates float values. More...
class | InterpolatorDVec4
Abstract class that interpolates vl::dvec4 values. More...
class | InterpolatorDVec3
Abstract class that interpolates vl::dvec3 values. More...
class | InterpolatorDVec2
Abstract class that interpolates vl::dvec2 values. More...
class | InterpolatorDouble
Abstract class that interpolates double values. More...
class | KeyValues
A set of key/value pairs used to store generic information. More...
class | Light
Wraps the OpenGL function glLight(). More...
class | LinearInterpolator
The LinearInterpolator class is a template class that implements linear interpolation. More...
class | LinearInterpolatorFVec4
Interpolates vl::fvec4 values using a LinearInterpolator. More...
class | LinearInterpolatorFVec3
Interpolates vl::fvec3 values using a LinearInterpolator. More...
class | LinearInterpolatorFVec2
Interpolates vl::fvec2 values using a LinearInterpolator. More...
class | LinearInterpolatorFloat
Interpolates float values using a LinearInterpolator. More...
class | LinearInterpolatorDVec4
Interpolates vl::dvec4 values using a LinearInterpolator. More...
class | LinearInterpolatorDVec3
Interpolates vl::dvec3 values using a LinearInterpolator. More...
class | LinearInterpolatorDVec2
Interpolates vl::dvec2 values using a LinearInterpolator. More...
class | LinearInterpolatorDouble
Interpolates double values using a LinearInterpolator. More...
class | LoadCallback
Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback. More...
class | WriteCallback
Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback. More...
class | LoadWriterManager
The LoadWriterManager class loads and writes resources using the registered ResourceLoadWriter objects. More...
class | LODEvaluator
Abstract class to compute the appropriate LOD of an Actor or Effect. More...
class | Log
The Log class is the abstract base class used to generate logging data. More...
class | StandardLog
The StandardLog class outputs the log messages on the stdout device and optionally also on a specified file. More...
class | Matrix2
The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2. More...
class | Matrix3
The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3. More...
class | Matrix4
The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4. More...
class | MD5CheckSum
Computes the MD5 of a given buffer or VirtualFile. More...
class | MemoryDirectory
A VirtualDirectory to manipulate directories stored in memory. More...
class | MemoryFile
A VirtualFile to manipulate files stored in memory. More...
class | MorphingCallback
The MorphingCallback class is used by MorphingActor to implement the morphing animation on the GPU. More...
class | MorphingActor
The MorphingActor class animates a Geometry by interpolating its position and normal array. More...
class | Object
The base class for all the reference counted objects. More...
class | ref
The ref<> class is used to reference-count an Object. More...
class | OpenGLContextFormat
The OpenGLContextFormat class encapsulates the settings of an OpenGL rendering context. More...
class | OpenGLContext
Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent. More...
class | PixelLODEvaluator
A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen. More...
class | Plane
The Plane class defines a plane using a normal and an origin. More...
class | PolygonSimplifier
The PolygonSimplifier class reduces the amount of polygons present in a Geometry using a quadric error metric. More...
class | Primitives
This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays(). More...
class | quat
The quat class implements a quaternion using vl::Real precision. More...
class | Ray
The Ray class defines a ray as an origin and direction using Real precision. More...
class | RayIntersection
The RayIntersection encapsulates all the information relative to a Ray/Actor intersection. More...
class | RayIntersectionGeometry
The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor. More...
class | RayIntersector
The RayIntersector class is used to detect the intersection points between a Ray and a set of Actor[s]. More...
class | ReadPixels
A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering. More...
class | Rect
Implements the common functions of RectI and RectF. More...
class | RectI
The RectI class represents a 2D rectangular area using int precision. More...
class | RectF
The RectF class represents a 2D rectangular area using float precision. More...
class | Renderable
An abstract class that represents all the objects that can be rendered. More...
class | Renderer
The Renderer class executes the actual rendering on the given RenderQueue. More...
class | Rendering
The Rendering class collects all the information to perform the rendering of a scene. More...
class | RenderingAbstract
The RenderingAbstract class implements the abstract rendering interface. More...
class | RenderingCallback
An abstract class used to perform operations at the end or at the beginning of a rendering. More...
class | RenderingTree
The RenderingTree class organizes a set of renderings into a tree-like data structure. More...
class | RenderQueue
The RenderQueue class collects a list of RenderToken objects to be sorted and rendered. More...
class | RenderQueueSorter
The RenderQueueSorter class is the abstract base class of all the algorithms used to sort a set of RenderToken. More...
class | RenderQueueSorterByShader
Sorts the RenderTokens by their Shader pointer. More...
class | RenderQueueSorterByRenderable
Sorts the RenderTokens by their Renderable pointer. More...
class | RenderQueueSorterBasic
Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer. More...
class | RenderQueueSorterStandard
Implements the default RenderQueueSorter. More...
class | RenderQueueSorterOcclusion
Implements a RenderQueueSorter to be used with occlusion culling. More...
class | RenderQueueSorterAggressive
Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer. More...
class | RenderState
Base class for most of the OpenGL render state wrapper classes. More...
class | RenderTarget
The RenderTarget class defines an abstract 'surface' where OpenGL can render into. More...
class | RenderToken
Internally used by the rendering engine. More...
class | ResourceDatabase
The ResourceDatabase class contains and manipulates a set of resources. More...
class | ResourceLoadWriter
The ResourceLoadWriter class is an abstract class used to implement read/write support for one or more resource types. More...
class | SayArg
Used internally by the Say class. More...
class | Say
A simple String formatting class. More...
class | SceneManager
The SceneManager class is the base class for all the scene managers. More...
class | SceneManagerActorKdTree
A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree. More...
class | SceneManagerActorTree
A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree. More...
class | SceneManagerBVH
The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers. More...
class | Portal
A planar convex polygon used to define the visibility from one Sector to another. More...
class | Sector
Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s]. More...
class | SceneManagerPortals
The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes. More...
class | Scissor
The Scissor class wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information. More...
class | PixelTransfer
Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information. More...
class | Hint
Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information. More...
class | CullFace
Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information. More...
class | FrontFace
Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information. More...
class | DepthFunc
Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information. More...
class | DepthMask
Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information. More...
class | PolygonMode
Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information. More...
class | ShadeModel
Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information. More...
class | BlendFunc
Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information. More...
class | BlendEquation
Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information. More...
class | SampleCoverage
Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information. More...
class | AlphaFunc
Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information. More...
class | Material
Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information. More...
class | LightModel
Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information. More...
class | Fog
Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information. More...
class | PolygonOffset
Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information. More...
class | LogicOp
Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information. More...
class | DepthRange
Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information. More...
class | LineWidth
Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information. More...
class | PointSize
Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information. More...
class | PolygonStipple
Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information. More...
class | LineStipple
Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information. More...
class | PointParameter
Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information. More...
class | StencilFunc
Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information. More...
class | StencilOp
Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information. More...
class | StencilMask
Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information. More...
class | BlendColor
Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information. More...
class | ColorMask
Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information. More...
class | TextureMatrix
The TextureMatrix class uses a 4x4 matrix to transform the texture coordinates of a texture unit. More...
class | TexEnv
Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information. More...
class | TexGen
Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information. More...
class | TextureUnit
The TextureUnit class associates a Texture object to an OpenGL texture unit. More...
class | RenderStateSet
A set of RenderState objects managed by a Shader. More...
class | EnableSet
A set of enables managed by Shader. More...
class | Shader
Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects. More...
class | ShaderNode
The ShaderNode class is used to conveniently manage complex hierarchies of Shader[s]. More...
class | Sphere
The Sphere class defines a sphere using a center and a radius using vl::Real precision. More...
class | String
The String class implements an advanced UTF16 (Unicode BMP) string manipulation engine. More...
class | Terrain
The Terrain class implements a ActorKdTree-based terrain scene manager. More...
class | Tessellator
Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library. More...
class | Text
A Renderable that renders text with a given Font. More...
class | TextStream
The TextStream class can be used to conveniently read or parse utf8-encoded text files. More...
class | TexParameter
Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information. More...
class | Texture
Wraps an OpenGL texture object. More...
class | Time
Simple class to be used as a timer and to retrieve the current time and date. More...
class | TrackballManipulator
This class lets you rotate a Camera or a Transform node using a vitual trackball. More...
class | Transform
Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor. More...
class | TriangleStripGenerator
The TriangleStripGenerator class is used to substitute lists of triangles or quads with triangle strips. More...
class | UIEventListener
The UIEventListener class listens to the events emitted by an OpenGLContext. More...
class | Uniform
Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram. More...
class | UniformSet
A set of Uniform objects managed by a Shader. More...
class | Vector2
The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2. More...
class | Vector3
The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3. More...
class | Vector4
The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4. More...
class | VertexAttributeArray
Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry. More...
class | Viewport
Implements the viewport and clearing settings associated to a Camera. More...
class | VirtualDirectory
Abstact class representing a directory of files. More...
class | VirtualFile
An abstract class representing a file. More...
class | VisualizationLibrary
Used to initialize/shutdown VisualizationLibrary and to access important global data. More...
class | LoadWriter3DS
The LoadWriter3DS class is a ResourceLoadWriter capable of reading 3DS files. More...
class | A3DSTexture
The A3DSTexture class represents a texture in a 3DS file. More...
class | A3DSMaterial
The A3DSMaterial class represents a material in a 3DS file. More...
class | A3DSTriFace
The A3DSTriFace class represents a triangle in a 3DS file. More...
class | A3DSMaterialFaceMapping
The A3DSMaterialFaceMapping class represents the material/face mapping in a 3DS file. More...
class | A3DSVertex
The A3DSVertex class represents a vertex in a 3DS file. More...
class | A3DSObject
The A3DSObject class represents an object in a 3DS file. More...
class | A3DSLoader
The A3DSLoader class loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects. More...
class | LoadWriterAC3D
The LoadWriterAC3D class is a ResourceLoadWriter capable of reading AC3D files. More...
class | LoadWriterBMP
The LoadWriterBMP class is a ResourceLoadWriter capable of reading BMP files. More...
class | LoadWriterDAT
The LoadWriterDAT class is a ResourceLoadWriter capable of reading DAT files. More...
class | LoadWriterDDS
The LoadWriterDDS class is a ResourceLoadWriter capable of reading DDS files. More...
class | LoadWriterDICOM
The LoadWriterDICOM class is a ResourceLoadWriter capable of reading DICOM files. More...
class | LoadWriterJPG
The LoadWriterJPG class is a ResourceLoadWriter capable of reading JPG files. More...
class | LoadWriterMD2
The LoadWriterMD2 class is a ResourceLoadWriter capable of reading MD2 files. More...
class | LoadWriterOBJ
The LoadWriterOBJ class is a ResourceLoadWriter capable of reading OBJ files. More...
class | ObjTexture
Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader. More...
class | ObjMaterial
Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader. More...
class | ObjMesh
Represents a Wavefront OBJ mesh. See also ObjLoader. More...
class | ObjLoader
Loads a Wavefront OBJ file. More...
class | LoadWriterPLY
The LoadWriterPLY class is a ResourceLoadWriter capable of reading PLY files. More...
class | PlyLoader
Loads a PLY file. More...
class | LoadWriterPNG
The LoadWriterPNG class is a ResourceLoadWriter capable of reading PNG files. More...
class | LoadWriterSTL
The LoadWriterSTL class is a ResourceLoadWriter capable of reading STL files. More...
class | STLLoader
Loads an STL file. More...
class | LoadWriterTGA
The LoadWriterTGA class is a ResourceLoadWriter capable of reading TGA files. More...
class | LoadWriterTIFF
The LoadWriterTIFF class is a ResourceLoadWriter capable of reading TIFF files. More...
class | ZippedDirectory
A VirtualDirectory capable of reading files from a .zip file. More...
class | ZippedFileInfo
Collects the information about a ZippedFile. More...
class | ZippedFile
A VirtualFile used to read a file contained in a .zip archive. More...

Typedefs

typedef Collection< Actor > | ActorCollection
typedef Array< GLfloat,
GLfloat, 1, GL_FLOAT > 		ArrayFloat
An array of GLfloat.
typedef Array< fvec2, GLfloat,
2, GL_FLOAT > 		ArrayFVec2
An array of vl::fvec2.
typedef Array< fvec3, GLfloat,
3, GL_FLOAT > 		ArrayFVec3
An array of vl::fvec3.
typedef Array< fvec4, GLfloat,
4, GL_FLOAT > 		ArrayFVec4
An array of vl::fvec4.
typedef Array< GLdouble,
GLdouble, 1, GL_DOUBLE > 		ArrayDouble
An array of GLdouble.
typedef Array< dvec2, GLdouble,
2, GL_DOUBLE > 		ArrayDVec2
An array of vl::dvec2.
typedef Array< dvec3, GLdouble,
3, GL_DOUBLE > 		ArrayDVec3
An array of vl::dvec3.
typedef Array< dvec4, GLdouble,
4, GL_DOUBLE > 		ArrayDVec4
An array of vl::dvec4.
typedef Array< GLint, GLint,
1, GL_INT > 		ArrayInt
An array of GLint.
typedef Array< ivec2, GLint,
2, GL_INT > 		ArrayIVec2
An array of vl::ivec2.
typedef Array< ivec3, GLint,
3, GL_INT > 		ArrayIVec3
An array of vl::ivec3.
typedef Array< ivec4, GLint,
4, GL_INT > 		ArrayIVec4
An array of vl::ivec4.
typedef Array< GLuint, GLuint,
1, GL_UNSIGNED_INT > 		ArrayUInt
An array of GLuint.
typedef Array< uvec2, GLuint,
2, GL_UNSIGNED_INT > 		ArrayUVec2
An array of vl::uvec2.
typedef Array< uvec3, GLuint,
3, GL_UNSIGNED_INT > 		ArrayUVec3
An array of vl::uvec3.
typedef Array< uvec4, GLuint,
4, GL_UNSIGNED_INT > 		ArrayUVec4
An array of vl::uvec4.
typedef Array< GLbyte, GLbyte,
1, GL_BYTE > 		ArrayByte
An array of GLbyte.
typedef Array< bvec2, GLbyte,
2, GL_BYTE > 		ArrayBVec2
An array of vl::bvec2.
typedef Array< bvec3, GLbyte,
3, GL_BYTE > 		ArrayBVec3
An array of vl::bvec3.
typedef Array< bvec4, GLbyte,
4, GL_BYTE > 		ArrayBVec4
An array of vl::bvec4.
typedef Array< GLubyte,
GLubyte, 1, GL_UNSIGNED_BYTE > 		ArrayUByte
An array of GLubyte.
typedef Array< ubvec2, GLubyte,
2, GL_UNSIGNED_BYTE > 		ArrayUBVec2
An array of vl::ubvec2.
typedef Array< ubvec3, GLubyte,
3, GL_UNSIGNED_BYTE > 		ArrayUBVec3
An array of vl::ubvec3.
typedef Array< ubvec4, GLubyte,
4, GL_UNSIGNED_BYTE > 		ArrayUBVec4
An array of vl::ubvec4.
typedef Array< GLshort,
GLshort, 1, GL_SHORT > 		ArrayShort
An array of GLshort.
typedef Array< svec2, GLshort,
2, GL_SHORT > 		ArraySVec2
An array of vl::svec2.
typedef Array< svec3, GLshort,
3, GL_SHORT > 		ArraySVec3
An array of vl::svec3.
typedef Array< svec4, GLshort,
4, GL_SHORT > 		ArraySVec4
An array of vl::svec4.
typedef Array< GLushort,
GLushort, 1, GL_UNSIGNED_SHORT > 		ArrayUShort
An array of GLushort.
typedef Array< usvec2,
GLushort, 2, GL_UNSIGNED_SHORT > 		ArrayUSVec2
An array of vl::usvec2.
typedef Array< usvec3,
GLushort, 3, GL_UNSIGNED_SHORT > 		ArrayUSVec3
An array of vl::usvec3.
typedef Array< usvec4,
GLushort, 4, GL_UNSIGNED_SHORT > 		ArrayUSVec4
An array of vl::usvec4.
typedef CatmullRomInterpolator
< float > 		CatmullRomInterpolatorFloat_T
typedef CatmullRomInterpolator
< vl::fvec2 > 		CatmullRomInterpolatorFVec2_T
typedef CatmullRomInterpolator
< vl::fvec3 > 		CatmullRomInterpolatorFVec3_T
typedef CatmullRomInterpolator
< vl::fvec4 > 		CatmullRomInterpolatorFVec4_T
typedef CatmullRomInterpolator
< double > 		CatmullRomInterpolatorDouble_T
typedef CatmullRomInterpolator
< vl::dvec2 > 		CatmullRomInterpolatorDVec2_T
typedef CatmullRomInterpolator
< vl::dvec3 > 		CatmullRomInterpolatorDVec3_T
typedef CatmullRomInterpolator
< vl::dvec4 > 		CatmullRomInterpolatorDVec4_T
typedef double | Real
Defined as 'typedef double Real'.
typedef DrawElements< GLuint,
GL_UNSIGNED_INT, ArrayUInt > 		DrawElementsUInt
A DrawElements using indices of type GLuint.
typedef DrawElements< GLushort,
GL_UNSIGNED_SHORT, ArrayUShort > 		DrawElementsUShort
A DrawElements using indices of type GLushort.
typedef DrawElements< GLubyte,
GL_UNSIGNED_BYTE, ArrayUByte > 		DrawElementsUByte
A DrawElements using indices of type GLubyte.
typedef LinearInterpolator< float > | LinearInterpolatorFloat_T
typedef LinearInterpolator
< vl::fvec2 > 		LinearInterpolatorFVec2_T
typedef LinearInterpolator
< vl::fvec3 > 		LinearInterpolatorFVec3_T
typedef LinearInterpolator
< vl::fvec4 > 		LinearInterpolatorFVec4_T
typedef LinearInterpolator
< double > 		LinearInterpolatorDouble_T
typedef LinearInterpolator
< vl::dvec2 > 		LinearInterpolatorDVec2_T
typedef LinearInterpolator
< vl::dvec3 > 		LinearInterpolatorDVec3_T
typedef LinearInterpolator
< vl::dvec4 > 		LinearInterpolatorDVec4_T
typedef Matrix2< GLdouble > | dmat2
A 2x2 matrix using GLdouble precision.
typedef Matrix2< GLfloat > | fmat2
A 2x2 matrix using GLfloat precision.
typedef Matrix2< GLint > | imat2
A 2x2 matrix using GLint precision.
typedef Matrix2< GLuint > | umat2
A 2x2 matrix using GLuint precision.
typedef dmat2 | mat2
Defined as: 'typedef dmat2 mat2'. See also VL_PIPELINE_PRECISION.
typedef Matrix3< GLdouble > | dmat3
A 3x3 matrix using GLdouble precision.
typedef Matrix3< GLfloat > | fmat3
A 3x3 matrix using GLfloat precision.
typedef Matrix3< GLint > | imat3
A 3x3 matrix using GLint precision.
typedef Matrix3< GLuint > | umat3
A 3x3 matrix using GLuint precision.
typedef dmat3 | mat3
Defined as: 'typedef dmat3 mat3'. See also VL_PIPELINE_PRECISION.
typedef Matrix4< GLdouble > | dmat4
A 4x4 matrix using GLdouble precision.
typedef Matrix4< GLfloat > | fmat4
A 4x4 matrix using GLfloat precision.
typedef Matrix4< GLint > | imat4
A 4x4 matrix using GLint precision.
typedef Matrix4< GLuint > | umat4
A 4x4 matrix using GLuint precision.
typedef dmat4 | mat4
Defined as: 'typedef dmat4 mat4'. See also VL_PIPELINE_PRECISION.
typedef std::map< float, ref
< RenderQueue > > 		TRenderQueueMap
typedef Vector2< GLint > | ivec2
A 2 components vector with GLint precision.
typedef Vector2< GLuint > | uvec2
A 2 components vector with GLuint precision.
typedef Vector2< GLfloat > | fvec2
A 2 components vector with GLfloat precision.
typedef Vector2< GLdouble > | dvec2
A 2 components vector with GLdouble precision.
typedef Vector2< GLbyte > | bvec2
A 2 components vector with GLbyte precision.
typedef Vector2< GLubyte > | ubvec2
A 2 components vector with GLubyte precision.
typedef Vector2< GLshort > | svec2
A 2 components vector with GLshort precision.
typedef Vector2< GLushort > | usvec2
A 2 components vector with GLushort precision.
typedef dvec2 | vec2
Defined as: 'typedef dvec2 vec2'. See also VL_PIPELINE_PRECISION.
typedef Vector3< GLint > | ivec3
A 3 components vector with GLint precision.
typedef Vector3< GLuint > | uvec3
A 3 components vector with GLuint precision.
typedef Vector3< GLfloat > | fvec3
A 3 components vector with GLfloat precision.
typedef Vector3< GLdouble > | dvec3
A 3 components vector with GLdouble precision.
typedef Vector3< GLbyte > | bvec3
A 3 components vector with GLbyte precision.
typedef Vector3< GLubyte > | ubvec3
A 3 components vector with GLubyte precision.
typedef Vector3< GLshort > | svec3
A 3 components vector with GLshort precision.
typedef Vector3< GLushort > | usvec3
A 3 components vector with GLushort precision.
typedef dvec3 | vec3
Defined as: 'typedef dvec3 vec3'. See also VL_PIPELINE_PRECISION.
typedef Vector4< GLint > | ivec4
A 4 components vector with GLint precision.
typedef Vector4< GLuint > | uvec4
A 4 components vector with GLuint precision.
typedef Vector4< GLfloat > | fvec4
A 4 components vector with GLfloat precision.
typedef Vector4< GLdouble > | dvec4
A 4 components vector with GLdouble precision.
typedef Vector4< GLbyte > | bvec4
A 4 components vector with GLbyte precision.
typedef Vector4< GLubyte > | ubvec4
A 4 components vector with GLubyte precision.
typedef Vector4< GLshort > | svec4
A 4 components vector with GLshort precision.
typedef Vector4< GLushort > | usvec4
A 4 components vector with GLushort precision.
typedef dvec4 | vec4
Defined as: 'typedef dvec4 vec4'. See also VL_PIPELINE_PRECISION.

Enumerations

enum | ESilhouetteMode { SilhouetteClosed, SilhouetteOpen }
enum ELogLevel {
LogNormal, LogDebug, LogInfo, LogWarning,
LogError, LogBug
}
enum ETextureFormat {
TF_ALPHA = GL_ALPHA, TF_ALPHA4 = GL_ALPHA4, TF_ALPHA8 = GL_ALPHA8, TF_ALPHA12 = GL_ALPHA12,
TF_ALPHA16 = GL_ALPHA16, TF_INTENSITY = GL_INTENSITY, TF_INTENSITY4 = GL_INTENSITY4, TF_INTENSITY8 = GL_INTENSITY8,
TF_INTENSITY12 = GL_INTENSITY12, TF_INTENSITY16 = GL_INTENSITY16, TF_LUMINANCE = GL_LUMINANCE, TF_LUMINANCE4 = GL_LUMINANCE4,
TF_LUMINANCE8 = GL_LUMINANCE8, TF_LUMINANCE12 = GL_LUMINANCE12, TF_LUMINANCE16 = GL_LUMINANCE16, TF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA,
TF_LUMINANCE4_ALPHA4 = GL_LUMINANCE4_ALPHA4, TF_LUMINANCE6_ALPHA2 = GL_LUMINANCE6_ALPHA2, TF_LUMINANCE8_ALPHA8 = GL_LUMINANCE8_ALPHA8, TF_LUMINANCE12_ALPHA4 = GL_LUMINANCE12_ALPHA4,
TF_LUMINANCE12_ALPHA12 = GL_LUMINANCE12_ALPHA12, TF_LUMINANCE16_ALPHA16 = GL_LUMINANCE16_ALPHA16, TF_R3_G3_B2 = GL_R3_G3_B2, TF_RGB = GL_RGB,
TF_RGB4 = GL_RGB4, TF_RGB5 = GL_RGB5, TF_RGB8 = GL_RGB8, TF_RGB10 = GL_RGB10,
TF_RGB12 = GL_RGB12, TF_RGB16 = GL_RGB16, TF_RGBA = GL_RGBA, TF_RGBA2 = GL_RGBA2,
TF_RGBA4 = GL_RGBA4, TF_RGB5_A1 = GL_RGB5_A1, TF_RGBA8 = GL_RGBA8, TF_RGB10_A2 = GL_RGB10_A2,
TF_RGBA12 = GL_RGBA12, TF_RGBA16 = GL_RGBA16, TF_RGBA32F = GL_RGBA32F_ARB, TF_RGB32F = GL_RGB32F_ARB,
TF_ALPHA32F = GL_ALPHA32F_ARB, TF_INTENSITY32F = GL_INTENSITY32F_ARB, TF_LUMINANCE32F = GL_LUMINANCE32F_ARB, TF_LUMINANCE_ALPHA32F = GL_LUMINANCE_ALPHA32F_ARB,
TF_RGBA16F = GL_RGBA16F_ARB, TF_RGB16F = GL_RGB16F_ARB, TF_ALPHA16F = GL_ALPHA16F_ARB, TF_INTENSITY16F = GL_INTENSITY16F_ARB,
TF_LUMINANCE16F = GL_LUMINANCE16F_ARB, TF_LUMINANCE_ALPHA16F = GL_LUMINANCE_ALPHA16F_ARB, TF_RGBA_FLOAT32_ATI = GL_RGBA_FLOAT32_ATI, TF_RGB_FLOAT32_ATI = GL_RGB_FLOAT32_ATI,
TF_ALPHA_FLOAT32_ATI = GL_ALPHA_FLOAT32_ATI, TF_INTENSITY_FLOAT32_ATI = GL_INTENSITY_FLOAT32_ATI, TF_LUMINANCE_FLOAT32_ATI = GL_LUMINANCE_FLOAT32_ATI, TF_LUMINANCE_ALPHA_FLOAT32_ATI = GL_LUMINANCE_ALPHA_FLOAT32_ATI,
TF_RGBA_FLOAT16_ATI = GL_RGBA_FLOAT16_ATI, TF_RGB_FLOAT16_ATI = GL_RGB_FLOAT16_ATI, TF_ALPHA_FLOAT16_ATI = GL_ALPHA_FLOAT16_ATI, TF_INTENSITY_FLOAT16_ATI = GL_INTENSITY_FLOAT16_ATI,
TF_LUMINANCE_FLOAT16_ATI = GL_LUMINANCE_FLOAT16_ATI, TF_LUMINANCE_ALPHA_FLOAT16_ATI = GL_LUMINANCE_ALPHA_FLOAT16_ATI, TF_RGB9_E5 = GL_RGB9_E5_EXT, TF_11F_G11F_B10F = GL_R11F_G11F_B10F_EXT,
TF_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, TF_DEPTH_COMPONENT32F = GL_DEPTH_COMPONENT32F_NV, TF_DEPTH32F_STENCIL8 = GL_DEPTH32F_STENCIL8_NV, TF_DEPTH_COMPONENT = GL_DEPTH_COMPONENT,
TF_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16, TF_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24, TF_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32, TF_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA_ARB,
TF_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY_ARB, TF_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE_ARB, TF_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA_ARB, TF_COMPRESSED_RGB = GL_COMPRESSED_RGB_ARB,
TF_COMPRESSED_RGBA = GL_COMPRESSED_RGBA_ARB, TF_COMPRESSED_RGB_FXT1_3DFX = GL_COMPRESSED_RGB_FXT1_3DFX, TF_COMPRESSED_RGBA_FXT1_3DFX = GL_COMPRESSED_RGBA_FXT1_3DFX, TF_COMPRESSED_RGB_S3TC_DXT1 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
TF_COMPRESSED_RGBA_S3TC_DXT1 = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, TF_COMPRESSED_RGBA_S3TC_DXT3 = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, TF_COMPRESSED_RGBA_S3TC_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, TF_COMPRESSED_LUMINANCE_LATC1 = GL_COMPRESSED_LUMINANCE_LATC1_EXT,
TF_COMPRESSED_SIGNED_LUMINANCE_LATC1 = GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, TF_COMPRESSED_LUMINANCE_ALPHA_LATC2 = GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, TF_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 = GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, TF_COMPRESSED_RED_RGTC1 = GL_COMPRESSED_RED_RGTC1_EXT,
TF_COMPRESSED_SIGNED_RED_RGTC1 = GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, TF_COMPRESSED_RED_GREEN_RGTC2 = GL_COMPRESSED_RED_GREEN_RGTC2_EXT, TF_COMPRESSED_SIGNED_RED_GREEN_RGTC2 = GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, TF_RGBA32UI = GL_RGBA32UI_EXT,
TF_RGB32UI = GL_RGB32UI_EXT, TF_ALPHA32UI = GL_ALPHA32UI_EXT, TF_INTENSITY32UI = GL_INTENSITY32UI_EXT, TF_LUMINANCE32UI = GL_LUMINANCE32UI_EXT,
TF_LUMINANCE_ALPHA32UI = GL_LUMINANCE_ALPHA32UI_EXT, TF_RGBA16UI = GL_RGBA16UI_EXT, TF_RGB16UI = GL_RGB16UI_EXT, TF_ALPHA16UI = GL_ALPHA16UI_EXT,
TF_INTENSITY16UI = GL_INTENSITY16UI_EXT, TF_LUMINANCE16UI = GL_LUMINANCE16UI_EXT, TF_LUMINANCE_ALPHA16UI = GL_LUMINANCE_ALPHA16UI_EXT, TF_RGBA8UI = GL_RGBA8UI_EXT,
TF_RGB8UI = GL_RGB8UI_EXT, TF_ALPHA8UI = GL_ALPHA8UI_EXT, TF_INTENSITY8UI = GL_INTENSITY8UI_EXT, TF_LUMINANCE8UI = GL_LUMINANCE8UI_EXT,
TF_LUMINANCE_ALPHA8UI = GL_LUMINANCE_ALPHA8UI_EXT, TF_RGBA32I = GL_RGBA32I_EXT, TF_RGB32I = GL_RGB32I_EXT, TF_ALPHA32I = GL_ALPHA32I_EXT,
TF_INTENSITY32I = GL_INTENSITY32I_EXT, TF_LUMINANCE32I = GL_LUMINANCE32I_EXT, TF_LUMINANCE_ALPHA32I = GL_LUMINANCE_ALPHA32I_EXT, TF_RGBA16I = GL_RGBA16I_EXT,
TF_RGB16I = GL_RGB16I_EXT, TF_ALPHA16I = GL_ALPHA16I_EXT, TF_INTENSITY16I = GL_INTENSITY16I_EXT, TF_LUMINANCE16I = GL_LUMINANCE16I_EXT,
TF_LUMINANCE_ALPHA16I = GL_LUMINANCE_ALPHA16I_EXT, TF_RGBA8I = GL_RGBA8I_EXT, TF_RGB8I = GL_RGB8I_EXT, TF_ALPHA8I = GL_ALPHA8I_EXT,
TF_INTENSITY8I = GL_INTENSITY8I_EXT, TF_LUMINANCE8I = GL_LUMINANCE8I_EXT, TF_LUMINANCE_ALPHA8I = GL_LUMINANCE_ALPHA8I_EXT
}
enum EColorBufferFormat {
CBF_RGB = GL_RGB, CBF_RGBA = GL_RGBA, CBF_R3_G3_B2 = GL_R3_G3_B2, CBF_RGB4 = GL_RGB4,
CBF_RGB5 = GL_RGB5, CBF_RGB8 = GL_RGB8, CBF_RGB10 = GL_RGB10, CBF_RGB12 = GL_RGB12,
CBF_RGB16 = GL_RGB16, CBF_RGBA2 = GL_RGBA2, CBF_RGBA4 = GL_RGBA4, CBF_RGB5_A1 = GL_RGB5_A1,
CBF_RGBA8 = GL_RGBA8, CBF_RGB10_A2 = GL_RGB10_A2, CBF_RGBA12 = GL_RGBA12, CBF_RGBA16 = GL_RGBA16,
CBF_FLOAT_R_NV = GL_FLOAT_R_NV, CBF_FLOAT_RG_NV = GL_FLOAT_RG_NV, CBF_FLOAT_RGB_NV = GL_FLOAT_RGB_NV, CBF_FLOAT_RGBA_NV = GL_FLOAT_RGBA_NV,
CBF_FLOAT_R16_NV = GL_FLOAT_R16_NV, CBF_FLOAT_RG16_NV = GL_FLOAT_RG16_NV, CBF_FLOAT_RGB16_NV = GL_FLOAT_RGB16_NV, CBF_FLOAT_RGBA16_NV = GL_FLOAT_RGBA16_NV,
CBF_FLOAT_R32_NV = GL_FLOAT_R32_NV, CBF_FLOAT_RG32_NV = GL_FLOAT_RG32_NV, CBF_FLOAT_RGB32_NV = GL_FLOAT_RGB32_NV, CBF_FLOAT_RGBA32_NV = GL_FLOAT_RGBA32_NV,
CBF_RGB9_E5 = GL_RGB9_E5_EXT, CBF_11F_G11F_B10F = GL_R11F_G11F_B10F_EXT
}
enum EAttachmentPoint {
AP_NO_ATTACHMENT = 0, AP_COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT, AP_COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1_EXT, AP_COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2_EXT,
AP_COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3_EXT, AP_COLOR_ATTACHMENT4 = GL_COLOR_ATTACHMENT4_EXT, AP_COLOR_ATTACHMENT5 = GL_COLOR_ATTACHMENT5_EXT, AP_COLOR_ATTACHMENT6 = GL_COLOR_ATTACHMENT6_EXT,
AP_COLOR_ATTACHMENT7 = GL_COLOR_ATTACHMENT7_EXT, AP_COLOR_ATTACHMENT8 = GL_COLOR_ATTACHMENT8_EXT, AP_COLOR_ATTACHMENT9 = GL_COLOR_ATTACHMENT9_EXT, AP_COLOR_ATTACHMENT10 = GL_COLOR_ATTACHMENT10_EXT,
AP_COLOR_ATTACHMENT11 = GL_COLOR_ATTACHMENT11_EXT, AP_COLOR_ATTACHMENT12 = GL_COLOR_ATTACHMENT12_EXT, AP_COLOR_ATTACHMENT13 = GL_COLOR_ATTACHMENT13_EXT, AP_COLOR_ATTACHMENT14 = GL_COLOR_ATTACHMENT14_EXT,
AP_COLOR_ATTACHMENT15 = GL_COLOR_ATTACHMENT15_EXT, AP_DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT_EXT, AP_STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT_EXT
}
enum ETex2DTarget {
T2DT_TEXTURE_2D = GL_TEXTURE_2D, T2DT_TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, T2DT_TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, T2DT_TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, T2DT_TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, T2DT_TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE_ARB,
T2DT_TEXTURE_1D_ARRAY = GL_TEXTURE_1D_ARRAY_EXT
}
enum EImageFormat {
IF_RGB = GL_RGB, IF_RGBA = GL_RGBA, IF_BGR = GL_BGR, IF_BGRA = GL_BGRA,
IF_RED = GL_RED, IF_GREEN = GL_GREEN, IF_BLUE = GL_BLUE, IF_ALPHA = GL_ALPHA,
IF_LUMINANCE = GL_LUMINANCE, IF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA, IF_DEPTH_COMPONENT = GL_DEPTH_COMPONENT, IF_STENCIL_INDEX = GL_STENCIL_INDEX,
IF_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, IF_COMPRESSED_RGB_S3TC_DXT1 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT, IF_COMPRESSED_RGBA_S3TC_DXT1 = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, IF_COMPRESSED_RGBA_S3TC_DXT3 = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
IF_COMPRESSED_RGBA_S3TC_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, IF_RED_INTEGER = GL_RED_INTEGER_EXT, IF_GREEN_INTEGER = GL_GREEN_INTEGER_EXT, IF_BLUE_INTEGER = GL_BLUE_INTEGER_EXT,
IF_ALPHA_INTEGER = GL_ALPHA_INTEGER_EXT, IF_RGB_INTEGER = GL_RGB_INTEGER_EXT, IF_RGBA_INTEGER = GL_RGBA_INTEGER_EXT, IF_BGR_INTEGER = GL_BGR_INTEGER_EXT,
IF_BGRA_INTEGER = GL_BGRA_INTEGER_EXT, IF_LUMINANCE_INTEGER = GL_LUMINANCE_INTEGER_EXT, IF_LUMINANCE_ALPHA_INTEGER = GL_LUMINANCE_ALPHA_INTEGER_EXT
}
enum EDepthType {
DT_DEPTH_COMPONENT = GL_DEPTH_COMPONENT, DT_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16, DT_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24, DT_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32,
DT_DEPTH_COMPONENT32F = GL_DEPTH_COMPONENT32F_NV
}
enum | EStencilType { ST_STENCIL_INDEX1 = GL_STENCIL_INDEX1_EXT, ST_STENCIL_INDEX4 = GL_STENCIL_INDEX4_EXT, ST_STENCIL_INDEX8 = GL_STENCIL_INDEX8_EXT, ST_STENCIL_INDEX16 = GL_STENCIL_INDEX16_EXT }
enum | EDepthStencilType { DST_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, DST_DEPTH24_STENCIL8 = GL_DEPTH_STENCIL_EXT, DST_DEPTH32F_STENCIL8 = GL_DEPTH32F_STENCIL8_NV }
enum EClearFlags {
CF_DO_NOT_CLEAR = 0, CF_CLEAR_COLOR = GL_COLOR_BUFFER_BIT, CF_CLEAR_DEPTH = GL_DEPTH_BUFFER_BIT, CF_CLEAR_STENCIL = GL_STENCIL_BUFFER_BIT,
CF_CLEAR_COLOR_DEPTH = CF_CLEAR_COLOR + CF_CLEAR_DEPTH, CF_CLEAR_COLOR_STENCIL = CF_CLEAR_COLOR + CF_CLEAR_STENCIL, CF_CLEAR_DEPTH_STENCIL = CF_CLEAR_DEPTH + CF_CLEAR_STENCIL, CF_CLEAR_COLOR_DEPTH_STENCIL = CF_CLEAR_COLOR + CF_CLEAR_DEPTH + CF_CLEAR_STENCIL
}
enum | EClearColorMode { CCM_Float, CCM_Int, CCM_UInt }
enum EBlendFactor {
BF_ZERO = GL_ZERO, BF_ONE = GL_ONE, BF_SRC_COLOR = GL_SRC_COLOR, BF_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR,
BF_DST_COLOR = GL_DST_COLOR, BF_ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR, BF_SRC_ALPHA = GL_SRC_ALPHA, BF_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA,
BF_DST_ALPHA = GL_DST_ALPHA, BF_ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA, BF_CONSTANT_COLOR = GL_CONSTANT_COLOR, BF_ONE_MINUS_CONSTANT_COLOR = GL_ONE_MINUS_CONSTANT_COLOR,
BF_CONSTANT_ALPHA = GL_CONSTANT_ALPHA, BF_ONE_MINUS_CONSTANT_ALPHA = GL_ONE_MINUS_CONSTANT_ALPHA, BF_SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE
}
enum ETextureDimension {
TD_TEXTURE_1D = GL_TEXTURE_1D, TD_TEXTURE_2D = GL_TEXTURE_2D, TD_TEXTURE_3D = GL_TEXTURE_3D, TD_TEXTURE_CUBE_MAP = GL_TEXTURE_CUBE_MAP,
TD_TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE_ARB, TD_TEXTURE_1D_ARRAY = GL_TEXTURE_1D_ARRAY_EXT, TD_TEXTURE_2D_ARRAY = GL_TEXTURE_2D_ARRAY_EXT
}
enum | ETexCompareMode { TCM_NONE = GL_NONE, TCM_COMPARE_R_TO_TEXTURE = GL_COMPARE_R_TO_TEXTURE, TCM_COMPARE_REF_DEPTH_TO_TEXTURE = GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT }
enum ETexCompareFunc {
TCF_LEQUAL = GL_LEQUAL, TCF_GEQUAL = GL_GEQUAL, TCF_LESS = GL_LESS, TCF_GREATER = GL_GREATER,
TCF_EQUAL = GL_EQUAL, TCF_NOTEQUAL = GL_NOTEQUAL, TCF_ALWAYS = GL_ALWAYS, TCF_NEVER = GL_NEVER
}
enum | EDepthTextureMode { DTM_LUMINANCE = GL_LUMINANCE, DTM_INTENSITY = GL_INTENSITY, DTM_ALPHA = GL_ALPHA }
enum EReadDrawBuffer {
RDB_NONE = GL_NONE, RDB_FRONT_LEFT = GL_FRONT_LEFT, RDB_FRONT_RIGHT = GL_FRONT_RIGHT, RDB_BACK_LEFT = GL_BACK_LEFT,
RDB_BACK_RIGHT = GL_BACK_RIGHT, RDB_AUX0 = GL_AUX0, RDB_AUX1 = GL_AUX1, RDB_AUX2 = GL_AUX2,
RDB_AUX3 = GL_AUX3, RDB_COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT, RDB_COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1_EXT, RDB_COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2_EXT,
RDB_COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3_EXT, RDB_COLOR_ATTACHMENT4 = GL_COLOR_ATTACHMENT4_EXT, RDB_COLOR_ATTACHMENT5 = GL_COLOR_ATTACHMENT5_EXT, RDB_COLOR_ATTACHMENT6 = GL_COLOR_ATTACHMENT6_EXT,
RDB_COLOR_ATTACHMENT7 = GL_COLOR_ATTACHMENT7_EXT, RDB_COLOR_ATTACHMENT8 = GL_COLOR_ATTACHMENT8_EXT, RDB_COLOR_ATTACHMENT9 = GL_COLOR_ATTACHMENT9_EXT, RDB_COLOR_ATTACHMENT10 = GL_COLOR_ATTACHMENT10_EXT,
RDB_COLOR_ATTACHMENT11 = GL_COLOR_ATTACHMENT11_EXT, RDB_COLOR_ATTACHMENT12 = GL_COLOR_ATTACHMENT12_EXT, RDB_COLOR_ATTACHMENT13 = GL_COLOR_ATTACHMENT13_EXT, RDB_COLOR_ATTACHMENT14 = GL_COLOR_ATTACHMENT14_EXT,
RDB_COLOR_ATTACHMENT15 = GL_COLOR_ATTACHMENT15_EXT
}
enum EImageType {
IT_COMPRESSED_TYPE = 0, IT_UNSIGNED_BYTE = GL_UNSIGNED_BYTE, IT_BYTE = GL_BYTE, IT_UNSIGNED_SHORT = GL_UNSIGNED_SHORT,
IT_SHORT = GL_SHORT, IT_UNSIGNED_INT = GL_UNSIGNED_INT, IT_INT = GL_INT, IT_FLOAT = GL_FLOAT,
IT_UNSIGNED_BYTE_3_3_2 = GL_UNSIGNED_BYTE_3_3_2, IT_UNSIGNED_BYTE_2_3_3_REV = GL_UNSIGNED_BYTE_2_3_3_REV, IT_UNSIGNED_SHORT_5_6_5 = GL_UNSIGNED_SHORT_5_6_5, IT_UNSIGNED_SHORT_5_6_5_REV = GL_UNSIGNED_SHORT_5_6_5_REV,
IT_UNSIGNED_SHORT_4_4_4_4 = GL_UNSIGNED_SHORT_4_4_4_4, IT_UNSIGNED_SHORT_4_4_4_4_REV = GL_UNSIGNED_SHORT_4_4_4_4_REV, IT_UNSIGNED_SHORT_5_5_5_1 = GL_UNSIGNED_SHORT_5_5_5_1, IT_UNSIGNED_SHORT_1_5_5_5_REV = GL_UNSIGNED_SHORT_1_5_5_5_REV,
IT_UNSIGNED_INT_8_8_8_8 = GL_UNSIGNED_INT_8_8_8_8, IT_UNSIGNED_INT_8_8_8_8_REV = GL_UNSIGNED_INT_8_8_8_8_REV, IT_UNSIGNED_INT_10_10_10_2 = GL_UNSIGNED_INT_10_10_10_2, IT_UNSIGNED_INT_2_10_10_10_REV = GL_UNSIGNED_INT_2_10_10_10_REV,
IT_UNSIGNED_INT_5_9_9_9_REV = GL_UNSIGNED_INT_5_9_9_9_REV_EXT, IT_UNSIGNED_INT_10F_11F_11F_REV = GL_UNSIGNED_INT_10F_11F_11F_REV_EXT, IT_UNSIGNED_INT_24_8 = GL_UNSIGNED_INT_24_8_EXT, IT_FLOAT_32_UNSIGNED_INT_24_8_REV = GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV
}
enum EPrimitiveType {
PT_POINTS = GL_POINTS, PT_LINES = GL_LINES, PT_LINE_LOOP = GL_LINE_LOOP, PT_LINE_STRIP = GL_LINE_STRIP,
PT_TRIANGLES = GL_TRIANGLES, PT_TRIANGLE_STRIP = GL_TRIANGLE_STRIP, PT_TRIANGLE_FAN = GL_TRIANGLE_FAN, PT_QUADS = GL_QUADS,
PT_QUAD_STRIP = GL_QUAD_STRIP, PT_POLYGON = GL_POLYGON, PT_LINES_ADJACENCY = GL_LINES_ADJACENCY_EXT, PT_LINE_STRIP_ADJACENCY = GL_LINE_STRIP_ADJACENCY_EXT,
PT_TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY_EXT, PT_TRIANGLE_STRIP_ADJACENCY = GL_TRIANGLE_STRIP_ADJACENCY_EXT
}
enum | EPolygonFace { PF_FRONT = GL_FRONT, PF_BACK = GL_BACK, PF_FRONT_AND_BACK = GL_FRONT_AND_BACK }
enum | EHintMode { HM_FASTEST = GL_FASTEST, HM_NICEST = GL_NICEST, HM_DONT_CARE = GL_DONT_CARE }
enum | EFrontFace { FF_CW = GL_CW, FF_CCW = GL_CCW }
enum EFunction {
FU_NEVER = GL_NEVER, FU_LESS = GL_LESS, FU_EQUAL = GL_EQUAL, FU_LEQUAL = GL_LEQUAL,
FU_GREATER = GL_GREATER, FU_NOTEQUAL = GL_NOTEQUAL, FU_GEQUAL = GL_GEQUAL, FU_ALWAYS = GL_ALWAYS
}
enum | EPolygonMode { PM_FILL = GL_FILL, PM_LINE = GL_LINE, PM_POINT = GL_POINT }
enum | EShadeModel { SM_FLAT = GL_FLAT, SM_SMOOTH = GL_SMOOTH }
enum EBlendEquation {
BE_FUNC_ADD = GL_FUNC_ADD, BE_FUNC_SUBTRACT = GL_FUNC_SUBTRACT, BE_FUNC_REVERSE_SUBTRACT = GL_FUNC_REVERSE_SUBTRACT, BE_MIN = GL_MIN,
BE_MAX = GL_MAX
}
enum EColorMaterial {
CM_EMISSION = GL_EMISSION, CM_AMBIENT = GL_AMBIENT, CM_DIFFUSE = GL_DIFFUSE, CM_SPECULAR = GL_SPECULAR,
CM_AMBIENT_AND_DIFFUSE = GL_AMBIENT_AND_DIFFUSE
}
enum | EColorControl { CC_SEPARATE_SPECULAR_COLOR = GL_SEPARATE_SPECULAR_COLOR, CC_SINGLE_COLOR = GL_SINGLE_COLOR }
enum | EFogMode { FM_LINEAR = GL_LINEAR, FM_EXP = GL_EXP, FM_EXP2 = GL_EXP2 }
enum ELogicOp {
LO_CLEAR = GL_CLEAR, LO_SET = GL_SET, LO_COPY = GL_COPY, LO_COPY_INVERTED = GL_COPY_INVERTED,
LO_NOOP = GL_NOOP, LO_INVERT = GL_INVERT, LO_AND = GL_AND, LO_NAND = GL_NAND,
LO_OR = GL_OR, LO_NOR = GL_NOR, LO_XOR = GL_XOR, LO_EQUIV = GL_EQUIV,
LO_AND_REVERSE = GL_AND_REVERSE, LO_AND_INVERTED = GL_AND_INVERTED, LO_OR_REVERSE = GL_OR_REVERSE, LO_OR_INVERTED = GL_OR_INVERTED
}
enum EStencilOp {
SO_KEEP = GL_KEEP, SO_ZERO = GL_ZERO, SO_REPLACE = GL_REPLACE, SO_INCR = GL_INCR,
SO_INCR_WRAP = GL_INCR_WRAP, SO_DECR = GL_DECR, SO_DECR_WRAP = GL_DECR_WRAP, SO_INVERT = GL_INVERT
}
enum ETexParamFilter {
TPF_NEAREST = GL_NEAREST, TPF_LINEAR = GL_LINEAR, TPF_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST, TPF_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
TPF_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR, TPF_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
}
enum ETexParamWrap {
TPW_CLAMP = GL_CLAMP, TPW_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER, TPW_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE, TPW_MIRRORED_REPEAT = GL_MIRRORED_REPEAT,
TPW_REPEAT = GL_REPEAT
}
enum ETexEnvMode {
TEM_DECAL = GL_DECAL, TEM_MODULATE = GL_MODULATE, TEM_ADD = GL_ADD, TEM_BLEND = GL_BLEND,
TEM_REPLACE = GL_REPLACE, TEM_COMBINE = GL_COMBINE, TEM_ADD_SIGN = GL_ADD_SIGNED, TEM_INTERPOLATE = GL_INTERPOLATE,
TEM_SUBTRACT = GL_SUBTRACT, TEM_DOT3_RGB = GL_DOT3_RGB, TEM_DOT3_RGBA = GL_DOT3_RGBA
}
enum ETexEnvSource {
TES_TEXTURE = GL_TEXTURE, TES_TEXTURE0 = GL_TEXTURE0, TES_TEXTURE1 = GL_TEXTURE1, TES_TEXTURE2 = GL_TEXTURE2,
TES_TEXTURE3 = GL_TEXTURE3, TES_TEXTURE4 = GL_TEXTURE4, TES_TEXTURE5 = GL_TEXTURE5, TES_TEXTURE6 = GL_TEXTURE6,
TES_TEXTURE7 = GL_TEXTURE7, TES_CONSTANT = GL_CONSTANT, TES_PRIMARY_COLOR = GL_PRIMARY_COLOR, TES_PREVIOUS = GL_PREVIOUS
}
enum | ETexEnvOperand { TEO_SRC_COLOR = GL_SRC_COLOR, TEO_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR, TEO_SRC_ALPHA = GL_SRC_ALPHA, TEO_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA }
enum ETexGenMode {
TGM_DISABLED = 0, TGM_EYE_LINEAR = GL_EYE_LINEAR, TGM_OBJECT_LINEAR = GL_OBJECT_LINEAR, TGM_SPHERE_MAP = GL_SPHERE_MAP,
TGM_REFLECTION_MAP = GL_REFLECTION_MAP, TGM_NORMAL_MAP = GL_NORMAL_MAP
}
Texture generation modes, see http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information. More...
enum EEnable {
EN_ALPHA_TEST, EN_BLEND, EN_COLOR_LOGIC_OP, EN_LIGHTING,
EN_COLOR_SUM, EN_CULL_FACE, EN_DEPTH_TEST, EN_FOG,
EN_LINE_SMOOTH, EN_LINE_STIPPLE, EN_POLYGON_STIPPLE, EN_NORMALIZE,
EN_POINT_SMOOTH, EN_POINT_SPRITE, EN_POLYGON_SMOOTH, EN_POLYGON_OFFSET_FILL,
EN_POLYGON_OFFSET_LINE, EN_POLYGON_OFFSET_POINT, EN_RESCALE_NORMAL, EN_STENCIL_TEST,
EN_VERTEX_PROGRAM_POINT_SIZE, EN_VERTEX_PROGRAM_TWO_SIDE, EN_MULTISAMPLE, EN_SAMPLE_ALPHA_TO_COVERAGE,
EN_SAMPLE_ALPHA_TO_ONE, EN_SAMPLE_COVERAGE, EN_EnableCount, EN_UnknownEnable
}
Constant that enable/disable a specific OpenGL feature, see also Shader, Shader::enable(), Shader::disable(), Shader::isEnabled(). More...
enum EGLBufferUsage {
GBU_STREAM_DRAW = GL_STREAM_DRAW, GBU_STREAM_READ = GL_STREAM_READ, GBU_STREAM_COPY = GL_STREAM_COPY, GBU_STATIC_DRAW = GL_STATIC_DRAW,
GBU_STATIC_READ = GL_STATIC_READ, GBU_STATIC_COPY = GL_STATIC_COPY, GBU_DYNAMIC_DRAW = GL_DYNAMIC_DRAW, GBU_DYNAMIC_READ = GL_DYNAMIC_READ,
GBU_DYNAMIC_COPY = GL_DYNAMIC_COPY
}
enum | EGLBufferAccess { GBA_READ_ONLY = GL_READ_ONLY, GBA_WRITE_ONLY = GL_WRITE_ONLY, GBA_READ_WRITE = GL_READ_WRITE }
enum EAlign {
AlignLeft = 1, AlignHCenter = 2, AlignRight = 4, AlignTop = 8,
AlignVCenter = 16, AlignBottom = 32
}
enum | ETextAlign { TextAlignLeft, TextAlignRight, TextAlignCenter, TextAlignJustify }
enum | ETextMode { Text2D = 1, Text3D = 2 }
enum | ETextLayout { LeftToRightText, RightToLeftText, TopToBottomText }
enum | EDepthSortMode { NeverDepthSort, AlwaysDepthSort, AlphaDepthSort }
enum EImageDimension {
ID_Error = 0, ID_1D = 1, ID_2D = 2, ID_3D = 3,
ID_Cubemap = 4
}
enum EStateType {
ST_RenderStates = 1, ST_Enables = 2, ST_TextureUnits = 4, ST_Lights = 8,
ST_ClipPlanes = 16
}
enum ERenderState {
RS_AlphaFunc, RS_BlendColor, RS_BlendEquation, RS_BlendFunc,
RS_ColorMask, RS_CullFace, RS_DepthFunc, RS_DepthMask,
RS_DepthRange, RS_Fog, RS_FrontFace, RS_PolygonMode,
RS_Hint, RS_LightModel, RS_LineStipple, RS_LineWidth,
RS_LogicOp, RS_Material, RS_PixelTransfer, RS_PointParameter,
RS_PointSize, RS_PolygonOffset, RS_PolygonStipple, RS_SampleCoverage,
RS_ShadeModel, RS_StencilFunc, RS_StencilMask, RS_StencilOp,
RS_GLSLProgram, RS_Light0, RS_Light1, RS_Light2,
RS_Light3, RS_Light4, RS_Light5, RS_Light6,
RS_Light7, RS_ClipPlane0, RS_ClipPlane1, RS_ClipPlane2,
RS_ClipPlane3, RS_ClipPlane4, RS_ClipPlane5, RS_TextureUnit0,
RS_TexGen0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*1, RS_TexEnv0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*2, RS_TextureMatrix0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*3, RS_COUNT = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*4,
RS_NONE
}
enum | ERenderingCallback { RC_PreRendering, RC_PostRendering }
enum EGeometryInputType {
GIT_POINTS = GL_POINTS, GIT_LINES = GL_LINES, GIT_LINES_ADJACENCY = GL_LINES_ADJACENCY_EXT, GIT_TRIANGLES = GL_TRIANGLES,
GIT_TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY_EXT
}
enum | EGeometryOutputType { GOT_POINTS = GL_POINTS, GOT_LINE_STRIP = GL_LINE_STRIP, GOT_TRIANGLE_STRIP = GL_TRIANGLE_STRIP }
enum | EBufferBits { BB_COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT, BB_DEPTH_BUFFER_BIT = GL_DEPTH_BUFFER_BIT, BB_STENCIL_BUFFER_BIT = GL_STENCIL_BUFFER_BIT }
enum | EBillboardType { BT_AxisAlignedBillboard = 1, BT_SphericalBillboard = 2 }
enum | ESortMode { SM_SortBackToFront, SM_SortFrontToBack }
enum | EGetMode { GM_GetOrCreate, GM_DontCreate }
enum EStringEncoding {
SE_Unknown, SE_ASCII, SE_UTF8, SE_UTF16_BE,
SE_UTF16_LE, SE_UTF32_BE, SE_UTF32_LE, SE_LATIN1
}
enum | EOpenMode { OM_ReadOnly, OM_WriteOnly }
enum EKey {
Key_None = 0, Key_0, Key_1, Key_2,
Key_3, Key_4, Key_5, Key_6,
Key_7, Key_8, Key_9, Key_A,
Key_B, Key_C, Key_D, Key_E,
Key_F, Key_G, Key_H, Key_I,
Key_J, Key_K, Key_L, Key_M,
Key_N, Key_O, Key_P, Key_Q,
Key_R, Key_S, Key_T, Key_U,
Key_V, Key_W, Key_X, Key_Y,
Key_Z, Key_Return, Key_BackSpace, Key_Tab,
Key_Space, Key_Clear, Key_Escape, Key_Exclam,
Key_QuoteDbl, Key_Hash, Key_Dollar, Key_Ampersand,
Key_Quote, Key_LeftParen, Key_RightParen, Key_Asterisk,
Key_Plus, Key_Comma, Key_Minus, Key_Period,
Key_Slash, Key_Colon, Key_Semicolon, Key_Less,
Key_Equal, Key_Greater, Key_Question, Key_At,
Key_LeftBracket, Key_BackSlash, Key_RightBracket, Key_Caret,
Key_Underscore, Key_QuoteLeft, Key_Ctrl, Key_LeftCtrl,
Key_RightCtrl, Key_Alt, Key_LeftAlt, Key_RightAlt,
Key_Shift, Key_LeftShift, Key_RightShift, Key_Insert,
Key_Delete, Key_Home, Key_End, Key_Print,
Key_Pause, Key_PageUp, Key_PageDown, Key_Left,
Key_Right, Key_Up, Key_Down, Key_F1,
Key_F2, Key_F3, Key_F4, Key_F5,
Key_F6, Key_F7, Key_F8, Key_F9,
Key_F10, Key_F11, Key_F12, Key_Unknown,
Key_NumberOfKeys
}
enum EMouseButton {
NoButton = 0, LeftButton = 1, RightButton = 2, MiddleButton = 4,
UnknownButton
}
enum EInheritance {
IN_Local = 0x00, IN_Propagate = 0x01, IN_Sticky = 0x04, IN_Propagate_Overrides_Sticky = 0x01 | 0x02 | 0x04,
IN_Propagate_Overrides = 0x01 | 0x02, IN_Propagate_Sticky = 0x01 | 0x04
}
enum | EShaderType { ST_VERTEX_SHADER = GL_VERTEX_SHADER, ST_FRAGMENT_SHADER = GL_FRAGMENT_SHADER, ST_GEOMETRY_SHADER = GL_GEOMETRY_SHADER_EXT }
enum ETessellationWinding {
TW_TESS_WINDING_ODD = GLU_TESS_WINDING_ODD, TW_TESS_WINDING_NONZERO = GLU_TESS_WINDING_NONZERO, TW_TESS_WINDING_POSITIVE = GLU_TESS_WINDING_POSITIVE, TW_TESS_WINDING_NEGATIVE = GLU_TESS_WINDING_NEGATIVE,
TW_TESS_WINDING_ABS_GEQ_TWO = GLU_TESS_WINDING_ABS_GEQ_TWO
}

Functions

void | log_failed_check (const char *, const char *, int)
float | asinh (float x)
double | asinh (double x)
float | acosh (float x)
double | acosh (double x)
float | atanh (float x)
double | atanh (double x)
template<typename T >
bool | isnan (T value)
template<typename T >
bool | isinf (T value)
template<typename T >
bool | isinf_pos (T value)
template<typename T >
bool | isinf_neg (T value)
float | modf (float a, float &intpart)
double | modf (double a, double &intpart)
float | radians (float degrees)
fvec2 | radians (const fvec2 &degrees)
fvec3 | radians (const fvec3 &degrees)
fvec4 | radians (const fvec4 &degrees)
double | radians (double degrees)
float | degrees (float radians)
fvec2 | degrees (const fvec2 &radians)
fvec3 | degrees (const fvec3 &radians)
fvec4 | degrees (const fvec4 &radians)
double | degrees (double radians)
float | sin (float a)
fvec2 | sin (const fvec2 &angle)
fvec3 | sin (const fvec3 &angle)
fvec4 | sin (const fvec4 &angle)
double | sin (double a)
float | cos (float a)
fvec2 | cos (const fvec2 &angle)
fvec3 | cos (const fvec3 &angle)
fvec4 | cos (const fvec4 &angle)
double | cos (double a)
float | tan (float a)
fvec2 | tan (const fvec2 &angle)
fvec3 | tan (const fvec3 &angle)
fvec4 | tan (const fvec4 &angle)
double | tan (double a)
float | asin (float a)
fvec2 | asin (const fvec2 &angle)
fvec3 | asin (const fvec3 &angle)
fvec4 | asin (const fvec4 &angle)
double | asin (double a)
float | acos (float a)
fvec2 | acos (const fvec2 &angle)
fvec3 | acos (const fvec3 &angle)
fvec4 | acos (const fvec4 &angle)
double | acos (double a)
float | atan (float a)
fvec2 | atan (const fvec2 &a, const fvec2 &b)
fvec3 | atan (const fvec3 &a, const fvec3 &b)
fvec4 | atan (const fvec4 &a, const fvec4 &b)
double | atan (double a)
float | sinh (float a)
fvec2 | sinh (const fvec2 &a)
fvec3 | sinh (const fvec3 &a)
fvec4 | sinh (const fvec4 &a)
double | sinh (double a)
float | cosh (float a)
fvec2 | cosh (const fvec2 &a)
fvec3 | cosh (const fvec3 &a)
fvec4 | cosh (const fvec4 &a)
double | cosh (double a)
float | tanh (float a)
fvec2 | tanh (const fvec2 &a)
fvec3 | tanh (const fvec3 &a)
fvec4 | tanh (const fvec4 &a)
double | tanh (double a)
fvec2 | asinh (const fvec2 &a)
fvec3 | asinh (const fvec3 &a)
fvec4 | asinh (const fvec4 &a)
fvec2 | acosh (const fvec2 &a)
fvec3 | acosh (const fvec3 &a)
fvec4 | acosh (const fvec4 &a)
fvec2 | atanh (const fvec2 &a)
fvec3 | atanh (const fvec3 &a)
fvec4 | atanh (const fvec4 &a)
float | pow (float a, float b)
fvec2 | pow (const fvec2 &a, const fvec2 &b)
fvec3 | pow (const fvec3 &a, const fvec3 &b)
fvec4 | pow (const fvec4 &a, const fvec4 &b)
double | pow (double a, double b)
float | exp (float a)
fvec2 | exp (const fvec2 &a)
fvec3 | exp (const fvec3 &a)
fvec4 | exp (const fvec4 &a)
double | exp (double a)
float | log (float a)
fvec2 | log (const fvec2 &a)
fvec3 | log (const fvec3 &a)
fvec4 | log (const fvec4 &a)
double | log (double a)
float | exp2 (float a)
fvec2 | exp2 (const fvec2 &a)
fvec3 | exp2 (const fvec3 &a)
fvec4 | exp2 (const fvec4 &a)
double | exp2 (double a)
float | log2 (float a)
fvec2 | log2 (const fvec2 &a)
fvec3 | log2 (const fvec3 &a)
fvec4 | log2 (const fvec4 &a)
double | log2 (double a)
float | log10 (float a)
fvec2 | log10 (const fvec2 &a)
fvec3 | log10 (const fvec3 &a)
fvec4 | log10 (const fvec4 &a)
double | log10 (double a)
float | sqrt (float a)
fvec2 | sqrt (const fvec2 &a)
fvec3 | sqrt (const fvec3 &a)
fvec4 | sqrt (const fvec4 &a)
double | sqrt (double a)
float | inversesqrt (float a)
fvec2 | inversesqrt (const fvec2 &a)
fvec3 | inversesqrt (const fvec3 &a)
fvec4 | inversesqrt (const fvec4 &a)
double | inversesqrt (double a)
float | abs (float a)
fvec2 | abs (const fvec2 &a)
fvec3 | abs (const fvec3 &a)
fvec4 | abs (const fvec4 &a)
double | abs (double a)
int | abs (int a)
float | sign (float a)
fvec2 | sign (const fvec2 &a)
fvec3 | sign (const fvec3 &a)
fvec4 | sign (const fvec4 &a)
double | sign (double a)
int | sign (int a)
float | floor (float a)
fvec2 | floor (const fvec2 &a)
fvec3 | floor (const fvec3 &a)
fvec4 | floor (const fvec4 &a)
double | floor (double a)
float | fract (float)
float | trunc (float a)
fvec2 | trunc (const fvec2 &a)
fvec3 | trunc (const fvec3 &a)
fvec4 | trunc (const fvec4 &a)
double | fract (double)
double | trunc (double a)
float | round (float x)
fvec2 | round (const fvec2 &a)
fvec3 | round (const fvec3 &a)
fvec4 | round (const fvec4 &a)
double | round (double x)
float | roundEven (float a, float epsilon=0.00001f)
fvec2 | roundEven (const fvec2 &a, float epsilon=0.00001f)
fvec3 | roundEven (const fvec3 &a, float epsilon=0.00001f)
fvec4 | roundEven (const fvec4 &a, float epsilon=0.00001f)
double | roundEven (double a, double epsilon=0.00001)
dvec2 | roundEven (const dvec2 &a, double epsilon=0.00001)
dvec3 | roundEven (const dvec3 &a, double epsilon=0.00001)
dvec4 | roundEven (const dvec4 &a, double epsilon=0.00001)
float | ceil (float a)
fvec2 | ceil (const fvec2 &a)
fvec3 | ceil (const fvec3 &a)
fvec4 | ceil (const fvec4 &a)
double | ceil (double a)
fvec2 | fract (const fvec2 &a)
fvec3 | fract (const fvec3 &a)
fvec4 | fract (const fvec4 &a)
float | mod (float a, float b)
fvec2 | mod (const fvec2 &a, float b)
fvec3 | mod (const fvec3 &a, float b)
fvec4 | mod (const fvec4 &a, float b)
fvec2 | mod (const fvec2 &a, const fvec2 &b)
fvec3 | mod (const fvec3 &a, const fvec3 &b)
fvec4 | mod (const fvec4 &a, const fvec4 &b)
double | mod (double a, double b)
dvec2 | mod (const dvec2 &a, double b)
dvec3 | mod (const dvec3 &a, double b)
dvec4 | mod (const dvec4 &a, double b)
fvec2 | modf (const fvec2 &a, fvec2 &intpart)
fvec3 | modf (const fvec3 &a, fvec3 &intpart)
fvec4 | modf (const fvec4 &a, fvec4 &intpart)
float | min (float a, float b)
fvec2 | min (const fvec2 &a, const fvec2 &b)
fvec3 | min (const fvec3 &a, const fvec3 &b)
fvec4 | min (const fvec4 &a, const fvec4 &b)
fvec2 | min (const fvec2 &a, float b)
fvec3 | min (const fvec3 &a, float b)
fvec4 | min (const fvec4 &a, float b)
double | min (double a, double b)
dvec2 | min (const dvec2 &a, double b)
dvec3 | min (const dvec3 &a, double b)
dvec4 | min (const dvec4 &a, double b)
int | min (int a, int b)
ivec2 | min (const ivec2 &a, int b)
ivec3 | min (const ivec3 &a, int b)
ivec4 | min (const ivec4 &a, int b)
unsigned int | min (unsigned int a, unsigned int b)
uvec2 | min (const uvec2 &a, unsigned int b)
uvec3 | min (const uvec3 &a, unsigned int b)
uvec4 | min (const uvec4 &a, unsigned int b)
float | max (float a, float b)
fvec2 | max (const fvec2 &a, const fvec2 &b)
fvec3 | max (const fvec3 &a, const fvec3 &b)
fvec4 | max (const fvec4 &a, const fvec4 &b)
fvec2 | max (const fvec2 &a, float b)
fvec3 | max (const fvec3 &a, float b)
fvec4 | max (const fvec4 &a, float b)
double | max (double a, double b)
dvec2 | max (const dvec2 &a, double b)
dvec3 | max (const dvec3 &a, double b)
dvec4 | max (const dvec4 &a, double b)
int | max (int a, int b)
ivec2 | max (const ivec2 &a, int b)
ivec3 | max (const ivec3 &a, int b)
ivec4 | max (const ivec4 &a, int b)
unsigned int | max (unsigned int a, unsigned int b)
uvec2 | max (const uvec2 &a, unsigned int b)
uvec3 | max (const uvec3 &a, unsigned int b)
uvec4 | max (const uvec4 &a, unsigned int b)
float | clamp (float x, float minval, float maxval)
fvec2 | clamp (const fvec2 &x, float minval, float maxval)
fvec3 | clamp (const fvec3 &x, float minval, float maxval)
fvec4 | clamp (const fvec4 &x, float minval, float maxval)
fvec2 | clamp (const fvec2 &x, const fvec2 &minval, const fvec2 &maxval)
fvec3 | clamp (const fvec3 &x, const fvec3 &minval, const fvec3 &maxval)
fvec4 | clamp (const fvec4 &x, const fvec4 &minval, const fvec4 &maxval)
double | clamp (double x, double minval, double maxval)
dvec2 | clamp (const dvec2 &x, double minval, double maxval)
dvec3 | clamp (const dvec3 &x, double minval, double maxval)
dvec4 | clamp (const dvec4 &x, double minval, double maxval)
int | clamp (int x, int minval, int maxval)
ivec2 | clamp (const ivec2 &x, int minval, int maxval)
ivec3 | clamp (const ivec3 &x, int minval, int maxval)
ivec4 | clamp (const ivec4 &x, int minval, int maxval)
unsigned int | clamp (unsigned int x, unsigned int minval, unsigned int maxval)
uvec2 | clamp (const uvec2 &x, unsigned int minval, unsigned int maxval)
uvec3 | clamp (const uvec3 &x, unsigned int minval, unsigned int maxval)
uvec4 | clamp (const uvec4 &x, unsigned int minval, unsigned int maxval)
float | mix (float a, float b, float t)
fvec2 | mix (const fvec2 &a, const fvec2 &b, float t)
fvec3 | mix (const fvec3 &a, const fvec3 &b, float t)
fvec4 | mix (const fvec4 &a, const fvec4 &b, float t)
fvec2 | mix (const fvec2 &a, const fvec2 &b, const fvec2 &t)
fvec3 | mix (const fvec3 &a, const fvec3 &b, const fvec3 &t)
fvec4 | mix (const fvec4 &a, const fvec4 &b, const fvec4 &t)
double | mix (double a, double b, double t)
dvec2 | mix (const dvec2 &a, const dvec2 &b, double t)
dvec3 | mix (const dvec3 &a, const dvec3 &b, double t)
dvec4 | mix (const dvec4 &a, const dvec4 &b, double t)
float | step (float edge, float a)
fvec2 | step (const fvec2 &edge, const fvec2 &a)
fvec3 | step (const fvec3 &edge, const fvec3 &a)
fvec4 | step (const fvec4 &edge, const fvec4 &a)
double | step (double edge, double a)
float | smoothstep (float edge0, float edge1, float a)
fvec2 | smoothstep (const fvec2 &edge0, const fvec2 &edge1, const fvec2 &a)
fvec3 | smoothstep (const fvec3 &edge0, const fvec3 &edge1, const fvec3 &a)
fvec4 | smoothstep (const fvec4 &edge0, const fvec4 &edge1, const fvec4 &a)
double | smoothstep (double edge0, double edge1, double a)
ivec2 | isnan (const fvec2 &a)
ivec3 | isnan (const fvec3 &a)
ivec4 | isnan (const fvec4 &a)
ivec2 | isinf (const fvec2 &a)
ivec3 | isinf (const fvec3 &a)
ivec4 | isinf (const fvec4 &a)
float | length (float v)
float | length (const fvec2 &v)
float | length (const fvec3 &v)
float | length (const fvec4 &v)
double | length (double v)
float | length (int v)
float | length (unsigned int v)
float | distance (float p0, float p1)
float | distance (const fvec2 &p0, const fvec2 &p1)
float | distance (const fvec3 &p0, const fvec3 &p1)
float | distance (const fvec4 &p0, const fvec4 &p1)
double | distance (double p0, double p1)
float | distance (int p0, int p1)
float | distance (unsigned int p0, unsigned int p1)
float | dot (float a, float b)
float | dot (const fvec2 &v1, const fvec2 &v2)
float | dot (const fvec3 &v1, const fvec3 &v2)
float | dot (const fvec4 &v1, const fvec4 &v2)
double | dot (double a, double b)
float | dot (int a, int b)
float | dot (unsigned int a, unsigned int b)
fvec3 | cross (const fvec3 &v1, const fvec3 &v2)
float | normalize (float)
fvec2 | normalize (const fvec2 &v)
fvec3 | normalize (const fvec3 &v)
fvec4 | normalize (const fvec4 &v)
double | normalize (double)
float | faceforward (float N, float I, float Nref)
fvec2 | faceforward (const fvec2 &N, const fvec2 &I, const fvec2 &Nref)
fvec3 | faceforward (const fvec3 &N, const fvec3 &I, const fvec3 &Nref)
fvec4 | faceforward (const fvec4 &N, const fvec4 &I, const fvec4 &Nref)
double | faceforward (double N, double I, double Nref)
float | reflect (float I, float N)
fvec2 | reflect (const fvec2 &I, const fvec2 &N)
fvec3 | reflect (const fvec3 &I, const fvec3 &N)
fvec4 | reflect (const fvec4 &I, const fvec4 &N)
double | reflect (double I, double N)
float | refract (float I, float N, float eta)
fvec2 | refract (const fvec2 &I, const fvec2 &N, float eta)
fvec3 | refract (const fvec3 &I, const fvec3 &N, float eta)
fvec4 | refract (const fvec4 &I, const fvec4 &N, float eta)
double | refract (double I, double N, double eta)
dvec2 | refract (const dvec2 &I, const dvec2 &N, double eta)
dvec3 | refract (const dvec3 &I, const dvec3 &N, double eta)
dvec4 | refract (const dvec4 &I, const dvec4 &N, double eta)
fmat2 | matrixCompMult (const fmat2 &a, const fmat2 &b)
fmat3 | matrixCompMult (const fmat3 &a, const fmat3 &b)
fmat4 | matrixCompMult (const fmat4 &a, const fmat4 &b)
fmat2 | outerProduct (const fvec2 &a, const fvec2 &b)
fmat3 | outerProduct (const fvec3 &a, const fvec3 &b)
fmat4 | outerProduct (const fvec4 &a, const fvec4 &b)
fmat2 | transpose (const fmat2 &a)
fmat3 | transpose (const fmat3 &a)
fmat4 | transpose (const fmat4 &a)
ivec4 | lessThan (const fvec4 &a, const fvec4 &b)
ivec3 | lessThan (const fvec3 &a, const fvec3 &b)
ivec2 | lessThan (const fvec2 &a, const fvec2 &b)
ivec4 | lessThanEqual (const fvec4 &a, const fvec4 &b)
ivec3 | lessThanEqual (const fvec3 &a, const fvec3 &b)
ivec2 | lessThanEqual (const fvec2 &a, const fvec2 &b)
ivec4 | greaterThan (const fvec4 &a, const fvec4 &b)
ivec3 | greaterThan (const fvec3 &a, const fvec3 &b)
ivec2 | greaterThan (const fvec2 &a, const fvec2 &b)
ivec4 | greaterThanEqual (const fvec4 &a, const fvec4 &b)
ivec3 | greaterThanEqual (const fvec3 &a, const fvec3 &b)
ivec2 | greaterThanEqual (const fvec2 &a, const fvec2 &b)
ivec4 | equal (const fvec4 &a, const fvec4 &b)
ivec3 | equal (const fvec3 &a, const fvec3 &b)
ivec2 | equal (const fvec2 &a, const fvec2 &b)
ivec4 | notEqual (const fvec4 &a, const fvec4 &b)
ivec3 | notEqual (const fvec3 &a, const fvec3 &b)
ivec2 | notEqual (const fvec2 &a, const fvec2 &b)
bool | any (const ivec2 &a)
bool | any (const ivec3 &a)
bool | any (const ivec4 &a)
bool | all (const ivec2 &a)
bool | all (const ivec3 &a)
bool | all (const ivec4 &a)
ref< Image > | loadCubemap (const String &xp_file, const String &xn_file, const String &yp_file, const String &yn_file, const String &zp_file, const String &zn_file)
Loads six images and assembles them into a cubemap image.
ref< Image > | loadRAW (VirtualFile *file, int width, int height, int depth, int bytealign, EImageFormat format, EImageType type)
Loads a raw image file.
ref< Image > | loadImage (VirtualFile *file)
Loads an image from the specified file.
ref< Image > | loadImage (const String &path)
Loads an image from the specified path.
bool | loadImagesFromDir (const String &dir_path, const String &ext, std::vector< ref< Image > > &images)
Loads all the images with the specified extension from the given directory.
ref< Image > | assemble3DImage (const std::vector< ref< Image > > &images)
Assembles the given 2D images in a single 2D image, all the images must be 2D images and have the same size, format() and type().
bool | saveImage (Image *img, VirtualFile *file)
Writes an image on the specified file.
bool | saveImage (Image *img, const String &path)
Writes an image on the specified path.
Real | randomMinMax (Real min, Real max)
Returns a random number N that between 'min' and 'max' included.
int | greaterEqualPow2 (int n)
Returns a number N that is a power of 2 and that is equal to or greater than 'n'.
int | smallerEqualPow2 (int n)
Returns a number N that is a power of 2 and that is equal to or smaller than 'n'.
void | extractPlanes (Plane *planes, const mat4 &modelviewproj)
Extracts the 6 frustum planes for the given model-view-projection matrix.
template<typename scalar_type >
Matrix2< scalar_type > | operator* (const Matrix2< scalar_type > &m2, const Matrix2< scalar_type > &m1)
template<typename scalar_type >
Matrix2< scalar_type > | operator+ (scalar_type d, const Matrix2< scalar_type > &m)
template<typename scalar_type >
Matrix2< scalar_type > | operator* (scalar_type d, const Matrix2< scalar_type > &m)
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Matrix2< scalar_type > &m, const Vector2< scalar_type > &v)
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Vector2< scalar_type > &v, const Matrix2< scalar_type > &m)
template<typename scalar_type >
Matrix3< scalar_type > | operator* (const Matrix3< scalar_type > &m2, const Matrix3< scalar_type > &m1)
template<typename scalar_type >
Matrix3< scalar_type > | operator+ (scalar_type d, const Matrix3< scalar_type > &m)
template<typename scalar_type >
Matrix3< scalar_type > | operator* (scalar_type d, const Matrix3< scalar_type > &m)
template<typename scalar_type >
Vector3< scalar_type > | operator* (const Matrix3< scalar_type > &m, const Vector3< scalar_type > &v)
Post multiplication: matrix * column vector.
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Matrix3< scalar_type > &m, const Vector2< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector3<scalar_type> with the component z = 0.
template<typename scalar_type >
Vector3< scalar_type > | operator* (const Vector3< scalar_type > &v, const Matrix3< scalar_type > &m)
Pre multiplication: row vector * matrix.
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Vector2< scalar_type > &v, const Matrix3< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector3<scalar_type> with the component z = 0.
template<typename scalar_type >
Matrix4< scalar_type > | operator* (const Matrix4< scalar_type > &m2, const Matrix4< scalar_type > &m1)
template<typename scalar_type >
Matrix4< scalar_type > | operator+ (scalar_type d, const Matrix4< scalar_type > &m)
template<typename scalar_type >
Matrix4< scalar_type > | operator* (scalar_type d, const Matrix4< scalar_type > &m)
template<typename scalar_type >
Vector4< scalar_type > | operator* (const Matrix4< scalar_type > &m, const Vector4< scalar_type > &v)
Post multiplication: matrix * column vector.
template<typename scalar_type >
Vector3< scalar_type > | operator* (const Matrix4< scalar_type > &m, const Vector3< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with the component w = 1.
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Matrix4< scalar_type > &m, const Vector2< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.
template<typename scalar_type >
Vector4< scalar_type > | operator* (const Vector4< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix.
template<typename scalar_type >
Vector3< scalar_type > | operator* (const Vector3< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with the component w = 1.
template<typename scalar_type >
Vector2< scalar_type > | operator* (const Vector2< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.
template<class T1 , class T2 >
bool | operator== (const ref< T1 > &o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | operator!= (const ref< T1 > &o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | operator== (const ref< T1 > &o1, T2 *o2)
template<class T1 , class T2 >
bool | operator!= (const ref< T1 > &o1, T2 *o2)
template<class T1 , class T2 >
bool | operator== (T1 *o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | operator!= (T1 *o1, const ref< T2 > &o2)
int | glcheck (const char *file, int line)
quat | operator* (Real r, const quat &q)
quat | operator* (const quat &q1, const quat &q2)
vec3 | operator* (const quat &q, const vec3 &v)
vec4 | operator* (const quat &q, const vec4 &v)
ref< ResourceDatabase > | loadResource (const String &path, bool quick=true)
Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(const String& path, bool quick).
ref< ResourceDatabase > | loadResource (VirtualFile *file, bool quick=true)
Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(VirtualFile* file).
bool | canLoad (const String &path)
Returns true if there is a ResourceLoadWriter registered to load the specified path or extension.
bool | canLoad (VirtualFile *file)
Returns true if there is a ResourceLoadWriter registered to load the specified file.
bool | canWrite (const String &path)
Returns true if there is a ResourceLoadWriter registered to write the specified path or extension.
bool | canWrite (VirtualFile *file)
Returns true if there is a ResourceLoadWriter registered to write the specified file.
String | operator+ (const wchar_t *pstr, const String &str)
String | operator+ (const char *pstr, const String &str)
String | operator+ (wchar_t ch, const String &str)
String | operator+ (char ch, const String &str)
float | fast1_inversesqrt (float x)
float | fast2_inversesqrt (float x)
float | fast_sqrt (float x)
template<typename T >
const Vector2< T > | operator* (T val, const Vector2< T > &v)
template<typename T >
const Vector3< T > | operator* (T val, const Vector3< T > &v)
template<typename T >
const Vector4< T > | operator* (T val, const Vector4< T > &v)
ref< VirtualFile > | locateFile (const String &path)
Utility function, equivalent to vl::VisualizationLibrary::fileSystem()->locateFile(path).
void | showWin32Console ()
Shows a console window that displays the standard output. This function is to be used only under Windows.
ref< ResourceDatabase > | load3DS (VirtualFile *file)
ref< ResourceDatabase > | load3DS (const String &path)
ref< ResourceDatabase > | loadAC3D (VirtualFile *file)
Loads and AC3D file (.ac).
ref< ResourceDatabase > | loadAC3D (const String &path)
Loads and AC3D file (.ac).
ref< Image > | loadBMP (VirtualFile *file)
ref< Image > | loadBMP (const String &path)
Loads a BMP file.
bool | isBMP (VirtualFile *file)
ref< Image > | loadDAT (VirtualFile *file)
ref< Image > | loadDAT (const String &path)
bool | isDAT (VirtualFile *file)
ref< Image > | loadDDS (VirtualFile *file)
ref< Image > | loadDDS (const String &path)
Loads a DDS file.
bool | isDDS (VirtualFile *file)
ref< Image > | loadDICOM (VirtualFile *file)
Loads a DICOM file.
ref< Image > | loadDICOM (const String &path)
Loads a DICOM file.
bool | saveDICOM (const Image *src, const String &path)
Writes a DICOM file.
bool | saveDICOM (const Image *src, VirtualFile *file)
Writes a DICOM file.
bool | isDICOM (VirtualFile *file)
Checks if the given file is a DICOM file.
ref< Image > | loadJPG (VirtualFile *file)
ref< Image > | loadJPG (const String &path)
bool | isJPG (VirtualFile *file)
bool | saveJPG (const Image *src, const String &path, int quality=95)
bool | saveJPG (const Image *src, VirtualFile *file, int quality=95)
ref< ResourceDatabase > | loadMD2 (const String &path)
ref< ResourceDatabase > | loadMD2 (VirtualFile *file)
ref< ResourceDatabase > | loadOBJ (const String &path)
Loads a Wavefront OBJ file. See also ObjLoader.
ref< ResourceDatabase > | loadOBJ (VirtualFile *file)
Loads a Wavefront OBJ file. See also ObjLoader.
ref< ResourceDatabase > | loadPLY (VirtualFile *file)
ref< ResourceDatabase > | loadPLY (const String &path)
ref< Image > | loadPNG (VirtualFile *file)
ref< Image > | loadPNG (const String &path)
bool | isPNG (VirtualFile *file)
bool | savePNG (const Image *src, const String &path, int compression=6)
bool | savePNG (const Image *src, VirtualFile *file, int compression=6)
ref< ResourceDatabase > | loadSTL (VirtualFile *file)
ref< ResourceDatabase > | loadSTL (const String &path)
ref< Image > | loadTGA (VirtualFile *file)
ref< Image > | loadTGA (const String &path)
Loads a TGA file.
bool | isTGA (VirtualFile *file)
A TGA file is accepted only if it has a 'TGA' extension.
bool | saveTGA (const Image *src, const String &path)
bool | saveTGA (const Image *src, VirtualFile *file)
ref< Image > | loadTIFF (VirtualFile *file)
ref< Image > | loadTIFF (const String &path)
bool | isTIFF (VirtualFile *file)
bool | saveTIFF (const Image *src, const String &path)
bool | saveTIFF (const Image *src, VirtualFile *file)

Variables

vl::Glyph ft_errors []
The Glyph associated to a character of a given Font.
const double | dPi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845
Greek Pi constant using double precision.
const double | dDEG_TO_RAD = dPi / 180.0
Constant to convert degrees into radians using double precision.
const double | dRAD_TO_DEG = 180.0 / dPi
Constant to convert radians into degrees using double precision.
const float | fPi = (float)3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845
Greek Pi constant using float precision.
const float | fDEG_TO_RAD = float(dPi / 180.0)
Constant to convert degrees into radians using float precision.
const float | fRAD_TO_DEG = float(180.0 / dPi)
Constant to convert radians into degrees using float precision.

Detailed Description

Visualization Library namespace.

Typedef Documentation

typedef Collection<Actor> vl::ActorCollection

typedef Array<GLfloat, GLfloat, 1, GL_FLOAT> vl::ArrayFloat

An array of GLfloat.

typedef Array<fvec2, GLfloat, 2, GL_FLOAT> vl::ArrayFVec2

An array of vl::fvec2.

typedef Array<fvec3, GLfloat, 3, GL_FLOAT> vl::ArrayFVec3

An array of vl::fvec3.

typedef Array<fvec4, GLfloat, 4, GL_FLOAT> vl::ArrayFVec4

An array of vl::fvec4.

typedef Array<GLdouble, GLdouble, 1, GL_DOUBLE> vl::ArrayDouble

An array of GLdouble.

typedef Array<dvec2, GLdouble, 2, GL_DOUBLE> vl::ArrayDVec2

An array of vl::dvec2.

typedef Array<dvec3, GLdouble, 3, GL_DOUBLE> vl::ArrayDVec3

An array of vl::dvec3.

typedef Array<dvec4, GLdouble, 4, GL_DOUBLE> vl::ArrayDVec4

An array of vl::dvec4.

typedef Array<GLint, GLint, 1, GL_INT> vl::ArrayInt

An array of GLint.

typedef Array<ivec2, GLint, 2, GL_INT> vl::ArrayIVec2

An array of vl::ivec2.

typedef Array<ivec3, GLint, 3, GL_INT> vl::ArrayIVec3

An array of vl::ivec3.

typedef Array<ivec4, GLint, 4, GL_INT> vl::ArrayIVec4

An array of vl::ivec4.

typedef Array<GLuint,GLuint, 1, GL_UNSIGNED_INT> vl::ArrayUInt

An array of GLuint.

typedef Array<uvec2, GLuint, 2, GL_UNSIGNED_INT> vl::ArrayUVec2

An array of vl::uvec2.

typedef Array<uvec3, GLuint, 3, GL_UNSIGNED_INT> vl::ArrayUVec3

An array of vl::uvec3.

typedef Array<uvec4, GLuint, 4, GL_UNSIGNED_INT> vl::ArrayUVec4

An array of vl::uvec4.

typedef Array<GLbyte, GLbyte, 1, GL_BYTE> vl::ArrayByte

An array of GLbyte.

typedef Array<bvec2, GLbyte, 2, GL_BYTE> vl::ArrayBVec2

An array of vl::bvec2.

typedef Array<bvec3, GLbyte, 3, GL_BYTE> vl::ArrayBVec3

An array of vl::bvec3.

typedef Array<bvec4, GLbyte, 4, GL_BYTE> vl::ArrayBVec4

An array of vl::bvec4.

typedef Array<GLubyte, GLubyte, 1, GL_UNSIGNED_BYTE> vl::ArrayUByte

An array of GLubyte.

typedef Array<ubvec2, GLubyte, 2, GL_UNSIGNED_BYTE> vl::ArrayUBVec2

An array of vl::ubvec2.

typedef Array<ubvec3, GLubyte, 3, GL_UNSIGNED_BYTE> vl::ArrayUBVec3

An array of vl::ubvec3.

typedef Array<ubvec4, GLubyte, 4, GL_UNSIGNED_BYTE> vl::ArrayUBVec4

An array of vl::ubvec4.

typedef Array<GLshort, GLshort, 1, GL_SHORT> vl::ArrayShort

An array of GLshort.

typedef Array<svec2, GLshort, 2, GL_SHORT> vl::ArraySVec2

An array of vl::svec2.

typedef Array<svec3, GLshort, 3, GL_SHORT> vl::ArraySVec3

An array of vl::svec3.

typedef Array<svec4, GLshort, 4, GL_SHORT> vl::ArraySVec4

An array of vl::svec4.

typedef Array<GLushort, GLushort, 1, GL_UNSIGNED_SHORT> vl::ArrayUShort

An array of GLushort.

typedef Array<usvec2, GLushort, 2, GL_UNSIGNED_SHORT> vl::ArrayUSVec2

An array of vl::usvec2.

typedef Array<usvec3, GLushort, 3, GL_UNSIGNED_SHORT> vl::ArrayUSVec3

An array of vl::usvec3.

typedef Array<usvec4, GLushort, 4, GL_UNSIGNED_SHORT> vl::ArrayUSVec4

An array of vl::usvec4.

typedef CatmullRomInterpolator<float> vl::CatmullRomInterpolatorFloat_T

typedef CatmullRomInterpolator<vl::fvec2> vl::CatmullRomInterpolatorFVec2_T

typedef CatmullRomInterpolator<vl::fvec3> vl::CatmullRomInterpolatorFVec3_T

typedef CatmullRomInterpolator<vl::fvec4> vl::CatmullRomInterpolatorFVec4_T

typedef CatmullRomInterpolator<double> vl::CatmullRomInterpolatorDouble_T

typedef CatmullRomInterpolator<vl::dvec2> vl::CatmullRomInterpolatorDVec2_T

typedef CatmullRomInterpolator<vl::dvec3> vl::CatmullRomInterpolatorDVec3_T

typedef CatmullRomInterpolator<vl::dvec4> vl::CatmullRomInterpolatorDVec4_T

typedef double vl::Real

Defined as 'typedef double Real'.

typedef DrawElements<GLuint, GL_UNSIGNED_INT, ArrayUInt> vl::DrawElementsUInt

A DrawElements using indices of type GLuint.

typedef DrawElements<GLushort, GL_UNSIGNED_SHORT, ArrayUShort> vl::DrawElementsUShort

A DrawElements using indices of type GLushort.

typedef DrawElements<GLubyte, GL_UNSIGNED_BYTE, ArrayUByte> vl::DrawElementsUByte

A DrawElements using indices of type GLubyte.

typedef LinearInterpolator<float> vl::LinearInterpolatorFloat_T

typedef LinearInterpolator<vl::fvec2> vl::LinearInterpolatorFVec2_T

typedef LinearInterpolator<vl::fvec3> vl::LinearInterpolatorFVec3_T

typedef LinearInterpolator<vl::fvec4> vl::LinearInterpolatorFVec4_T

typedef LinearInterpolator<double> vl::LinearInterpolatorDouble_T

typedef LinearInterpolator<vl::dvec2> vl::LinearInterpolatorDVec2_T

typedef LinearInterpolator<vl::dvec3> vl::LinearInterpolatorDVec3_T

typedef LinearInterpolator<vl::dvec4> vl::LinearInterpolatorDVec4_T

typedef Matrix2<GLdouble> vl::dmat2

A 2x2 matrix using GLdouble precision.

typedef Matrix2<GLfloat> vl::fmat2

A 2x2 matrix using GLfloat precision.

typedef Matrix2<GLint> vl::imat2

A 2x2 matrix using GLint precision.

typedef Matrix2<GLuint> vl::umat2

A 2x2 matrix using GLuint precision.

typedef dmat2 vl::mat2

Defined as: 'typedef dmat2 mat2'. See also VL_PIPELINE_PRECISION.

typedef Matrix3<GLdouble> vl::dmat3

A 3x3 matrix using GLdouble precision.

typedef Matrix3<GLfloat> vl::fmat3

A 3x3 matrix using GLfloat precision.

typedef Matrix3<GLint> vl::imat3

A 3x3 matrix using GLint precision.

typedef Matrix3<GLuint> vl::umat3

A 3x3 matrix using GLuint precision.

typedef dmat3 vl::mat3

Defined as: 'typedef dmat3 mat3'. See also VL_PIPELINE_PRECISION.

typedef Matrix4<GLdouble> vl::dmat4

A 4x4 matrix using GLdouble precision.

typedef Matrix4<GLfloat> vl::fmat4

A 4x4 matrix using GLfloat precision.

typedef Matrix4<GLint> vl::imat4

A 4x4 matrix using GLint precision.

typedef Matrix4<GLuint> vl::umat4

A 4x4 matrix using GLuint precision.

typedef dmat4 vl::mat4

Defined as: 'typedef dmat4 mat4'. See also VL_PIPELINE_PRECISION.

typedef std::map< float, ref<RenderQueue> > vl::TRenderQueueMap

typedef Vector2<GLint> vl::ivec2

A 2 components vector with GLint precision.

typedef Vector2<GLuint> vl::uvec2

A 2 components vector with GLuint precision.

typedef Vector2<GLfloat> vl::fvec2

A 2 components vector with GLfloat precision.

typedef Vector2<GLdouble> vl::dvec2

A 2 components vector with GLdouble precision.

typedef Vector2<GLbyte> vl::bvec2

A 2 components vector with GLbyte precision.

typedef Vector2<GLubyte> vl::ubvec2

A 2 components vector with GLubyte precision.

typedef Vector2<GLshort> vl::svec2

A 2 components vector with GLshort precision.

typedef Vector2<GLushort> vl::usvec2

A 2 components vector with GLushort precision.

typedef dvec2 vl::vec2

Defined as: 'typedef dvec2 vec2'. See also VL_PIPELINE_PRECISION.

typedef Vector3<GLint> vl::ivec3

A 3 components vector with GLint precision.

typedef Vector3<GLuint> vl::uvec3

A 3 components vector with GLuint precision.

typedef Vector3<GLfloat> vl::fvec3

A 3 components vector with GLfloat precision.

typedef Vector3<GLdouble> vl::dvec3

A 3 components vector with GLdouble precision.

typedef Vector3<GLbyte> vl::bvec3

A 3 components vector with GLbyte precision.

typedef Vector3<GLubyte> vl::ubvec3

A 3 components vector with GLubyte precision.

typedef Vector3<GLshort> vl::svec3

A 3 components vector with GLshort precision.

typedef Vector3<GLushort> vl::usvec3

A 3 components vector with GLushort precision.

typedef dvec3 vl::vec3

Defined as: 'typedef dvec3 vec3'. See also VL_PIPELINE_PRECISION.

typedef Vector4<GLint> vl::ivec4

A 4 components vector with GLint precision.

typedef Vector4<GLuint> vl::uvec4

A 4 components vector with GLuint precision.

typedef Vector4<GLfloat> vl::fvec4

A 4 components vector with GLfloat precision.

typedef Vector4<GLdouble> vl::dvec4

A 4 components vector with GLdouble precision.

typedef Vector4<GLbyte> vl::bvec4

A 4 components vector with GLbyte precision.

typedef Vector4<GLubyte> vl::ubvec4

A 4 components vector with GLubyte precision.

typedef Vector4<GLshort> vl::svec4

A 4 components vector with GLshort precision.

typedef Vector4<GLushort> vl::usvec4

A 4 components vector with GLushort precision.

typedef dvec4 vl::vec4

Defined as: 'typedef dvec4 vec4'. See also VL_PIPELINE_PRECISION.

Enumeration Type Documentation

enum vl::ESilhouetteMode

Enumerator:
SilhouetteClosed
SilhouetteOpen

enum vl::ELogLevel

Enumerator:
LogNormal Default logging level.

LogDebug Information useful for the programmer.

LogInfo Information userful for the end user.

LogWarning Information about situations that might lead to errors.

LogError Information about a run-time error: file not found, out of memory etc.

LogBug Information about a programming error: wrong parameter initialization, division by zero etc.

enum vl::ETextureFormat

Enumerator:
TF_ALPHA
TF_ALPHA4
TF_ALPHA8
TF_ALPHA12
TF_ALPHA16
TF_INTENSITY
TF_INTENSITY4
TF_INTENSITY8
TF_INTENSITY12
TF_INTENSITY16
TF_LUMINANCE
TF_LUMINANCE4
TF_LUMINANCE8
TF_LUMINANCE12
TF_LUMINANCE16
TF_LUMINANCE_ALPHA
TF_LUMINANCE4_ALPHA4
TF_LUMINANCE6_ALPHA2
TF_LUMINANCE8_ALPHA8
TF_LUMINANCE12_ALPHA4
TF_LUMINANCE12_ALPHA12
TF_LUMINANCE16_ALPHA16
TF_R3_G3_B2
TF_RGB
TF_RGB4
TF_RGB5
TF_RGB8
TF_RGB10
TF_RGB12
TF_RGB16
TF_RGBA
TF_RGBA2
TF_RGBA4
TF_RGB5_A1
TF_RGBA8
TF_RGB10_A2
TF_RGBA12
TF_RGBA16
TF_RGBA32F
TF_RGB32F
TF_ALPHA32F
TF_INTENSITY32F
TF_LUMINANCE32F
TF_LUMINANCE_ALPHA32F
TF_RGBA16F
TF_RGB16F
TF_ALPHA16F
TF_INTENSITY16F
TF_LUMINANCE16F
TF_LUMINANCE_ALPHA16F
TF_RGBA_FLOAT32_ATI
TF_RGB_FLOAT32_ATI
TF_ALPHA_FLOAT32_ATI
TF_INTENSITY_FLOAT32_ATI
TF_LUMINANCE_FLOAT32_ATI
TF_LUMINANCE_ALPHA_FLOAT32_ATI
TF_RGBA_FLOAT16_ATI
TF_RGB_FLOAT16_ATI
TF_ALPHA_FLOAT16_ATI
TF_INTENSITY_FLOAT16_ATI
TF_LUMINANCE_FLOAT16_ATI
TF_LUMINANCE_ALPHA_FLOAT16_ATI
TF_RGB9_E5
TF_11F_G11F_B10F
TF_DEPTH_STENCIL
TF_DEPTH_COMPONENT32F
TF_DEPTH32F_STENCIL8
TF_DEPTH_COMPONENT
TF_DEPTH_COMPONENT16
TF_DEPTH_COMPONENT24
TF_DEPTH_COMPONENT32
TF_COMPRESSED_ALPHA
TF_COMPRESSED_INTENSITY
TF_COMPRESSED_LUMINANCE
TF_COMPRESSED_LUMINANCE_ALPHA
TF_COMPRESSED_RGB
TF_COMPRESSED_RGBA
TF_COMPRESSED_RGB_FXT1_3DFX
TF_COMPRESSED_RGBA_FXT1_3DFX
TF_COMPRESSED_RGB_S3TC_DXT1
TF_COMPRESSED_RGBA_S3TC_DXT1
TF_COMPRESSED_RGBA_S3TC_DXT3
TF_COMPRESSED_RGBA_S3TC_DXT5
TF_COMPRESSED_LUMINANCE_LATC1
TF_COMPRESSED_SIGNED_LUMINANCE_LATC1
TF_COMPRESSED_LUMINANCE_ALPHA_LATC2
TF_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2
TF_COMPRESSED_RED_RGTC1
TF_COMPRESSED_SIGNED_RED_RGTC1
TF_COMPRESSED_RED_GREEN_RGTC2
TF_COMPRESSED_SIGNED_RED_GREEN_RGTC2
TF_RGBA32UI
TF_RGB32UI
TF_ALPHA32UI
TF_INTENSITY32UI
TF_LUMINANCE32UI
TF_LUMINANCE_ALPHA32UI
TF_RGBA16UI
TF_RGB16UI
TF_ALPHA16UI
TF_INTENSITY16UI
TF_LUMINANCE16UI
TF_LUMINANCE_ALPHA16UI
TF_RGBA8UI
TF_RGB8UI
TF_ALPHA8UI
TF_INTENSITY8UI
TF_LUMINANCE8UI
TF_LUMINANCE_ALPHA8UI
TF_RGBA32I
TF_RGB32I
TF_ALPHA32I
TF_INTENSITY32I
TF_LUMINANCE32I
TF_LUMINANCE_ALPHA32I
TF_RGBA16I
TF_RGB16I
TF_ALPHA16I
TF_INTENSITY16I
TF_LUMINANCE16I
TF_LUMINANCE_ALPHA16I
TF_RGBA8I
TF_RGB8I
TF_ALPHA8I
TF_INTENSITY8I
TF_LUMINANCE8I
TF_LUMINANCE_ALPHA8I

enum vl::EColorBufferFormat

Enumerator:
CBF_RGB
CBF_RGBA
CBF_R3_G3_B2
CBF_RGB4
CBF_RGB5
CBF_RGB8
CBF_RGB10
CBF_RGB12
CBF_RGB16
CBF_RGBA2
CBF_RGBA4
CBF_RGB5_A1
CBF_RGBA8
CBF_RGB10_A2
CBF_RGBA12
CBF_RGBA16
CBF_FLOAT_R_NV
CBF_FLOAT_RG_NV
CBF_FLOAT_RGB_NV
CBF_FLOAT_RGBA_NV
CBF_FLOAT_R16_NV
CBF_FLOAT_RG16_NV
CBF_FLOAT_RGB16_NV
CBF_FLOAT_RGBA16_NV
CBF_FLOAT_R32_NV
CBF_FLOAT_RG32_NV
CBF_FLOAT_RGB32_NV
CBF_FLOAT_RGBA32_NV
CBF_RGB9_E5
CBF_11F_G11F_B10F

enum vl::EAttachmentPoint

Enumerator:
AP_NO_ATTACHMENT
AP_COLOR_ATTACHMENT0
AP_COLOR_ATTACHMENT1
AP_COLOR_ATTACHMENT2
AP_COLOR_ATTACHMENT3
AP_COLOR_ATTACHMENT4
AP_COLOR_ATTACHMENT5
AP_COLOR_ATTACHMENT6
AP_COLOR_ATTACHMENT7
AP_COLOR_ATTACHMENT8
AP_COLOR_ATTACHMENT9
AP_COLOR_ATTACHMENT10
AP_COLOR_ATTACHMENT11
AP_COLOR_ATTACHMENT12
AP_COLOR_ATTACHMENT13
AP_COLOR_ATTACHMENT14
AP_COLOR_ATTACHMENT15
AP_DEPTH_ATTACHMENT
AP_STENCIL_ATTACHMENT

enum vl::ETex2DTarget

Enumerator:
T2DT_TEXTURE_2D
T2DT_TEXTURE_CUBE_MAP_POSITIVE_X
T2DT_TEXTURE_CUBE_MAP_NEGATIVE_X
T2DT_TEXTURE_CUBE_MAP_POSITIVE_Y
T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Y
T2DT_TEXTURE_CUBE_MAP_POSITIVE_Z
T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Z
T2DT_TEXTURE_RECTANGLE
T2DT_TEXTURE_1D_ARRAY

enum vl::EImageFormat

Enumerator:
IF_RGB
IF_RGBA
IF_BGR
IF_BGRA
IF_RED
IF_GREEN
IF_BLUE
IF_ALPHA
IF_LUMINANCE
IF_LUMINANCE_ALPHA
IF_DEPTH_COMPONENT
IF_STENCIL_INDEX
IF_DEPTH_STENCIL
IF_COMPRESSED_RGB_S3TC_DXT1
IF_COMPRESSED_RGBA_S3TC_DXT1
IF_COMPRESSED_RGBA_S3TC_DXT3
IF_COMPRESSED_RGBA_S3TC_DXT5
IF_RED_INTEGER
IF_GREEN_INTEGER
IF_BLUE_INTEGER
IF_ALPHA_INTEGER
IF_RGB_INTEGER
IF_RGBA_INTEGER
IF_BGR_INTEGER
IF_BGRA_INTEGER
IF_LUMINANCE_INTEGER
IF_LUMINANCE_ALPHA_INTEGER

enum vl::EDepthType

Enumerator:
DT_DEPTH_COMPONENT
DT_DEPTH_COMPONENT16
DT_DEPTH_COMPONENT24
DT_DEPTH_COMPONENT32
DT_DEPTH_COMPONENT32F

enum vl::EStencilType

Enumerator:
ST_STENCIL_INDEX1
ST_STENCIL_INDEX4
ST_STENCIL_INDEX8
ST_STENCIL_INDEX16

enum vl::EDepthStencilType

Enumerator:
DST_DEPTH_STENCIL
DST_DEPTH24_STENCIL8
DST_DEPTH32F_STENCIL8

enum vl::EClearFlags

Enumerator:
CF_DO_NOT_CLEAR
CF_CLEAR_COLOR
CF_CLEAR_DEPTH
CF_CLEAR_STENCIL
CF_CLEAR_COLOR_DEPTH
CF_CLEAR_COLOR_STENCIL
CF_CLEAR_DEPTH_STENCIL
CF_CLEAR_COLOR_DEPTH_STENCIL

enum vl::EClearColorMode

Enumerator:
CCM_Float
CCM_Int
CCM_UInt

enum vl::EBlendFactor

Enumerator:
BF_ZERO
BF_ONE
BF_SRC_COLOR
BF_ONE_MINUS_SRC_COLOR
BF_DST_COLOR
BF_ONE_MINUS_DST_COLOR
BF_SRC_ALPHA
BF_ONE_MINUS_SRC_ALPHA
BF_DST_ALPHA
BF_ONE_MINUS_DST_ALPHA
BF_CONSTANT_COLOR
BF_ONE_MINUS_CONSTANT_COLOR
BF_CONSTANT_ALPHA
BF_ONE_MINUS_CONSTANT_ALPHA
BF_SRC_ALPHA_SATURATE

enum vl::ETextureDimension

Enumerator:
TD_TEXTURE_1D
TD_TEXTURE_2D
TD_TEXTURE_3D
TD_TEXTURE_CUBE_MAP
TD_TEXTURE_RECTANGLE
TD_TEXTURE_1D_ARRAY
TD_TEXTURE_2D_ARRAY

enum vl::ETexCompareMode

Enumerator:
TCM_NONE
TCM_COMPARE_R_TO_TEXTURE
TCM_COMPARE_REF_DEPTH_TO_TEXTURE

enum vl::ETexCompareFunc

Enumerator:
TCF_LEQUAL
TCF_GEQUAL
TCF_LESS
TCF_GREATER
TCF_EQUAL
TCF_NOTEQUAL
TCF_ALWAYS
TCF_NEVER

enum vl::EDepthTextureMode

Enumerator:
DTM_LUMINANCE
DTM_INTENSITY
DTM_ALPHA

enum vl::EReadDrawBuffer

Enumerator:
RDB_NONE
RDB_FRONT_LEFT
RDB_FRONT_RIGHT
RDB_BACK_LEFT
RDB_BACK_RIGHT
RDB_AUX0
RDB_AUX1
RDB_AUX2
RDB_AUX3
RDB_COLOR_ATTACHMENT0
RDB_COLOR_ATTACHMENT1
RDB_COLOR_ATTACHMENT2
RDB_COLOR_ATTACHMENT3
RDB_COLOR_ATTACHMENT4
RDB_COLOR_ATTACHMENT5
RDB_COLOR_ATTACHMENT6
RDB_COLOR_ATTACHMENT7
RDB_COLOR_ATTACHMENT8
RDB_COLOR_ATTACHMENT9
RDB_COLOR_ATTACHMENT10
RDB_COLOR_ATTACHMENT11
RDB_COLOR_ATTACHMENT12
RDB_COLOR_ATTACHMENT13
RDB_COLOR_ATTACHMENT14
RDB_COLOR_ATTACHMENT15

enum vl::EImageType

Enumerator:
IT_COMPRESSED_TYPE
IT_UNSIGNED_BYTE
IT_BYTE
IT_UNSIGNED_SHORT
IT_SHORT
IT_UNSIGNED_INT
IT_INT
IT_FLOAT
IT_UNSIGNED_BYTE_3_3_2
IT_UNSIGNED_BYTE_2_3_3_REV
IT_UNSIGNED_SHORT_5_6_5
IT_UNSIGNED_SHORT_5_6_5_REV
IT_UNSIGNED_SHORT_4_4_4_4
IT_UNSIGNED_SHORT_4_4_4_4_REV
IT_UNSIGNED_SHORT_5_5_5_1
IT_UNSIGNED_SHORT_1_5_5_5_REV
IT_UNSIGNED_INT_8_8_8_8
IT_UNSIGNED_INT_8_8_8_8_REV
IT_UNSIGNED_INT_10_10_10_2
IT_UNSIGNED_INT_2_10_10_10_REV
IT_UNSIGNED_INT_5_9_9_9_REV
IT_UNSIGNED_INT_10F_11F_11F_REV
IT_UNSIGNED_INT_24_8
IT_FLOAT_32_UNSIGNED_INT_24_8_REV

enum vl::EPrimitiveType

Enumerator:
PT_POINTS
PT_LINES
PT_LINE_LOOP
PT_LINE_STRIP
PT_TRIANGLES
PT_TRIANGLE_STRIP
PT_TRIANGLE_FAN
PT_QUADS
PT_QUAD_STRIP
PT_POLYGON
PT_LINES_ADJACENCY
PT_LINE_STRIP_ADJACENCY
PT_TRIANGLES_ADJACENCY
PT_TRIANGLE_STRIP_ADJACENCY

enum vl::EPolygonFace

Enumerator:
PF_FRONT
PF_BACK
PF_FRONT_AND_BACK

enum vl::EHintMode

Enumerator:
HM_FASTEST
HM_NICEST
HM_DONT_CARE

enum vl::EFrontFace

Enumerator:
FF_CW
FF_CCW

enum vl::EFunction

Enumerator:
FU_NEVER
FU_LESS
FU_EQUAL
FU_LEQUAL
FU_GREATER
FU_NOTEQUAL
FU_GEQUAL
FU_ALWAYS

enum vl::EPolygonMode

Enumerator:
PM_FILL
PM_LINE
PM_POINT

enum vl::EShadeModel

Enumerator:
SM_FLAT
SM_SMOOTH

enum vl::EBlendEquation

Enumerator:
BE_FUNC_ADD
BE_FUNC_SUBTRACT
BE_FUNC_REVERSE_SUBTRACT
BE_MIN
BE_MAX

enum vl::EColorMaterial

Enumerator:
CM_EMISSION
CM_AMBIENT
CM_DIFFUSE
CM_SPECULAR
CM_AMBIENT_AND_DIFFUSE

enum vl::EColorControl

Enumerator:
CC_SEPARATE_SPECULAR_COLOR
CC_SINGLE_COLOR

enum vl::EFogMode

Enumerator:
FM_LINEAR
FM_EXP
FM_EXP2

enum vl::ELogicOp

Enumerator:
LO_CLEAR
LO_SET
LO_COPY
LO_COPY_INVERTED
LO_NOOP
LO_INVERT
LO_AND
LO_NAND
LO_OR
LO_NOR
LO_XOR
LO_EQUIV
LO_AND_REVERSE
LO_AND_INVERTED
LO_OR_REVERSE
LO_OR_INVERTED

enum vl::EStencilOp

Enumerator:
SO_KEEP
SO_ZERO
SO_REPLACE
SO_INCR
SO_INCR_WRAP
SO_DECR
SO_DECR_WRAP
SO_INVERT

enum vl::ETexParamFilter

Enumerator:
TPF_NEAREST
TPF_LINEAR
TPF_NEAREST_MIPMAP_NEAREST
TPF_LINEAR_MIPMAP_NEAREST
TPF_NEAREST_MIPMAP_LINEAR
TPF_LINEAR_MIPMAP_LINEAR

enum vl::ETexParamWrap

Enumerator:
TPW_CLAMP
TPW_CLAMP_TO_BORDER
TPW_CLAMP_TO_EDGE
TPW_MIRRORED_REPEAT
TPW_REPEAT

enum vl::ETexEnvMode

Enumerator:
TEM_DECAL
TEM_MODULATE
TEM_ADD
TEM_BLEND
TEM_REPLACE
TEM_COMBINE
TEM_ADD_SIGN
TEM_INTERPOLATE
TEM_SUBTRACT
TEM_DOT3_RGB
TEM_DOT3_RGBA

enum vl::ETexEnvSource

Enumerator:
TES_TEXTURE
TES_TEXTURE0
TES_TEXTURE1
TES_TEXTURE2
TES_TEXTURE3
TES_TEXTURE4
TES_TEXTURE5
TES_TEXTURE6
TES_TEXTURE7
TES_CONSTANT
TES_PRIMARY_COLOR
TES_PREVIOUS

enum vl::ETexEnvOperand

Enumerator:
TEO_SRC_COLOR
TEO_ONE_MINUS_SRC_COLOR
TEO_SRC_ALPHA
TEO_ONE_MINUS_SRC_ALPHA

enum vl::ETexGenMode

Texture generation modes, see http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information.

Enumerator:
TGM_DISABLED
TGM_EYE_LINEAR
TGM_OBJECT_LINEAR
TGM_SPHERE_MAP
TGM_REFLECTION_MAP
TGM_NORMAL_MAP

enum vl::EEnable

Constant that enable/disable a specific OpenGL feature, see also Shader, Shader::enable(), Shader::disable(), Shader::isEnabled().

Enumerator:
EN_ALPHA_TEST If enabled, performs alpha testing, see also AlphaFunc for more information.

EN_BLEND If enabled, blend the incoming RGBA color values with the values in the color buffers, see also BlendFunc for more information.

EN_COLOR_LOGIC_OP If enabled, apply the currently selected logical operation to the incoming RGBA color and color buffer values, see also LogicOp.

EN_LIGHTING If enabled, use the current lighting parameters to compute the vertex color; Otherwise, simply associate the current color with each vertex, see also Material, LightModel, and Light.

EN_COLOR_SUM If enabled, add the secondary color value to the computed fragment color.

EN_CULL_FACE If enabled, cull polygons based on their winding in window coordinates, see also CullFace.

EN_DEPTH_TEST If enabled, do depth comparisons and update the depth buffer; Note that even if the depth buffer exists and the depth mask is non-zero, the depth buffer is not updated if the depth test is disabled, see also DepthFunc and DepthRange.

EN_FOG If enabled, blend a fog color into the post-texturing color, see also Fog.

EN_LINE_SMOOTH IIf enabled, draw lines with correct filtering; Otherwise, draw aliased lines, see also LineWidth.

EN_LINE_STIPPLE If enabled, use the current line stipple pattern when drawing lines, see also LineStipple.

EN_POLYGON_STIPPLE If enabled, use the current polygon stipple pattern when rendering polygons, see also PolygonStipple.

EN_NORMALIZE If enabled, normal vectors are scaled to unit length after transformation, see also vl::EN_RESCALE_NORMAL.

EN_POINT_SMOOTH If enabled, draw points with proper filtering; Otherwise, draw aliased points, see also PointSize.

EN_POINT_SPRITE If enabled, calculate texture coordinates for points based on texture environment and point parameter settings; Otherwise texture coordinates are constant across points.

EN_POLYGON_SMOOTH If enabled, draw polygons with proper filtering; Otherwise, draw aliased polygons; For correct antialiased polygons, an alpha buffer is needed and the polygons must be sorted front to back.

EN_POLYGON_OFFSET_FILL If enabled, and if the polygon is rendered in GL_FILL mode, an offset is added to depth values of a polygon's fragments before the depth comparison is performed, see also PolygonOffset.

EN_POLYGON_OFFSET_LINE If enabled, and if the polygon is rendered in GL_LINE mode, an offset is added to depth values of a polygon's fragments before the depth comparison is performed, see also PolygonOffset.

EN_POLYGON_OFFSET_POINT If enabled, an offset is added to depth values of a polygon's fragments before the depth comparison is performed, if the polygon is rendered in GL_POINT mode, see also PolygonOffset.

EN_RESCALE_NORMAL If enabled, normals are scaled by a scaling factor derived from the modelview matrix; vl::EN_RESCALE_NORMAL requires that the originally specified normals were of unit length, and that the modelview matrix contain only uniform scales for proper results, see also vl::EN_NORMALIZE.

EN_STENCIL_TEST If enabled, do stencil testing and update the stencil buffer, see also StencilFunc and StencilOp.

EN_VERTEX_PROGRAM_POINT_SIZE If enabled, and a vertex shader is active, then the derived point size is taken from the (potentially clipped) shader builtin gl_PointSize and clamped to the implementation-dependent point size range|.
EN_VERTEX_PROGRAM_TWO_SIDE If enabled, and a vertex shader is active, it specifies that the GL will choose between front and back colors based on the polygon's face direction of which the vertex being shaded is a part; It has no effect on points or lines.

EN_MULTISAMPLE If enabled, use multiple fragment samples in computing the final color of a pixel, see also SampleCoverage.

EN_SAMPLE_ALPHA_TO_COVERAGE If enabled, compute a temporary coverage value where each bit is determined by the alpha value at the corresponding sample location; The temporary coverage value is then ANDed with the fragment coverage value.

EN_SAMPLE_ALPHA_TO_ONE If enabled, each sample alpha value is replaced by the maximum representable alpha value.

EN_SAMPLE_COVERAGE If enabled, the fragment's coverage is ANDed with the temporary coverage value; If GL_SAMPLE_COVERAGE_INVERT is set to GL_TRUE, invert the coverage value, see also SampleCoverage.

EN_EnableCount For internal use only.

EN_UnknownEnable For internal use only.

enum vl::EGLBufferUsage

Enumerator:
GBU_STREAM_DRAW
GBU_STREAM_READ
GBU_STREAM_COPY
GBU_STATIC_DRAW
GBU_STATIC_READ
GBU_STATIC_COPY
GBU_DYNAMIC_DRAW
GBU_DYNAMIC_READ
GBU_DYNAMIC_COPY

enum vl::EGLBufferAccess

Enumerator:
GBA_READ_ONLY
GBA_WRITE_ONLY
GBA_READ_WRITE

enum vl::EAlign

Enumerator:
AlignLeft
AlignHCenter
AlignRight
AlignTop
AlignVCenter
AlignBottom

enum vl::ETextAlign

Enumerator:
TextAlignLeft
TextAlignRight
TextAlignCenter
TextAlignJustify

enum vl::ETextMode

Enumerator:
Text2D
Text3D

enum vl::ETextLayout

Enumerator:
LeftToRightText
RightToLeftText
TopToBottomText

enum vl::EDepthSortMode

Enumerator:
NeverDepthSort
AlwaysDepthSort
AlphaDepthSort

enum vl::EImageDimension

Enumerator:
ID_Error
ID_1D
ID_2D
ID_3D
ID_Cubemap

enum vl::EStateType

Enumerator:
ST_RenderStates
ST_Enables
ST_TextureUnits
ST_Lights
ST_ClipPlanes

enum vl::ERenderState

Enumerator:
RS_AlphaFunc
RS_BlendColor
RS_BlendEquation
RS_BlendFunc
RS_ColorMask
RS_CullFace
RS_DepthFunc
RS_DepthMask
RS_DepthRange
RS_Fog
RS_FrontFace
RS_PolygonMode
RS_Hint
RS_LightModel
RS_LineStipple
RS_LineWidth
RS_LogicOp
RS_Material
RS_PixelTransfer
RS_PointParameter
RS_PointSize
RS_PolygonOffset
RS_PolygonStipple
RS_SampleCoverage
RS_ShadeModel
RS_StencilFunc
RS_StencilMask
RS_StencilOp
RS_GLSLProgram
RS_Light0
RS_Light1
RS_Light2
RS_Light3
RS_Light4
RS_Light5
RS_Light6
RS_Light7
RS_ClipPlane0
RS_ClipPlane1
RS_ClipPlane2
RS_ClipPlane3
RS_ClipPlane4
RS_ClipPlane5
RS_TextureUnit0
RS_TexGen0
RS_TexEnv0
RS_TextureMatrix0
RS_COUNT
RS_NONE

enum vl::ERenderingCallback

Enumerator:
RC_PreRendering The RenderingCallback is being called because a new rendering is going to start.

RC_PostRendering The RenderingCallback is being called because a rendering has just been completed.

enum vl::EGeometryInputType

Enumerator:
GIT_POINTS
GIT_LINES
GIT_LINES_ADJACENCY
GIT_TRIANGLES
GIT_TRIANGLES_ADJACENCY

enum vl::EGeometryOutputType

Enumerator:
GOT_POINTS
GOT_LINE_STRIP
GOT_TRIANGLE_STRIP

enum vl::EBufferBits

Enumerator:
BB_COLOR_BUFFER_BIT
BB_DEPTH_BUFFER_BIT
BB_STENCIL_BUFFER_BIT

enum vl::EBillboardType

Enumerator:
BT_AxisAlignedBillboard
BT_SphericalBillboard

enum vl::ESortMode

Enumerator:
SM_SortBackToFront
SM_SortFrontToBack

enum vl::EGetMode

Enumerator:
GM_GetOrCreate
GM_DontCreate

enum vl::EStringEncoding

Enumerator:
SE_Unknown
SE_ASCII
SE_UTF8
SE_UTF16_BE
SE_UTF16_LE
SE_UTF32_BE
SE_UTF32_LE
SE_LATIN1

enum vl::EOpenMode

Enumerator:
OM_ReadOnly
OM_WriteOnly

enum vl::EKey

Enumerator:
Key_None
Key_0
Key_1
Key_2
Key_3
Key_4
Key_5
Key_6
Key_7
Key_8
Key_9
Key_A
Key_B
Key_C
Key_D
Key_E
Key_F
Key_G
Key_H
Key_I
Key_J
Key_K
Key_L
Key_M
Key_N
Key_O
Key_P
Key_Q
Key_R
Key_S
Key_T
Key_U
Key_V
Key_W
Key_X
Key_Y
Key_Z
Key_Return
Key_BackSpace
Key_Tab
Key_Space
Key_Clear
Key_Escape
Key_Exclam
Key_QuoteDbl
Key_Hash
Key_Dollar
Key_Ampersand
Key_Quote
Key_LeftParen
Key_RightParen
Key_Asterisk
Key_Plus
Key_Comma
Key_Minus
Key_Period
Key_Slash
Key_Colon
Key_Semicolon
Key_Less
Key_Equal
Key_Greater
Key_Question
Key_At
Key_LeftBracket
Key_BackSlash
Key_RightBracket
Key_Caret
Key_Underscore
Key_QuoteLeft
Key_Ctrl
Key_LeftCtrl
Key_RightCtrl
Key_Alt
Key_LeftAlt
Key_RightAlt
Key_Shift
Key_LeftShift
Key_RightShift
Key_Insert
Key_Delete
Key_Home
Key_End
Key_Print
Key_Pause
Key_PageUp
Key_PageDown
Key_Left
Key_Right
Key_Up
Key_Down
Key_F1
Key_F2
Key_F3
Key_F4
Key_F5
Key_F6
Key_F7
Key_F8
Key_F9
Key_F10
Key_F11
Key_F12
Key_Unknown
Key_NumberOfKeys

enum vl::EMouseButton

Enumerator:
NoButton
LeftButton
RightButton
MiddleButton
UnknownButton

enum vl::EInheritance

Enumerator:
IN_Local Does not propagates to children (thus cannot override children settings); can be overridden.

IN_Propagate Propagates to children; does not override children settings; can be overridden.

IN_Sticky Does not propagates to children (thus cannot override children settings); cannot be overridden.

IN_Propagate_Overrides_Sticky Propagates to children; overrides children settings; cannot be overridden.

IN_Propagate_Overrides Propagates to children; overrides children settings; can be overridden.

IN_Propagate_Sticky Propagates to children; does not override children settings; cannot be overridden.

enum vl::EShaderType

Enumerator:
ST_VERTEX_SHADER
ST_FRAGMENT_SHADER
ST_GEOMETRY_SHADER

enum vl::ETessellationWinding

Enumerator:
TW_TESS_WINDING_ODD
TW_TESS_WINDING_NONZERO
TW_TESS_WINDING_POSITIVE
TW_TESS_WINDING_NEGATIVE
TW_TESS_WINDING_ABS_GEQ_TWO

Function Documentation

void vl::log_failed_check | ( | const char * | expr,
 |  | const char * | file,
 |  | int | line
 | ) |  |

float vl::asinh ( float x ) [inline]

double vl::asinh ( double x ) [inline]

float vl::acosh ( float x ) [inline]

double vl::acosh ( double x ) [inline]

float vl::atanh ( float x ) [inline]

double vl::atanh ( double x ) [inline]

template<typename T >
bool vl::isnan ( T value ) [inline]

template<typename T >
bool vl::isinf ( T value ) [inline]

template<typename T >
bool vl::isinf_pos ( T value ) [inline]

template<typename T >
bool vl::isinf_neg ( T value ) [inline]

float vl::modf | ( | float | a,
 |  | float & | intpart |
 | ) |  |  | [inline]

double vl::modf | ( | double | a,
 |  | double & | intpart |
 | ) |  |  | [inline]

float vl::radians ( float degrees ) [inline]

dvec2 vl::radians ( const fvec2 & degrees ) [inline]

dvec3 vl::radians ( const fvec3 & degrees ) [inline]

dvec4 vl::radians ( const fvec4 & degrees ) [inline]

double vl::radians ( double degrees ) [inline]

float vl::degrees ( float radians ) [inline]

dvec2 vl::degrees ( const fvec2 & radians ) [inline]

dvec3 vl::degrees ( const fvec3 & radians ) [inline]

dvec4 vl::degrees ( const fvec4 & radians ) [inline]

double vl::degrees ( double radians ) [inline]

float vl::sin ( float a ) [inline]

dvec2 vl::sin ( const fvec2 & angle ) [inline]

dvec3 vl::sin ( const fvec3 & angle ) [inline]

dvec4 vl::sin ( const fvec4 & angle ) [inline]

double vl::sin ( double a ) [inline]

float vl::cos ( float a ) [inline]

dvec2 vl::cos ( const fvec2 & angle ) [inline]

dvec3 vl::cos ( const fvec3 & angle ) [inline]

dvec4 vl::cos ( const fvec4 & angle ) [inline]

double vl::cos ( double a ) [inline]

float vl::tan ( float a ) [inline]

dvec2 vl::tan ( const fvec2 & angle ) [inline]

dvec3 vl::tan ( const fvec3 & angle ) [inline]

dvec4 vl::tan ( const fvec4 & angle ) [inline]

double vl::tan ( double a ) [inline]

float vl::asin ( float a ) [inline]

dvec2 vl::asin ( const fvec2 & angle ) [inline]

dvec3 vl::asin ( const fvec3 & angle ) [inline]

dvec4 vl::asin ( const fvec4 & angle ) [inline]

double vl::asin ( double a ) [inline]

float vl::acos ( float a ) [inline]

dvec2 vl::acos ( const fvec2 & angle ) [inline]

dvec3 vl::acos ( const fvec3 & angle ) [inline]

dvec4 vl::acos ( const fvec4 & angle ) [inline]

double vl::acos ( double a ) [inline]

float vl::atan ( float a ) [inline]

dvec2 vl::atan | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

dvec3 vl::atan | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

dvec4 vl::atan | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

double vl::atan ( double a ) [inline]

float vl::sinh ( float a ) [inline]

dvec2 vl::sinh ( const fvec2 & a ) [inline]

dvec3 vl::sinh ( const fvec3 & a ) [inline]

dvec4 vl::sinh ( const fvec4 & a ) [inline]

double vl::sinh ( double a ) [inline]

float vl::cosh ( float a ) [inline]

dvec2 vl::cosh ( const fvec2 & a ) [inline]

dvec3 vl::cosh ( const fvec3 & a ) [inline]

dvec4 vl::cosh ( const fvec4 & a ) [inline]

double vl::cosh ( double a ) [inline]

float vl::tanh ( float a ) [inline]

dvec2 vl::tanh ( const fvec2 & a ) [inline]

dvec3 vl::tanh ( const fvec3 & a ) [inline]

dvec4 vl::tanh ( const fvec4 & a ) [inline]

double vl::tanh ( double a ) [inline]

dvec2 vl::asinh ( const fvec2 & a ) [inline]

dvec3 vl::asinh ( const fvec3 & a ) [inline]

dvec4 vl::asinh ( const fvec4 & a ) [inline]

dvec2 vl::acosh ( const fvec2 & a ) [inline]

dvec3 vl::acosh ( const fvec3 & a ) [inline]

dvec4 vl::acosh ( const fvec4 & a ) [inline]

dvec2 vl::atanh ( const fvec2 & a ) [inline]

dvec3 vl::atanh ( const fvec3 & a ) [inline]

dvec4 vl::atanh ( const fvec4 & a ) [inline]

float vl::pow | ( | float | a,
 |  | float | b |
 | ) |  |  | [inline]

dvec2 vl::pow | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

dvec3 vl::pow | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

dvec4 vl::pow | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

double vl::pow | ( | double | a,
 |  | double | b |
 | ) |  |  | [inline]

float vl::exp ( float a ) [inline]

dvec2 vl::exp ( const fvec2 & a ) [inline]

dvec3 vl::exp ( const fvec3 & a ) [inline]

dvec4 vl::exp ( const fvec4 & a ) [inline]

double vl::exp ( double a ) [inline]

float vl::log ( float a ) [inline]

dvec2 vl::log ( const fvec2 & a ) [inline]

dvec3 vl::log ( const fvec3 & a ) [inline]

dvec4 vl::log ( const fvec4 & a ) [inline]

double vl::log ( double a ) [inline]

float vl::exp2 ( float a ) [inline]

dvec2 vl::exp2 ( const fvec2 & a ) [inline]

dvec3 vl::exp2 ( const fvec3 & a ) [inline]

dvec4 vl::exp2 ( const fvec4 & a ) [inline]

double vl::exp2 ( double a ) [inline]

float vl::log2 ( float a ) [inline]

dvec2 vl::log2 ( const fvec2 & a ) [inline]

dvec3 vl::log2 ( const fvec3 & a ) [inline]

dvec4 vl::log2 ( const fvec4 & a ) [inline]

double vl::log2 ( double a ) [inline]

float vl::log10 ( float a ) [inline]

dvec2 vl::log10 ( const fvec2 & a ) [inline]

dvec3 vl::log10 ( const fvec3 & a ) [inline]

dvec4 vl::log10 ( const fvec4 & a ) [inline]

double vl::log10 ( double a ) [inline]

float vl::sqrt ( float a ) [inline]

dvec2 vl::sqrt ( const fvec2 & a ) [inline]

dvec3 vl::sqrt ( const fvec3 & a ) [inline]

dvec4 vl::sqrt ( const fvec4 & a ) [inline]

double vl::sqrt ( double a ) [inline]

float vl::inversesqrt ( float a ) [inline]

dvec2 vl::inversesqrt ( const fvec2 & a ) [inline]

dvec3 vl::inversesqrt ( const fvec3 & a ) [inline]

dvec4 vl::inversesqrt ( const fvec4 & a ) [inline]

double vl::inversesqrt ( double a ) [inline]

float vl::abs ( float a ) [inline]

dvec2 vl::abs ( const fvec2 & a ) [inline]

ivec3 vl::abs ( const fvec3 & a ) [inline]

ivec4 vl::abs ( const fvec4 & a ) [inline]

double vl::abs ( double a ) [inline]

int vl::abs ( int a ) [inline]

float vl::sign ( float a ) [inline]

dvec2 vl::sign ( const fvec2 & a ) [inline]

ivec3 vl::sign ( const fvec3 & a ) [inline]

ivec4 vl::sign ( const fvec4 & a ) [inline]

double vl::sign ( double a ) [inline]

int vl::sign ( int a ) [inline]

float vl::floor ( float a ) [inline]

dvec2 vl::floor ( const fvec2 & a ) [inline]

dvec3 vl::floor ( const fvec3 & a ) [inline]

dvec4 vl::floor ( const fvec4 & a ) [inline]

double vl::floor ( double a ) [inline]

float vl::fract ( float a ) [inline]

float vl::trunc ( float a ) [inline]

dvec2 vl::trunc ( const fvec2 & a ) [inline]

dvec3 vl::trunc ( const fvec3 & a ) [inline]

dvec4 vl::trunc ( const fvec4 & a ) [inline]

double vl::fract ( double a ) [inline]

double vl::trunc ( double a ) [inline]

float vl::round ( float x ) [inline]

dvec2 vl::round ( const fvec2 & a ) [inline]

dvec3 vl::round ( const fvec3 & a ) [inline]

dvec4 vl::round ( const fvec4 & a ) [inline]

double vl::round ( double x ) [inline]

float vl::roundEven | ( | float | a,
 |  | float | epsilon = 0.00001f |
 | ) |  |  | [inline]

fvec2 vl::roundEven | ( | const fvec2 & | a,
 |  | float | epsilon = 0.00001f |
 | ) |  |  | [inline]

fvec3 vl::roundEven | ( | const fvec3 & | a,
 |  | float | epsilon = 0.00001f |
 | ) |  |  | [inline]

fvec4 vl::roundEven | ( | const fvec4 & | a,
 |  | float | epsilon = 0.00001f |
 | ) |  |  | [inline]

double vl::roundEven | ( | double | a,
 |  | double | epsilon = 0.00001 |
 | ) |  |  | [inline]

dvec2 vl::roundEven | ( | const dvec2 & | a,
 |  | double | epsilon = 0.00001 |
 | ) |  |  | [inline]

dvec3 vl::roundEven | ( | const dvec3 & | a,
 |  | double | epsilon = 0.00001 |
 | ) |  |  | [inline]

dvec4 vl::roundEven | ( | const dvec4 & | a,
 |  | double | epsilon = 0.00001 |
 | ) |  |  | [inline]

float vl::ceil ( float a ) [inline]

dvec2 vl::ceil ( const fvec2 & a ) [inline]

dvec3 vl::ceil ( const fvec3 & a ) [inline]

dvec4 vl::ceil ( const fvec4 & a ) [inline]

double vl::ceil ( double a ) [inline]

dvec2 vl::fract ( const fvec2 & a ) [inline]

dvec3 vl::fract ( const fvec3 & a ) [inline]

dvec4 vl::fract ( const fvec4 & a ) [inline]

float vl::mod | ( | float | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec2 vl::mod | ( | const fvec2 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec3 vl::mod | ( | const fvec3 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec4 vl::mod | ( | const fvec4 & | a,
 |  | float | b |
 | ) |  |  | [inline]

dvec2 vl::mod | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

dvec3 vl::mod | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

dvec4 vl::mod | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

double vl::mod | ( | double | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec2 vl::mod | ( | const dvec2 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec3 vl::mod | ( | const dvec3 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec4 vl::mod | ( | const dvec4 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec2 vl::modf | ( | const fvec2 & | a,
 |  | fvec2 & | intpart |
 | ) |  |  | [inline]

dvec3 vl::modf | ( | const fvec3 & | a,
 |  | fvec3 & | intpart |
 | ) |  |  | [inline]

dvec4 vl::modf | ( | const fvec4 & | a,
 |  | fvec4 & | intpart |
 | ) |  |  | [inline]

float vl::min | ( | float | a,
 |  | float | b |
 | ) |  |  | [inline]

uvec2 vl::min | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

uvec3 vl::min | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

uvec4 vl::min | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

fvec2 vl::min | ( | const fvec2 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec3 vl::min | ( | const fvec3 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec4 vl::min | ( | const fvec4 & | a,
 |  | float | b |
 | ) |  |  | [inline]

double vl::min | ( | double | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec2 vl::min | ( | const dvec2 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec3 vl::min | ( | const dvec3 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec4 vl::min | ( | const dvec4 & | a,
 |  | double | b |
 | ) |  |  | [inline]

int vl::min | ( | int | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec2 vl::min | ( | const ivec2 & | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec3 vl::min | ( | const ivec3 & | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec4 vl::min | ( | const ivec4 & | a,
 |  | int | b |
 | ) |  |  | [inline]

unsigned int vl::min | ( | unsigned int | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec2 vl::min | ( | const uvec2 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec3 vl::min | ( | const uvec3 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec4 vl::min | ( | const uvec4 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

float vl::max | ( | float | a,
 |  | float | b |
 | ) |  |  | [inline]

uvec2 vl::max | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

uvec3 vl::max | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

uvec4 vl::max | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

fvec2 vl::max | ( | const fvec2 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec3 vl::max | ( | const fvec3 & | a,
 |  | float | b |
 | ) |  |  | [inline]

fvec4 vl::max | ( | const fvec4 & | a,
 |  | float | b |
 | ) |  |  | [inline]

double vl::max | ( | double | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec2 vl::max | ( | const dvec2 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec3 vl::max | ( | const dvec3 & | a,
 |  | double | b |
 | ) |  |  | [inline]

dvec4 vl::max | ( | const dvec4 & | a,
 |  | double | b |
 | ) |  |  | [inline]

int vl::max | ( | int | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec2 vl::max | ( | const ivec2 & | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec3 vl::max | ( | const ivec3 & | a,
 |  | int | b |
 | ) |  |  | [inline]

ivec4 vl::max | ( | const ivec4 & | a,
 |  | int | b |
 | ) |  |  | [inline]

unsigned int vl::max | ( | unsigned int | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec2 vl::max | ( | const uvec2 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec3 vl::max | ( | const uvec3 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

uvec4 vl::max | ( | const uvec4 & | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

float vl::clamp | ( | float | x,
 |  | float | minval,
 |  | float | maxval |
 | ) |  |  | [inline]

fvec2 vl::clamp | ( | const fvec2 & | x,
 |  | float | minval,
 |  | float | maxval |
 | ) |  |  | [inline]

fvec3 vl::clamp | ( | const fvec3 & | x,
 |  | float | minval,
 |  | float | maxval |
 | ) |  |  | [inline]

fvec4 vl::clamp | ( | const fvec4 & | x,
 |  | float | minval,
 |  | float | maxval |
 | ) |  |  | [inline]

uvec2 vl::clamp | ( | const fvec2 & | x,
 |  | const fvec2 & | minval,
 |  | const fvec2 & | maxval |
 | ) |  |  | [inline]

uvec3 vl::clamp | ( | const fvec3 & | x,
 |  | const fvec3 & | minval,
 |  | const fvec3 & | maxval |
 | ) |  |  | [inline]

uvec4 vl::clamp | ( | const fvec4 & | x,
 |  | const fvec4 & | minval,
 |  | const fvec4 & | maxval |
 | ) |  |  | [inline]

double vl::clamp | ( | double | x,
 |  | double | minval,
 |  | double | maxval |
 | ) |  |  | [inline]

dvec2 vl::clamp | ( | const dvec2 & | x,
 |  | double | minval,
 |  | double | maxval |
 | ) |  |  | [inline]

dvec3 vl::clamp | ( | const dvec3 & | x,
 |  | double | minval,
 |  | double | maxval |
 | ) |  |  | [inline]

dvec4 vl::clamp | ( | const dvec4 & | x,
 |  | double | minval,
 |  | double | maxval |
 | ) |  |  | [inline]

int vl::clamp | ( | int | x,
 |  | int | minval,
 |  | int | maxval |
 | ) |  |  | [inline]

ivec2 vl::clamp | ( | const ivec2 & | x,
 |  | int | minval,
 |  | int | maxval |
 | ) |  |  | [inline]

ivec3 vl::clamp | ( | const ivec3 & | x,
 |  | int | minval,
 |  | int | maxval |
 | ) |  |  | [inline]

ivec4 vl::clamp | ( | const ivec4 & | x,
 |  | int | minval,
 |  | int | maxval |
 | ) |  |  | [inline]

unsigned int vl::clamp | ( | unsigned int | x,
 |  | unsigned int | minval,
 |  | unsigned int | maxval |
 | ) |  |  | [inline]

uvec2 vl::clamp | ( | const uvec2 & | x,
 |  | unsigned int | minval,
 |  | unsigned int | maxval |
 | ) |  |  | [inline]

uvec3 vl::clamp | ( | const uvec3 & | x,
 |  | unsigned int | minval,
 |  | unsigned int | maxval |
 | ) |  |  | [inline]

uvec4 vl::clamp | ( | const uvec4 & | x,
 |  | unsigned int | minval,
 |  | unsigned int | maxval |
 | ) |  |  | [inline]

float vl::mix | ( | float | a,
 |  | float | b,
 |  | float | t |
 | ) |  |  | [inline]

fvec2 vl::mix | ( | const fvec2 & | a,
 |  | const fvec2 & | b,
 |  | float | t |
 | ) |  |  | [inline]

fvec3 vl::mix | ( | const fvec3 & | a,
 |  | const fvec3 & | b,
 |  | float | t |
 | ) |  |  | [inline]

fvec4 vl::mix | ( | const fvec4 & | a,
 |  | const fvec4 & | b,
 |  | float | t |
 | ) |  |  | [inline]

dvec2 vl::mix | ( | const fvec2 & | a,
 |  | const fvec2 & | b,
 |  | const fvec2 & | t |
 | ) |  |  | [inline]

dvec3 vl::mix | ( | const fvec3 & | a,
 |  | const fvec3 & | b,
 |  | const fvec3 & | t |
 | ) |  |  | [inline]

dvec4 vl::mix | ( | const fvec4 & | a,
 |  | const fvec4 & | b,
 |  | const fvec4 & | t |
 | ) |  |  | [inline]

double vl::mix | ( | double | a,
 |  | double | b,
 |  | double | t |
 | ) |  |  | [inline]

dvec2 vl::mix | ( | const dvec2 & | a,
 |  | const dvec2 & | b,
 |  | double | t |
 | ) |  |  | [inline]

dvec3 vl::mix | ( | const dvec3 & | a,
 |  | const dvec3 & | b,
 |  | double | t |
 | ) |  |  | [inline]

dvec4 vl::mix | ( | const dvec4 & | a,
 |  | const dvec4 & | b,
 |  | double | t |
 | ) |  |  | [inline]

float vl::step | ( | float | edge,
 |  | float | a |
 | ) |  |  | [inline]

dvec2 vl::step | ( | const fvec2 & | edge,
 |  | const fvec2 & | a |
 | ) |  |  | [inline]

dvec3 vl::step | ( | const fvec3 & | edge,
 |  | const fvec3 & | a |
 | ) |  |  | [inline]

dvec4 vl::step | ( | const fvec4 & | edge,
 |  | const fvec4 & | a |
 | ) |  |  | [inline]

double vl::step | ( | double | edge,
 |  | double | a |
 | ) |  |  | [inline]

float vl::smoothstep | ( | float | edge0,
 |  | float | edge1,
 |  | float | a |
 | ) |  |  | [inline]

dvec2 vl::smoothstep | ( | const fvec2 & | edge0,
 |  | const fvec2 & | edge1,
 |  | const fvec2 & | a |
 | ) |  |  | [inline]

dvec3 vl::smoothstep | ( | const fvec3 & | edge0,
 |  | const fvec3 & | edge1,
 |  | const fvec3 & | a |
 | ) |  |  | [inline]

dvec4 vl::smoothstep | ( | const fvec4 & | edge0,
 |  | const fvec4 & | edge1,
 |  | const fvec4 & | a |
 | ) |  |  | [inline]

double vl::smoothstep | ( | double | edge0,
 |  | double | edge1,
 |  | double | a |
 | ) |  |  | [inline]

ivec2 vl::isnan ( const fvec2 & a ) [inline]

ivec3 vl::isnan ( const fvec3 & a ) [inline]

ivec4 vl::isnan ( const fvec4 & a ) [inline]

ivec2 vl::isinf ( const fvec2 & a ) [inline]

ivec3 vl::isinf ( const fvec3 & a ) [inline]

ivec4 vl::isinf ( const fvec4 & a ) [inline]

float vl::length ( float v ) [inline]

float vl::length ( const fvec2 & v ) [inline]

float vl::length ( const fvec3 & v ) [inline]

float vl::length ( const fvec4 & v ) [inline]

double vl::length ( double v ) [inline]

float vl::length ( int v ) [inline]

float vl::length ( unsigned int v ) [inline]

float vl::distance | ( | float | p0,
 |  | float | p1 |
 | ) |  |  | [inline]

float vl::distance | ( | const fvec2 & | p0,
 |  | const fvec2 & | p1 |
 | ) |  |  | [inline]

float vl::distance | ( | const fvec3 & | p0,
 |  | const fvec3 & | p1 |
 | ) |  |  | [inline]

float vl::distance | ( | const fvec4 & | p0,
 |  | const fvec4 & | p1 |
 | ) |  |  | [inline]

double vl::distance | ( | double | p0,
 |  | double | p1 |
 | ) |  |  | [inline]

float vl::distance | ( | int | p0,
 |  | int | p1 |
 | ) |  |  | [inline]

float vl::distance | ( | unsigned int | p0,
 |  | unsigned int | p1 |
 | ) |  |  | [inline]

float vl::dot | ( | float | a,
 |  | float | b |
 | ) |  |  | [inline]

float vl::dot | ( | const fvec2 & | v1,
 |  | const fvec2 & | v2 |
 | ) |  |  | [inline]

float vl::dot | ( | const fvec3 & | v1,
 |  | const fvec3 & | v2 |
 | ) |  |  | [inline]

float vl::dot | ( | const fvec4 & | v1,
 |  | const fvec4 & | v2 |
 | ) |  |  | [inline]

double vl::dot | ( | double | a,
 |  | double | b |
 | ) |  |  | [inline]

float vl::dot | ( | int | a,
 |  | int | b |
 | ) |  |  | [inline]

float vl::dot | ( | unsigned int | a,
 |  | unsigned int | b |
 | ) |  |  | [inline]

dvec3 vl::cross | ( | const fvec3 & | v1,
 |  | const fvec3 & | v2 |
 | ) |  |  | [inline]

float vl::normalize ( float ) [inline]

dvec2 vl::normalize ( const fvec2 & v ) [inline]

dvec3 vl::normalize ( const fvec3 & v ) [inline]

dvec4 vl::normalize ( const fvec4 & v ) [inline]

double vl::normalize ( double ) [inline]

float vl::faceforward | ( | float | N,
 |  | float | I,
 |  | float | Nref |
 | ) |  |  | [inline]

dvec2 vl::faceforward | ( | const fvec2 & | N,
 |  | const fvec2 & | I,
 |  | const fvec2 & | Nref |
 | ) |  |  | [inline]

dvec3 vl::faceforward | ( | const fvec3 & | N,
 |  | const fvec3 & | I,
 |  | const fvec3 & | Nref |
 | ) |  |  | [inline]

dvec4 vl::faceforward | ( | const fvec4 & | N,
 |  | const fvec4 & | I,
 |  | const fvec4 & | Nref |
 | ) |  |  | [inline]

double vl::faceforward | ( | double | N,
 |  | double | I,
 |  | double | Nref |
 | ) |  |  | [inline]

float vl::reflect | ( | float | I,
 |  | float | N |
 | ) |  |  | [inline]

dvec2 vl::reflect | ( | const fvec2 & | I,
 |  | const fvec2 & | N |
 | ) |  |  | [inline]

dvec3 vl::reflect | ( | const fvec3 & | I,
 |  | const fvec3 & | N |
 | ) |  |  | [inline]

dvec4 vl::reflect | ( | const fvec4 & | I,
 |  | const fvec4 & | N |
 | ) |  |  | [inline]

double vl::reflect | ( | double | I,
 |  | double | N |
 | ) |  |  | [inline]

float vl::refract | ( | float | I,
 |  | float | N,
 |  | float | eta |
 | ) |  |  | [inline]

fvec2 vl::refract | ( | const fvec2 & | I,
 |  | const fvec2 & | N,
 |  | float | eta |
 | ) |  |  | [inline]

fvec3 vl::refract | ( | const fvec3 & | I,
 |  | const fvec3 & | N,
 |  | float | eta |
 | ) |  |  | [inline]

fvec4 vl::refract | ( | const fvec4 & | I,
 |  | const fvec4 & | N,
 |  | float | eta |
 | ) |  |  | [inline]

double vl::refract | ( | double | I,
 |  | double | N,
 |  | double | eta |
 | ) |  |  | [inline]

dvec2 vl::refract | ( | const dvec2 & | I,
 |  | const dvec2 & | N,
 |  | double | eta |
 | ) |  |  | [inline]

dvec3 vl::refract | ( | const dvec3 & | I,
 |  | const dvec3 & | N,
 |  | double | eta |
 | ) |  |  | [inline]

dvec4 vl::refract | ( | const dvec4 & | I,
 |  | const dvec4 & | N,
 |  | double | eta |
 | ) |  |  | [inline]

dmat2 vl::matrixCompMult | ( | const fmat2 & | a,
 |  | const fmat2 & | b |
 | ) |  |  | [inline]

dmat3 vl::matrixCompMult | ( | const fmat3 & | a,
 |  | const fmat3 & | b |
 | ) |  |  | [inline]

dmat4 vl::matrixCompMult | ( | const fmat4 & | a,
 |  | const fmat4 & | b |
 | ) |  |  | [inline]

dmat2 vl::outerProduct | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

dmat3 vl::outerProduct | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

dmat4 vl::outerProduct | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

dmat2 vl::transpose ( const fmat2 & a ) [inline]

dmat3 vl::transpose ( const fmat3 & a ) [inline]

dmat4 vl::transpose ( const fmat4 & a ) [inline]

ivec4 vl::lessThan | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::lessThan | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::lessThan | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

ivec4 vl::lessThanEqual | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::lessThanEqual | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::lessThanEqual | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

ivec4 vl::greaterThan | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::greaterThan | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::greaterThan | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

ivec4 vl::greaterThanEqual | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::greaterThanEqual | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::greaterThanEqual | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

ivec4 vl::equal | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::equal | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::equal | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

ivec4 vl::notEqual | ( | const fvec4 & | a,
 |  | const fvec4 & | b |
 | ) |  |  | [inline]

ivec3 vl::notEqual | ( | const fvec3 & | a,
 |  | const fvec3 & | b |
 | ) |  |  | [inline]

ivec2 vl::notEqual | ( | const fvec2 & | a,
 |  | const fvec2 & | b |
 | ) |  |  | [inline]

bool vl::any ( const ivec2 & a ) [inline]

bool vl::any ( const ivec3 & a ) [inline]

bool vl::any ( const ivec4 & a ) [inline]

bool vl::all ( const ivec2 & a ) [inline]

bool vl::all ( const ivec3 & a ) [inline]

bool vl::all ( const ivec4 & a ) [inline]

ref< Image > vl::loadCubemap | ( | const String & | xp_file,
 |  | const String & | xn_file,
 |  | const String & | yp_file,
 |  | const String & | yn_file,
 |  | const String & | zp_file,
 |  | const String & | zn_file
 | ) |  |

Loads six images and assembles them into a cubemap image.

ref< Image > vl::loadRAW | ( | VirtualFile * | file,
 |  | int | width,
 |  | int | height,
 |  | int | depth,
 |  | int | bytealign,
 |  | EImageFormat | format,
 |  | EImageType | type
 | ) |  |

Loads a raw image file.

ref< Image > vl::loadImage ( VirtualFile * file )

Loads an image from the specified file.

ref< Image > vl::loadImage ( const String & path )

Loads an image from the specified path.

bool vl::loadImagesFromDir | ( | const String & | dir_path,
 |  | const String & | ext,
 |  | std::vector< ref< Image > > & | images
 | ) |  |

Loads all the images with the specified extension from the given directory.

ref< Image > vl::assemble3DImage ( const std::vector< ref< Image > > & images )

Assembles the given 2D images in a single 2D image, all the images must be 2D images and have the same size, format() and type().

The order of the given images is important: the first image will be used for z layer #0, the second for z layer #1 and so on.

bool vl::saveImage | ( | Image * | img,
 |  | VirtualFile * | file
 | ) |  |

Writes an image on the specified file.

bool vl::saveImage | ( | Image * | img,
 |  | const String & | path
 | ) |  |

Writes an image on the specified path.

Real vl::randomMinMax | ( | Real | min,
 |  | Real | max
 | ) |  |

Returns a random number N that between 'min' and 'max' included.

int vl::greaterEqualPow2 ( int n )

Returns a number N that is a power of 2 and that is equal to or greater than 'n'.

int vl::smallerEqualPow2 ( int n )

Returns a number N that is a power of 2 and that is equal to or smaller than 'n'.

void vl::extractPlanes | ( | Plane * | planes,
 |  | const mat4 & | modelviewproj
 | ) |  |

Extracts the 6 frustum planes for the given model-view-projection matrix.

template<typename scalar_type >
Matrix2<scalar_type> vl::operator* | ( | const Matrix2< scalar_type > & | m2,
 |  | const Matrix2< scalar_type > & | m1 |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix2<scalar_type> vl::operator+ | ( | scalar_type | d,
 |  | const Matrix2< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix2<scalar_type> vl::operator* | ( | scalar_type | d,
 |  | const Matrix2< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Matrix2< scalar_type > & | m,
 |  | const Vector2< scalar_type > & | v |
 | ) |  |  | [inline]

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Vector2< scalar_type > & | v,
 |  | const Matrix2< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix3<scalar_type> vl::operator* | ( | const Matrix3< scalar_type > & | m2,
 |  | const Matrix3< scalar_type > & | m1 |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix3<scalar_type> vl::operator+ | ( | scalar_type | d,
 |  | const Matrix3< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix3<scalar_type> vl::operator* | ( | scalar_type | d,
 |  | const Matrix3< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Vector3<scalar_type> vl::operator* | ( | const Matrix3< scalar_type > & | m,
 |  | const Vector3< scalar_type > & | v |
 | ) |  |  | [inline]

Post multiplication: matrix * column vector.

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Matrix3< scalar_type > & | m,
 |  | const Vector2< scalar_type > & | v |
 | ) |  |  | [inline]

Post multiplication: matrix * column vector The incoming vector is considered a Vector3<scalar_type> with the component z = 0.

template<typename scalar_type >
Vector3<scalar_type> vl::operator* | ( | const Vector3< scalar_type > & | v,
 |  | const Matrix3< scalar_type > & | m |
 | ) |  |  | [inline]

Pre multiplication: row vector * matrix.

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Vector2< scalar_type > & | v,
 |  | const Matrix3< scalar_type > & | m |
 | ) |  |  | [inline]

Pre multiplication: row vector * matrix The incoming vector is considered a Vector3<scalar_type> with the component z = 0.

template<typename scalar_type >
Matrix4<scalar_type> vl::operator* | ( | const Matrix4< scalar_type > & | m2,
 |  | const Matrix4< scalar_type > & | m1 |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix4<scalar_type> vl::operator+ | ( | scalar_type | d,
 |  | const Matrix4< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Matrix4<scalar_type> vl::operator* | ( | scalar_type | d,
 |  | const Matrix4< scalar_type > & | m |
 | ) |  |  | [inline]

template<typename scalar_type >
Vector4<scalar_type> vl::operator* | ( | const Matrix4< scalar_type > & | m,
 |  | const Vector4< scalar_type > & | v |
 | ) |  |  | [inline]

Post multiplication: matrix * column vector.

template<typename scalar_type >
Vector3<scalar_type> vl::operator* | ( | const Matrix4< scalar_type > & | m,
 |  | const Vector3< scalar_type > & | v |
 | ) |  |  | [inline]

Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with the component w = 1.

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Matrix4< scalar_type > & | m,
 |  | const Vector2< scalar_type > & | v |
 | ) |  |  | [inline]

Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.

template<typename scalar_type >
Vector4<scalar_type> vl::operator* | ( | const Vector4< scalar_type > & | v,
 |  | const Matrix4< scalar_type > & | m |
 | ) |  |  | [inline]

Pre multiplication: row vector * matrix.

template<typename scalar_type >
Vector3<scalar_type> vl::operator* | ( | const Vector3< scalar_type > & | v,
 |  | const Matrix4< scalar_type > & | m |
 | ) |  |  | [inline]

Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with the component w = 1.

template<typename scalar_type >
Vector2<scalar_type> vl::operator* | ( | const Vector2< scalar_type > & | v,
 |  | const Matrix4< scalar_type > & | m |
 | ) |  |  | [inline]

Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.

template<class T1 , class T2 >
bool vl::operator== | ( | const ref< T1 > & | o1,
 |  | const ref< T2 > & | o2 |
 | ) |  |  | [inline]

template<class T1 , class T2 >
bool vl::operator!= | ( | const ref< T1 > & | o1,
 |  | const ref< T2 > & | o2 |
 | ) |  |  | [inline]

template<class T1 , class T2 >
bool vl::operator== | ( | const ref< T1 > & | o1,
 |  | T2 * | o2 |
 | ) |  |  | [inline]

template<class T1 , class T2 >
bool vl::operator!= | ( | const ref< T1 > & | o1,
 |  | T2 * | o2 |
 | ) |  |  | [inline]

template<class T1 , class T2 >
bool vl::operator== | ( | T1 * | o1,
 |  | const ref< T2 > & | o2 |
 | ) |  |  | [inline]

template<class T1 , class T2 >
bool vl::operator!= | ( | T1 * | o1,
 |  | const ref< T2 > & | o2 |
 | ) |  |  | [inline]

int vl::glcheck | ( | const char * | file,
 |  | int | line
 | ) |  |

quat vl::operator* | ( | Real | r,
 |  | const quat & | q |
 | ) |  |  | [inline]

quat vl::operator* | ( | const quat & | q1,
 |  | const quat & | q2 |
 | ) |  |  | [inline]

vec3 vl::operator* | ( | const quat & | q,
 |  | const vec3 & | v |
 | ) |  |  | [inline]

vec4 vl::operator* | ( | const quat & | q,
 |  | const vec4 & | v |
 | ) |  |  | [inline]

ref< ResourceDatabase > vl::loadResource | ( | const String & | path,
 |  | bool | quick = true
 | ) |  |

Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(const String& path, bool quick).

ref< ResourceDatabase > vl::loadResource | ( | VirtualFile * | file,
 |  | bool | quick = true
 | ) |  |

Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(VirtualFile* file).

bool vl::canLoad ( const String & path )

Returns true if there is a ResourceLoadWriter registered to load the specified path or extension.

bool vl::canLoad ( VirtualFile * file )

Returns true if there is a ResourceLoadWriter registered to load the specified file.

bool vl::canWrite ( const String & path )

Returns true if there is a ResourceLoadWriter registered to write the specified path or extension.

bool vl::canWrite ( VirtualFile * file )

Returns true if there is a ResourceLoadWriter registered to write the specified file.

String vl::operator+ | ( | const wchar_t * | pstr,
 |  | const String & | str |
 | ) |  |  | [inline]

String vl::operator+ | ( | const char * | pstr,
 |  | const String & | str |
 | ) |  |  | [inline]

String vl::operator+ | ( | wchar_t | ch,
 |  | const String & | str |
 | ) |  |  | [inline]

String vl::operator+ | ( | char | ch,
 |  | const String & | str |
 | ) |  |  | [inline]

float vl::fast1_inversesqrt ( float x ) [inline]

float vl::fast2_inversesqrt ( float x ) [inline]

float vl::fast_sqrt ( float x ) [inline]

template<typename T >
const Vector2<T> vl::operator* | ( | T | val,
 |  | const Vector2< T > & | v |
 | ) |  |  | [inline]

template<typename T >
const Vector3<T> vl::operator* | ( | T | val,
 |  | const Vector3< T > & | v |
 | ) |  |  | [inline]

template<typename T >
const Vector4<T> vl::operator* | ( | T | val,
 |  | const Vector4< T > & | v |
 | ) |  |  | [inline]

ref< VirtualFile > vl::locateFile ( const String & path )

Utility function, equivalent to vl::VisualizationLibrary::fileSystem()->locateFile(path).

void vl::showWin32Console ( )

Shows a console window that displays the standard output. This function is to be used only under Windows.

ref< ResourceDatabase > vl::load3DS ( VirtualFile * file )

ref< ResourceDatabase > vl::load3DS ( const String & path )

ref< ResourceDatabase > vl::loadAC3D ( VirtualFile * file )

Loads and AC3D file (.ac).

Note:
The importer supports only very simple objects, this are the limitations:
  • No hierarchical transforms
  • Imports only the polygons, no lines
  • Only one material per object
  • Face flags supported: only "two-sided" flag
  • The objects are all flat shaded

ref< ResourceDatabase > vl::loadAC3D ( const String & path )

Loads and AC3D file (.ac).

Note:
The importer supports only very simple objects, this are the limitations:
  • No hierarchical transforms
  • Imports only the polygons, no lines
  • Only one material per object
  • Face flags supported: only "two-sided" flag
  • The objects are all flat shaded

ref< Image > vl::loadBMP ( VirtualFile * file )

ref< Image > vl::loadBMP ( const String & path )

Loads a BMP file.

Supports the following formats:

  • 8 bit palettized, uncompressed
  • 24 bit RGB, uncompressed
  • 32 bit RGBX, uncompressed
  • image flipping

bool vl::isBMP ( VirtualFile * file )

ref< Image > vl::loadDAT ( VirtualFile * file )

ref< Image > vl::loadDAT ( const String & path )

bool vl::isDAT ( VirtualFile * file )

ref< Image > vl::loadDDS ( VirtualFile * file )

ref< Image > vl::loadDDS ( const String & path )

Loads a DDS file.

Can load 2D textures, cubemaps, mipmaps for both cubemaps and 2d textures (also non square and non power of 2).

Supports the following formats:

  • RGB 24 bit, uncompressed
  • RGBA 32 bit, uncompressed
  • BGR 24 bit, uncompressed
  • BGRA 32 bit, uncompressed
  • Grayscale 8 bit
  • Grayscale + Alpha, 8 + 8 bit
  • 8 bit palettized (8 bit palette compression)
  • DXT1, DXT3, DXT5

Remarks:
DDS images and cubemaps will look flipped if created according to the DirectX conventions.
In order to prevent this, your tools might have an "export DDS for OpenGL"-like option. If not, you will either have to flip your images before exporting them to DDS or you will have to flip the texture coordinates of your models.

bool vl::isDDS ( VirtualFile * file )

ref< Image > vl::loadDICOM ( VirtualFile * file )

Loads a DICOM file.

The retuned image has attached also some tags (vl::Image::tags()) extracted from the DICOM file describing the image geometry.

ref< Image > vl::loadDICOM ( const String & path )

Loads a DICOM file.

bool vl::saveDICOM | ( | const Image * | src,
 |  | const String & | path
 | ) |  |

Writes a DICOM file.

bool vl::saveDICOM | ( | const Image * | src,
 |  | VirtualFile * | file
 | ) |  |

Writes a DICOM file.

bool vl::isDICOM ( VirtualFile * file )

Checks if the given file is a DICOM file.

ref< Image > vl::loadJPG ( VirtualFile * file )

ref< Image > vl::loadJPG ( const String & path )

bool vl::isJPG ( VirtualFile * file )

bool vl::saveJPG | ( | const Image * | src,
 |  | const String & | path,
 |  | int | quality = 95
 | ) |  |

bool vl::saveJPG | ( | const Image * | src,
 |  | VirtualFile * | file,
 |  | int | quality = 95
 | ) |  |

* Here we use the library-supplied code to send compressed data to a

ref< ResourceDatabase > vl::loadMD2 ( const String & path )

ref< ResourceDatabase > vl::loadMD2 ( VirtualFile * file )

ref< ResourceDatabase > vl::loadOBJ ( const String & path )

Loads a Wavefront OBJ file. See also ObjLoader.

ref< ResourceDatabase > vl::loadOBJ ( VirtualFile * file )

Loads a Wavefront OBJ file. See also ObjLoader.

ref< ResourceDatabase > vl::loadPLY ( VirtualFile * file )

ref< ResourceDatabase > vl::loadPLY ( const String & path )

ref< Image > vl::loadPNG ( VirtualFile * file )

png_set_strip_alpha(png_ptr);

* Turn on interlace handling. REQUIRED if you are not using

* Optional call to gamma correct and add the background to the palette

* Allocate the memory to hold the image using the fields of info_ptr. */

* The easiest way to read the image: */ / png_bytep row_pointers[height];

ref< Image > vl::loadPNG ( const String & path )

bool vl::isPNG ( VirtualFile * file )

bool vl::savePNG | ( | const Image * | src,
 |  | const String & | path,
 |  | int | compression = 6
 | ) |  |

bool vl::savePNG | ( | const Image * | src,
 |  | VirtualFile * | file,
 |  | int | compression = 6
 | ) |  |

ref< ResourceDatabase > vl::loadSTL ( VirtualFile * file )

ref< ResourceDatabase > vl::loadSTL ( const String & path )

ref< Image > vl::loadTGA ( VirtualFile * file )

ref< Image > vl::loadTGA ( const String & path )

Loads a TGA file.

Supports the following formats:

  • IF_RGBA 32 bit uncompressed
  • RGB 24 bit uncompressed
  • RGB 16 bit uncompressed
  • IF_RGBA 32 bit RLE compressed
  • RGB 24 bit RLE compressed
  • RGB 16 bit RLE compressed
  • Grayscale uncompressed
  • Grayscale RLE compressed
  • 8 bit palettizzed / 32 bit (IF_RGBA) per color uncompressed
  • 8 bit palettizzed / 24 bit (rgb) per color uncompressed
  • 8 bit palettizzed / 32 bit (IF_RGBA) per color RLE uncompressed
  • 8 bit palettizzed / 24 bit (rgb) per color RLE uncompressed

bool vl::isTGA ( VirtualFile * file )

A TGA file is accepted only if it has a 'TGA' extension.

bool vl::saveTGA | ( | const Image * | src,
 |  | const String & | path
 | ) |  |

bool vl::saveTGA | ( | const Image * | src,
 |  | VirtualFile * | file
 | ) |  |

ref< Image > vl::loadTIFF ( VirtualFile * file )

ref< Image > vl::loadTIFF ( const String & path )

bool vl::isTIFF ( VirtualFile * file )

bool vl::saveTIFF | ( | const Image * | src,
 |  | const String & | path
 | ) |  |

bool vl::saveTIFF | ( | const Image * | src,
 |  | VirtualFile * | file
 | ) |  |

Variable Documentation

vl::Glyph vl::ft_errors[]

The Glyph associated to a character of a given Font.

const double vl::dPi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845

Greek Pi constant using double precision.

const double vl::dDEG_TO_RAD = dPi / 180.0

Constant to convert degrees into radians using double precision.

const double vl::dRAD_TO_DEG = 180.0 / dPi

Constant to convert radians into degrees using double precision.

const float vl::fPi = (float)3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845

Greek Pi constant using float precision.

const float vl::fDEG_TO_RAD = float(dPi / 180.0)

Constant to convert degrees into radians using float precision.

const float vl::fRAD_TO_DEG = float(180.0 / dPi)

Constant to convert radians into degrees using float precision.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: vlGLUT Namespace Reference

  • Namespace List
  • Namespace Members

vlGLUT Namespace Reference

The GLUT bindings namespace. More...

Classes

class | GLUTWindow
The GLUTWindow class implements an OpenGLContext using the GLUT API. More...

Functions

void | atexit_visualization_library_shutdown ()

Detailed Description

The GLUT bindings namespace.

Function Documentation

void vlGLUT::atexit_visualization_library_shutdown ( )

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vlMFC Namespace Reference

  • Namespace List
  • Namespace Members

vlMFC Namespace Reference

The MFC bindings namespace. More...

Classes

class MFCWindow
The MFCWindow class is an MFC CWnd with the functionalities of a Win32Context. More...

Detailed Description

The MFC bindings namespace.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: vlMolecule Namespace Reference

  • Namespace List
  • Namespace Members

vlMolecule Namespace Reference

The Molecule Visualization namespace. More...

Classes

class | Atom
The Atom class represents an atom to be used with the Molecule class. More...
class | Bond
The Bond class represents a bond to be used with the Molecule class. More...
class | AtomInfo
Encapsulates information regarding an atom type. More...
class | Molecule
The Molecule class is used to manage and render 3D molecular structures. More...
class | RingExtractor
The RingExtractor class traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection. More...

Enumerations

enum EBondType {
BT_None, BT_Single, BT_Double, BT_Triple,
BT_Aromatic, BT_Amide, BT_Dummy, BT_Unknown
}
Bond types. More...
enum EAtomType {
AT_Hydrogen, AT_Helium, AT_Lithium, AT_Beryllium,
AT_Boron, AT_Carbon, AT_Nitrogen, AT_Oxygen,
AT_Fluorine, AT_Neon, AT_Sodium, AT_Magnesium,
AT_Aluminium, AT_Silicon, AT_Phosphorus, AT_Sulfur,
AT_Chlorine, AT_Argon, AT_Potassium, AT_Calcium,
AT_Scandium, AT_Titanium, AT_Vanadium, AT_Chromium,
AT_Manganese, AT_Iron, AT_Cobalt, AT_Nickel,
AT_Copper, AT_Zinc, AT_Gallium, AT_Germanium,
AT_Arsenic, AT_Selenium, AT_Bromine, AT_Krypton,
AT_Rubidium, AT_Strontium, AT_Yttrium, AT_Zirconium,
AT_Niobium, AT_Molybdenum, AT_Technetium, AT_Ruthenium,
AT_Rhodium, AT_Palladium, AT_Silver, AT_Cadmium,
AT_Indium, AT_Tin, AT_Antimony, AT_Tellurium,
AT_Iodine, AT_Xenon, AT_Caesium, AT_Barium,
AT_Lanthanum, AT_Cerium, AT_Praseodymium, AT_Neodymium,
AT_Promethium, AT_Samarium, AT_Europium, AT_Gadolinium,
AT_Terbium, AT_Dysprosium, AT_Holmium, AT_Erbium,
AT_Thulium, AT_Ytterbium, AT_Lutetium, AT_Hafnium,
AT_Tantalum, AT_Tungsten, AT_Rhenium, AT_Osmium,
AT_Iridium, AT_Platinum, AT_Gold, AT_Mercury,
AT_Thallium, AT_Lead, AT_Bismuth, AT_Polonium,
AT_Astatine, AT_Radon, AT_Francium, AT_Radium,
AT_Actinium, AT_Thorium, AT_Protactinium, AT_Uranium,
AT_Neptunium, AT_Plutonium, AT_Americium, AT_Curium,
AT_Berkelium, AT_Californium, AT_Einsteinium, AT_Fermium,
AT_Mendelevium, AT_Nobelium, AT_Lawrencium, AT_Rutherfordium,
AT_Dubnium, AT_Seaborgium, AT_Bohrium, AT_Hassium,
AT_Meitnerium, AT_Darmstadtium, AT_Roentgenium, AT_Ununbium,
AT_Ununtrium, AT_Ununquadium, AT_Ununpentium, AT_Ununhexium,
AT_Ununseptium, AT_Ununoctium, AT_Unknown, AT_Count
}
Element types. More...
enum | EMoleculeStyle { MS_AtomsOnly, MS_BallAndStick, MS_Sticks, MS_Wireframe }
Defines the main molecule styles. More...

Functions

const AtomInfo & | atomInfo (EAtomType type)
Returns an AtomInfo representing the properties of the given atom type.
EAtomType | atomType (const char *type)
Translates a string containing atom type name, atom symbol or a Sybyl type into an EAtomType.
bool | loadMOL2 (const vl::String &path, std::vector< vl::ref< Molecule > > &structures)
Loads a Tripos MOL2 file.
bool | loadMOL2 (vl::VirtualFile *vfile, std::vector< vl::ref< Molecule > > &structures)
Loads a Tripos MOL2 file.

Detailed Description

The Molecule Visualization namespace.

Enumeration Type Documentation

enum vlMolecule::EBondType

Bond types.

Enumerator:
BT_None
BT_Single
BT_Double
BT_Triple
BT_Aromatic
BT_Amide
BT_Dummy
BT_Unknown

enum vlMolecule::EAtomType

Element types.

Enumerator:
AT_Hydrogen
AT_Helium
AT_Lithium
AT_Beryllium
AT_Boron
AT_Carbon
AT_Nitrogen
AT_Oxygen
AT_Fluorine
AT_Neon
AT_Sodium
AT_Magnesium
AT_Aluminium
AT_Silicon
AT_Phosphorus
AT_Sulfur
AT_Chlorine
AT_Argon
AT_Potassium
AT_Calcium
AT_Scandium
AT_Titanium
AT_Vanadium
AT_Chromium
AT_Manganese
AT_Iron
AT_Cobalt
AT_Nickel
AT_Copper
AT_Zinc
AT_Gallium
AT_Germanium
AT_Arsenic
AT_Selenium
AT_Bromine
AT_Krypton
AT_Rubidium
AT_Strontium
AT_Yttrium
AT_Zirconium
AT_Niobium
AT_Molybdenum
AT_Technetium
AT_Ruthenium
AT_Rhodium
AT_Palladium
AT_Silver
AT_Cadmium
AT_Indium
AT_Tin
AT_Antimony
AT_Tellurium
AT_Iodine
AT_Xenon
AT_Caesium
AT_Barium
AT_Lanthanum
AT_Cerium
AT_Praseodymium
AT_Neodymium
AT_Promethium
AT_Samarium
AT_Europium
AT_Gadolinium
AT_Terbium
AT_Dysprosium
AT_Holmium
AT_Erbium
AT_Thulium
AT_Ytterbium
AT_Lutetium
AT_Hafnium
AT_Tantalum
AT_Tungsten
AT_Rhenium
AT_Osmium
AT_Iridium
AT_Platinum
AT_Gold
AT_Mercury
AT_Thallium
AT_Lead
AT_Bismuth
AT_Polonium
AT_Astatine
AT_Radon
AT_Francium
AT_Radium
AT_Actinium
AT_Thorium
AT_Protactinium
AT_Uranium
AT_Neptunium
AT_Plutonium
AT_Americium
AT_Curium
AT_Berkelium
AT_Californium
AT_Einsteinium
AT_Fermium
AT_Mendelevium
AT_Nobelium
AT_Lawrencium
AT_Rutherfordium
AT_Dubnium
AT_Seaborgium
AT_Bohrium
AT_Hassium
AT_Meitnerium
AT_Darmstadtium
AT_Roentgenium
AT_Ununbium
AT_Ununtrium
AT_Ununquadium
AT_Ununpentium
AT_Ununhexium
AT_Ununseptium
AT_Ununoctium
AT_Unknown
AT_Count

enum vlMolecule::EMoleculeStyle

Defines the main molecule styles.

Enumerator:
MS_AtomsOnly
MS_BallAndStick
MS_Sticks
MS_Wireframe

Function Documentation

const AtomInfo & vlMolecule::atomInfo ( EAtomType type )

Returns an AtomInfo representing the properties of the given atom type.

EAtomType vlMolecule::atomType ( const char * type )

Translates a string containing atom type name, atom symbol or a Sybyl type into an EAtomType.

bool vlMolecule::loadMOL2 | ( | const vl::String & | path,
 |  | std::vector< vl::ref< Molecule > > & | structures
 | ) |  |

Loads a Tripos MOL2 file.

The Molecule tags will contain the following key/value pairs:

  • "MultiMol2Index": the index (0-based) of the structure in a multi MOL2 file.
  • "FilePath": the full path of the file that contained the structure.

bool vlMolecule::loadMOL2 | ( | vl::VirtualFile * | vfile,
 |  | std::vector< vl::ref< Molecule > > & | structures
 | ) |  |

Loads a Tripos MOL2 file.

The Molecule tags will contain the following key/value pairs:

  • "MultiMol2Index": the index (0-based) of the structure in a multi MOL2 file.
  • "FilePath": the full path of the file that contained the structure.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlQt4 Namespace Reference

  • Namespace List
  • Namespace Members

vlQt4 Namespace Reference

The Qt4 bindings namespace. More...

Classes

class Qt4Widget
The Qt4Widget class implements an OpenGLContext using the Trolltech's Qt4 API. More...

Detailed Description

The Qt4 bindings namespace.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: vlSDL Namespace Reference

  • Namespace List
  • Namespace Members

vlSDL Namespace Reference

The SDL bindings namespace. More...

Classes

class | SDLWindow
The SDLWindow class implements an OpenGLContext using the SDL API. More...

Functions

void | messageLoop ()

Detailed Description

The SDL bindings namespace.

Function Documentation

void vlSDL::messageLoop ( )

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlut Namespace Reference

  • Namespace List
  • Namespace Members

vlut Namespace Reference

Visualization Library utility namespace. More...

Classes

class | Applet
The Applet class is an utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline. More...

Enumerations

enum | ECapsuleCap { CC_FlatCap, CC_RoundedCap, CC_NoCap }

Functions

vl::fvec4 | makeColor (unsigned int color)
vl::ref< vl::Geometry > | makeIcosphere (const vl::vec3 &pos, vl::Real radius=1, int detail=2, bool remove_doubles=true)
Creates a sphere by iteratively subdividing an icosahedron.
vl::ref< vl::Geometry > | makeCylinder (const vl::vec3 &origin, vl::Real diameter=1, vl::Real height=1, int phi=20, int theta=2, bool top=true, bool bottom=true)
Creates a cylinder.
vl::ref< vl::Geometry > | makeUVSphere (const vl::vec3 &origin, vl::Real diameter=1, int phi=20, int theta=20)
Creates a uv sphere.
vl::ref< vl::Geometry > | makeTorus (const vl::vec3 &origin, vl::Real diameter=1, vl::Real thickness=0.2, int phi=10, int theta=10)
Creates torus.
vl::ref< vl::Geometry > | makeCone (const vl::vec3 &origin, vl::Real diameter=1, vl::Real height=1, int phi=10, bool bottom=true)
Creates a cone.
vl::ref< vl::Geometry > | makePyramid (const vl::vec3 &origin, vl::Real side=1, vl::Real height=1)
Creates a pyramid.
vl::ref< vl::Geometry > | makeBox (const vl::vec3 &origin, vl::Real xside=1, vl::Real yside=1, vl::Real zside=1, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | makeBox (const vl::vec3 &min, const vl::vec3 &max, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | makeBox (const vl::AABB &aabb, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | makeGrid (const vl::vec3 &origin, vl::Real xside, vl::Real zside, int x, int z, bool gen_texcoords=false, vl::fvec2 uv0=vl::fvec2(), vl::fvec2 uv1=vl::fvec2())
Creates a 2D grid.
vl::ref< vl::Geometry > | makeIcosahedron (const vl::vec3 &origin, vl::Real diameter)
Creates an icosahedron.
vl::ref< vl::Geometry > | makePoints (const std::vector< vl::vec3 > &pos, const vl::fvec4 &color=vlut::white)
Creates a Geometry representing a set of points.
vl::ref< vl::Geometry > | makeCircle (vl::vec3 origin, vl::Real radius, int slices=60)
Creates a 2D circle.
vl::ref< vl::Geometry > | makeCapsule (float radius, float height, int segments, ECapsuleCap top_cap, ECapsuleCap bottom_cap, const vl::fvec4 &top_col, const vl::fvec4 &bottom_col)
Creates a 3d capsule with rounded, flat or no caps.

Detailed Description

Visualization Library utility namespace.

Enumeration Type Documentation

enum vlut::ECapsuleCap

Enumerator:
CC_FlatCap
CC_RoundedCap
CC_NoCap

Function Documentation

vl::fvec4 vlut::makeColor ( unsigned int color ) [inline]

vl::ref<vl::Geometry> vlut::makeIcosphere | ( | const vl::vec3 & | pos,
 |  | vl::Real | radius = 1,
 |  | int | detail = 2,
 |  | bool | remove_doubles = true
 | ) |  |

Creates a sphere by iteratively subdividing an icosahedron.

vl::ref<vl::Geometry> vlut::makeCylinder | ( | const vl::vec3 & | origin,
 |  | vl::Real | diameter = 1,
 |  | vl::Real | height = 1,
 |  | int | phi = 20,
 |  | int | theta = 2,
 |  | bool | top = true,
 |  | bool | bottom = true
 | ) |  |

Creates a cylinder.

vl::ref<vl::Geometry> vlut::makeUVSphere | ( | const vl::vec3 & | origin,
 |  | vl::Real | diameter = 1,
 |  | int | phi = 20,
 |  | int | theta = 20
 | ) |  |

Creates a uv sphere.

vl::ref<vl::Geometry> vlut::makeTorus | ( | const vl::vec3 & | origin,
 |  | vl::Real | diameter = 1,
 |  | vl::Real | thickness = 0.2,
 |  | int | phi = 10,
 |  | int | theta = 10
 | ) |  |

Creates torus.

vl::ref<vl::Geometry> vlut::makeCone | ( | const vl::vec3 & | origin,
 |  | vl::Real | diameter = 1,
 |  | vl::Real | height = 1,
 |  | int | phi = 10,
 |  | bool | bottom = true
 | ) |  |

Creates a cone.

vl::ref<vl::Geometry> vlut::makePyramid | ( | const vl::vec3 & | origin,
 |  | vl::Real | side = 1,
 |  | vl::Real | height = 1
 | ) |  |

Creates a pyramid.

vl::ref<vl::Geometry> vlut::makeBox | ( | const vl::vec3 & | origin,
 |  | vl::Real | xside = 1,
 |  | vl::Real | yside = 1,
 |  | vl::Real | zside = 1,
 |  | bool | tex_coords = true
 | ) |  |

Creates a box.

ref< Geometry > vlut::makeBox | ( | const vl::vec3 & | min,
 |  | const vl::vec3 & | max,
 |  | bool | tex_coords = true
 | ) |  |

Creates a box.

ref< Geometry > vlut::makeBox | ( | const vl::AABB & | aabb,
 |  | bool | tex_coords = true
 | ) |  |

Creates a box.

vl::ref<vl::Geometry> vlut::makeGrid | ( | const vl::vec3 & | origin,
 |  | vl::Real | xside,
 |  | vl::Real | zside,
 |  | int | x,
 |  | int | z,
 |  | bool | gen_texcoords = false,
 |  | vl::fvec2 | uv0 = vl::fvec2(),
 |  | vl::fvec2 | uv1 = vl::fvec2()
 | ) |  |

Creates a 2D grid.

vl::ref<vl::Geometry> vlut::makeIcosahedron | ( | const vl::vec3 & | origin,
 |  | vl::Real | diameter
 | ) |  |

Creates an icosahedron.

vl::ref<vl::Geometry> vlut::makePoints | ( | const std::vector< vl::vec3 > & | pos,
 |  | const vl::fvec4 & | color = vlut::white
 | ) |  |

Creates a Geometry representing a set of points.

vl::ref<vl::Geometry> vlut::makeCircle | ( | vl::vec3 | origin,
 |  | vl::Real | radius,
 |  | int | slices = 60
 | ) |  |

Creates a 2D circle.

vl::ref<vl::Geometry> vlut::makeCapsule | ( | float | radius,
 |  | float | height,
 |  | int | segments,
 |  | ECapsuleCap | top_cap,
 |  | ECapsuleCap | bottom_cap,
 |  | const vl::fvec4 & | top_col,
 |  | const vl::fvec4 & | bottom_col
 | ) |  |

Creates a 3d capsule with rounded, flat or no caps.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlVG Namespace Reference

  • Namespace List
  • Namespace Members

vlVG Namespace Reference

The Vector Graphics namespace. More...

Classes

class | SceneManagerVectorGraphics
The SceneManagerVectorGraphics class is a SceneManager that contains VectorGraphics objects. More...
class | VectorGraphics
The VectorGraphics class is used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics. More...

Enumerations

enum | ETextureMode { TextureMode_Clamp, TextureMode_Repeat }
Defines how the texture is applied to the rendering primitive. More...
enum EPolygonStipple {
PolygonStipple_Solid, PolygonStipple_Dot, PolygonStipple_Chain, PolygonStipple_HLine,
PolygonStipple_VLine
}
Poligon stipple patterns. More...
enum ELineStipple {
LineStipple_Solid, LineStipple_Dot, LineStipple_Dash, LineStipple_Dash4,
LineStipple_Dash8, LineStipple_DashDot, LineStipple_DashDotDot
}
Line stipple patterns. More...

Detailed Description

The Vector Graphics namespace.

Enumeration Type Documentation

enum vlVG::ETextureMode

Defines how the texture is applied to the rendering primitive.

Enumerator:
TextureMode_Clamp | The texture is stretched over the primitive.
TextureMode_Repeat | The texture is repeated over the primitive.

enum vlVG::EPolygonStipple

Poligon stipple patterns.

Enumerator:
PolygonStipple_Solid The poligon is completely filled (default).
PolygonStipple_Dot
PolygonStipple_Chain
PolygonStipple_HLine
PolygonStipple_VLine

enum vlVG::ELineStipple

Line stipple patterns.

Enumerator:
LineStipple_Solid The line is completely filled (default).
LineStipple_Dot
LineStipple_Dash
LineStipple_Dash4
LineStipple_Dash8
LineStipple_DashDot
LineStipple_DashDotDot

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlVolume Namespace Reference

  • Namespace List
  • Namespace Members

vlVolume Namespace Reference

The Volume Rendering namespace. More...

Classes

class | Volume
Defines the volume data to be used with a MarchingCube object. More...
class | VolumeInfo
Defines the volume parameters to be used with a MarchingCube and Volume object. More...
class | MarchingCubes
An efficient implementation of the Marching Cubes algorithm. More...
class | SlicedVolume
An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices. More...
class | VolumePlot
Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm. More...

Detailed Description

The Volume Rendering namespace.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: vlWin32 Namespace Reference

  • Namespace List
  • Namespace Members

vlWin32 Namespace Reference

The Win32 bindings namespace. More...

Classes

class | Win32Context
The Win32Context class implements an OpenGLContext using the Win32 API. More...
class | Win32Window
The Win32Window class is a Win32Context that can be used as a top or child window. More...

Functions

int | choosePixelFormat (const vl::OpenGLContextFormat &fmt, bool verbose=true)
int | messageLoop ()
void | peekMessage (MSG &msg)
void | dispatchUpdate ()
void | translateKeyEvent (WPARAM wParam, LPARAM lParam, unsigned short &unicode_out, vl::EKey &key_out)

Detailed Description

The Win32 bindings namespace.

Function Documentation

int vlWin32::choosePixelFormat | ( | const vl::OpenGLContextFormat & | fmt,
 |  | bool | verbose = true
 | ) |  |

int vlWin32::messageLoop ( )

void vlWin32::peekMessage ( MSG & msg )

void vlWin32::dispatchUpdate ( )

void vlWin32::translateKeyEvent | ( | WPARAM | wParam,
 |  | LPARAM | lParam,
 |  | unsigned short & | unicode_out,
 |  | vl::EKey & | key_out
 | ) |  |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: vlWX Namespace Reference

  • Namespace List
  • Namespace Members

vlWX Namespace Reference

The wxWidgets bindings namespace. More...

Classes

class vlWXGLCanvas
The vlWXGLCanvas class implements a vl::OpenGLContext using the wxWidgets library. More...

Detailed Description

The wxWidgets bindings namespace.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- a -

  • abs() : vl
  • acos() : vl
  • acosh() : vl
  • ActorCollection : vl
  • AlignBottom : vl
  • AlignHCenter : vl
  • AlignLeft : vl
  • AlignRight : vl
  • AlignTop : vl
  • AlignVCenter : vl
  • all() : vl
  • AlphaDepthSort : vl
  • AlwaysDepthSort : vl
  • any() : vl
  • AP_COLOR_ATTACHMENT0 : vl
  • AP_COLOR_ATTACHMENT1 : vl
  • AP_COLOR_ATTACHMENT10 : vl
  • AP_COLOR_ATTACHMENT11 : vl
  • AP_COLOR_ATTACHMENT12 : vl
  • AP_COLOR_ATTACHMENT13 : vl
  • AP_COLOR_ATTACHMENT14 : vl
  • AP_COLOR_ATTACHMENT15 : vl
  • AP_COLOR_ATTACHMENT2 : vl
  • AP_COLOR_ATTACHMENT3 : vl
  • AP_COLOR_ATTACHMENT4 : vl
  • AP_COLOR_ATTACHMENT5 : vl
  • AP_COLOR_ATTACHMENT6 : vl
  • AP_COLOR_ATTACHMENT7 : vl
  • AP_COLOR_ATTACHMENT8 : vl
  • AP_COLOR_ATTACHMENT9 : vl
  • AP_DEPTH_ATTACHMENT : vl
  • AP_NO_ATTACHMENT : vl
  • AP_STENCIL_ATTACHMENT : vl
  • ArrayBVec2 : vl
  • ArrayBVec3 : vl
  • ArrayBVec4 : vl
  • ArrayByte : vl
  • ArrayDouble : vl
  • ArrayDVec2 : vl
  • ArrayDVec3 : vl
  • ArrayDVec4 : vl
  • ArrayFloat : vl
  • ArrayFVec2 : vl
  • ArrayFVec3 : vl
  • ArrayFVec4 : vl
  • ArrayInt : vl
  • ArrayIVec2 : vl
  • ArrayIVec3 : vl
  • ArrayIVec4 : vl
  • ArrayShort : vl
  • ArraySVec2 : vl
  • ArraySVec3 : vl
  • ArraySVec4 : vl
  • ArrayUBVec2 : vl
  • ArrayUBVec3 : vl
  • ArrayUBVec4 : vl
  • ArrayUByte : vl
  • ArrayUInt : vl
  • ArrayUShort : vl
  • ArrayUSVec2 : vl
  • ArrayUSVec3 : vl
  • ArrayUSVec4 : vl
  • ArrayUVec2 : vl
  • ArrayUVec3 : vl
  • ArrayUVec4 : vl
  • asin() : vl
  • asinh() : vl
  • assemble3DImage() : vl
  • AT_Actinium : vlMolecule
  • AT_Aluminium : vlMolecule
  • AT_Americium : vlMolecule
  • AT_Antimony : vlMolecule
  • AT_Argon : vlMolecule
  • AT_Arsenic : vlMolecule
  • AT_Astatine : vlMolecule
  • AT_Barium : vlMolecule
  • AT_Berkelium : vlMolecule
  • AT_Beryllium : vlMolecule
  • AT_Bismuth : vlMolecule
  • AT_Bohrium : vlMolecule
  • AT_Boron : vlMolecule
  • AT_Bromine : vlMolecule
  • AT_Cadmium : vlMolecule
  • AT_Caesium : vlMolecule
  • AT_Calcium : vlMolecule
  • AT_Californium : vlMolecule
  • AT_Carbon : vlMolecule
  • AT_Cerium : vlMolecule
  • AT_Chlorine : vlMolecule
  • AT_Chromium : vlMolecule
  • AT_Cobalt : vlMolecule
  • AT_Copper : vlMolecule
  • AT_Count : vlMolecule
  • AT_Curium : vlMolecule
  • AT_Darmstadtium : vlMolecule
  • AT_Dubnium : vlMolecule
  • AT_Dysprosium : vlMolecule
  • AT_Einsteinium : vlMolecule
  • AT_Erbium : vlMolecule
  • AT_Europium : vlMolecule
  • AT_Fermium : vlMolecule
  • AT_Fluorine : vlMolecule
  • AT_Francium : vlMolecule
  • AT_Gadolinium : vlMolecule
  • AT_Gallium : vlMolecule
  • AT_Germanium : vlMolecule
  • AT_Gold : vlMolecule
  • AT_Hafnium : vlMolecule
  • AT_Hassium : vlMolecule
  • AT_Helium : vlMolecule
  • AT_Holmium : vlMolecule
  • AT_Hydrogen : vlMolecule
  • AT_Indium : vlMolecule
  • AT_Iodine : vlMolecule
  • AT_Iridium : vlMolecule
  • AT_Iron : vlMolecule
  • AT_Krypton : vlMolecule
  • AT_Lanthanum : vlMolecule
  • AT_Lawrencium : vlMolecule
  • AT_Lead : vlMolecule
  • AT_Lithium : vlMolecule
  • AT_Lutetium : vlMolecule
  • AT_Magnesium : vlMolecule
  • AT_Manganese : vlMolecule
  • AT_Meitnerium : vlMolecule
  • AT_Mendelevium : vlMolecule
  • AT_Mercury : vlMolecule
  • AT_Molybdenum : vlMolecule
  • AT_Neodymium : vlMolecule
  • AT_Neon : vlMolecule
  • AT_Neptunium : vlMolecule
  • AT_Nickel : vlMolecule
  • AT_Niobium : vlMolecule
  • AT_Nitrogen : vlMolecule
  • AT_Nobelium : vlMolecule
  • AT_Osmium : vlMolecule
  • AT_Oxygen : vlMolecule
  • AT_Palladium : vlMolecule
  • AT_Phosphorus : vlMolecule
  • AT_Platinum : vlMolecule
  • AT_Plutonium : vlMolecule
  • AT_Polonium : vlMolecule
  • AT_Potassium : vlMolecule
  • AT_Praseodymium : vlMolecule
  • AT_Promethium : vlMolecule
  • AT_Protactinium : vlMolecule
  • AT_Radium : vlMolecule
  • AT_Radon : vlMolecule
  • AT_Rhenium : vlMolecule
  • AT_Rhodium : vlMolecule
  • AT_Roentgenium : vlMolecule
  • AT_Rubidium : vlMolecule
  • AT_Ruthenium : vlMolecule
  • AT_Rutherfordium : vlMolecule
  • AT_Samarium : vlMolecule
  • AT_Scandium : vlMolecule
  • AT_Seaborgium : vlMolecule
  • AT_Selenium : vlMolecule
  • AT_Silicon : vlMolecule
  • AT_Silver : vlMolecule
  • AT_Sodium : vlMolecule
  • AT_Strontium : vlMolecule
  • AT_Sulfur : vlMolecule
  • AT_Tantalum : vlMolecule
  • AT_Technetium : vlMolecule
  • AT_Tellurium : vlMolecule
  • AT_Terbium : vlMolecule
  • AT_Thallium : vlMolecule
  • AT_Thorium : vlMolecule
  • AT_Thulium : vlMolecule
  • AT_Tin : vlMolecule
  • AT_Titanium : vlMolecule
  • AT_Tungsten : vlMolecule
  • AT_Unknown : vlMolecule
  • AT_Ununbium : vlMolecule
  • AT_Ununhexium : vlMolecule
  • AT_Ununoctium : vlMolecule
  • AT_Ununpentium : vlMolecule
  • AT_Ununquadium : vlMolecule
  • AT_Ununseptium : vlMolecule
  • AT_Ununtrium : vlMolecule
  • AT_Uranium : vlMolecule
  • AT_Vanadium : vlMolecule
  • AT_Xenon : vlMolecule
  • AT_Ytterbium : vlMolecule
  • AT_Yttrium : vlMolecule
  • AT_Zinc : vlMolecule
  • AT_Zirconium : vlMolecule
  • atan() : vl
  • atanh() : vl
  • atexit_visualization_library_shutdown() : vlGLUT
  • atomInfo() : vlMolecule
  • atomType() : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: File Index

  • File List
  • File Members

File List

Here is a list of all files with brief descriptions:
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Array.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BlitFramebuffer.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Buffer.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BufferedStream.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/checks.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Clear.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ClipPlane.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Collection.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/config.hpp | Visualization Library configuration file
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CRC32CheckSum.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DepthSortCallback.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DistanceLODEvaluator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawArrays.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawElements.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeUpdateCallback.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Frustum.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GeometryLoadCallback.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLBufferObject.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSLmath.hpp | Implements the OpenGL Shading Language convenience functions for scalar and vector operations
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image_Tools.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LODEvaluator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix2.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix3.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix4.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Primitives.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Ray.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ReadPixels.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderable.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingCallback.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueue.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderState.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderToken.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceDatabase.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceLoadWriter.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorTree.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerBVH.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Scissor.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ShaderNode.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Sphere.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String_Tables.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TextStream.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/UIEventListener.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Uniform.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector2.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector3.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector4.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/version.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VertexAttributeArray.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlnamespace.hpp | Visualization Library's enums in the 'vl' namespace
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/StdAfx.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Atom.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Bond.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule_rendering.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/RingExtractor.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/vlMOL2.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Colors.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/SceneManagerVectorGraphics.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/VectorGraphics.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.hpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.cpp |
E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.hpp |
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.cpp File Reference

#include "vl/AABB.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/AABB.hpp File Reference

#include "vl/Vector3.hpp"
#include "vl/Matrix4.hpp"

Classes

class | vl::AABB
The AABB class implements an axis-aligned bounding box using vl::Real precision. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.cpp File Reference

#include "vl/Actor.hpp"
#include "vl/Effect.hpp"
#include "vl/Camera.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Actor.hpp File Reference

#include "vl/Renderable.hpp"
#include "vl/LODEvaluator.hpp"
#include "vl/Uniform.hpp"
#include "vl/Effect.hpp"
#include "vl/Collection.hpp"
#include "vl/Scissor.hpp"

Classes

class | vl::ActorRenderingCallback
The ActorRenderingCallback class defines a callback object to be executed just before an Actor is rendered but after the render states are setup. More...
class | vl::Actor
Associates a Renderable object to an Effect and Transform. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Collection< Actor > | vl::ActorCollection
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.cpp File Reference

#include "vl/ActorKdTree.hpp"
#include "vl/Log.hpp"
#include <algorithm>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorKdTree.hpp File Reference

#include "vl/AABB.hpp"
#include "vl/Actor.hpp"
#include "vl/math3D.hpp"
#include "vl/Plane.hpp"
#include "vl/Collection.hpp"
#include "vl/ActorTreeAbstract.hpp"

Classes

class | vl::ActorKdTree
ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.cpp File Reference

#include "vl/ActorTree.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTree.hpp File Reference

#include "vl/ActorTreeAbstract.hpp"

Classes

class | vl::ActorTree
The ActorTree class implements a generic tree whose nodes contain Actor[s]. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.cpp File Reference

#include "vl/ActorTreeAbstract.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ActorTreeAbstract.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/AABB.hpp"
#include <set>

Classes

class | vl::ActorTreeAbstract
The ActorTreeAbstract class implements the interface of a generic tree containing Actor[s] in its nodes. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Array.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Array.hpp File Reference

#include "vl/GLBufferObject.hpp"

Classes

class | vl::ArrayAbstract
The ArrayAbstract class defines an abstract interface to conveniently manipulate data stored in a GLBufferObject. More...
class | vl::Array< vector_type, scalar_type, gl_size, gl_type >
The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Array< GLfloat,
GLfloat, 1, GL_FLOAT > 		vl::ArrayFloat
An array of GLfloat.
typedef Array< fvec2, GLfloat,
2, GL_FLOAT > 		vl::ArrayFVec2
An array of vl::fvec2.
typedef Array< fvec3, GLfloat,
3, GL_FLOAT > 		vl::ArrayFVec3
An array of vl::fvec3.
typedef Array< fvec4, GLfloat,
4, GL_FLOAT > 		vl::ArrayFVec4
An array of vl::fvec4.
typedef Array< GLdouble,
GLdouble, 1, GL_DOUBLE > 		vl::ArrayDouble
An array of GLdouble.
typedef Array< dvec2, GLdouble,
2, GL_DOUBLE > 		vl::ArrayDVec2
An array of vl::dvec2.
typedef Array< dvec3, GLdouble,
3, GL_DOUBLE > 		vl::ArrayDVec3
An array of vl::dvec3.
typedef Array< dvec4, GLdouble,
4, GL_DOUBLE > 		vl::ArrayDVec4
An array of vl::dvec4.
typedef Array< GLint, GLint,
1, GL_INT > 		vl::ArrayInt
An array of GLint.
typedef Array< ivec2, GLint,
2, GL_INT > 		vl::ArrayIVec2
An array of vl::ivec2.
typedef Array< ivec3, GLint,
3, GL_INT > 		vl::ArrayIVec3
An array of vl::ivec3.
typedef Array< ivec4, GLint,
4, GL_INT > 		vl::ArrayIVec4
An array of vl::ivec4.
typedef Array< GLuint, GLuint,
1, GL_UNSIGNED_INT > 		vl::ArrayUInt
An array of GLuint.
typedef Array< uvec2, GLuint,
2, GL_UNSIGNED_INT > 		vl::ArrayUVec2
An array of vl::uvec2.
typedef Array< uvec3, GLuint,
3, GL_UNSIGNED_INT > 		vl::ArrayUVec3
An array of vl::uvec3.
typedef Array< uvec4, GLuint,
4, GL_UNSIGNED_INT > 		vl::ArrayUVec4
An array of vl::uvec4.
typedef Array< GLbyte, GLbyte,
1, GL_BYTE > 		vl::ArrayByte
An array of GLbyte.
typedef Array< bvec2, GLbyte,
2, GL_BYTE > 		vl::ArrayBVec2
An array of vl::bvec2.
typedef Array< bvec3, GLbyte,
3, GL_BYTE > 		vl::ArrayBVec3
An array of vl::bvec3.
typedef Array< bvec4, GLbyte,
4, GL_BYTE > 		vl::ArrayBVec4
An array of vl::bvec4.
typedef Array< GLubyte,
GLubyte, 1, GL_UNSIGNED_BYTE > 		vl::ArrayUByte
An array of GLubyte.
typedef Array< ubvec2, GLubyte,
2, GL_UNSIGNED_BYTE > 		vl::ArrayUBVec2
An array of vl::ubvec2.
typedef Array< ubvec3, GLubyte,
3, GL_UNSIGNED_BYTE > 		vl::ArrayUBVec3
An array of vl::ubvec3.
typedef Array< ubvec4, GLubyte,
4, GL_UNSIGNED_BYTE > 		vl::ArrayUBVec4
An array of vl::ubvec4.
typedef Array< GLshort,
GLshort, 1, GL_SHORT > 		vl::ArrayShort
An array of GLshort.
typedef Array< svec2, GLshort,
2, GL_SHORT > 		vl::ArraySVec2
An array of vl::svec2.
typedef Array< svec3, GLshort,
3, GL_SHORT > 		vl::ArraySVec3
An array of vl::svec3.
typedef Array< svec4, GLshort,
4, GL_SHORT > 		vl::ArraySVec4
An array of vl::svec4.
typedef Array< GLushort,
GLushort, 1, GL_UNSIGNED_SHORT > 		vl::ArrayUShort
An array of GLushort.
typedef Array< usvec2,
GLushort, 2, GL_UNSIGNED_SHORT > 		vl::ArrayUSVec2
An array of vl::usvec2.
typedef Array< usvec3,
GLushort, 3, GL_UNSIGNED_SHORT > 		vl::ArrayUSVec3
An array of vl::usvec3.
typedef Array< usvec4,
GLushort, 4, GL_UNSIGNED_SHORT > 		vl::ArrayUSVec4
An array of vl::usvec4.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.cpp File Reference

#include "vl/BezierSurface.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BezierSurface.hpp File Reference

#include "vl/Geometry.hpp"

Classes

class | vl::BezierPatch
Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class. More...
class | vl::BezierSurface
The BezierSurface class implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch). More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.cpp File Reference

#include "vl/Billboard.hpp"
#include "vl/Camera.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Billboard.hpp File Reference

#include "vl/Transform.hpp"

Classes

class | vl::Billboard
A Transform that aligns an Actor towards the camera. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BlitFramebuffer.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BlitFramebuffer.hpp File Reference

#include "vl/RenderingCallback.hpp"
#include "vl/FramebufferObject.hpp"

Classes

class | vl::BlitFramebuffer
A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Buffer.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Buffer.hpp File Reference

#include "vl/Object.hpp"
#include <string.h>

Classes

class | vl::Buffer
Implements a buffer whose storage is in local memory. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BufferedStream.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/BufferedStream.hpp File Reference

#include "vl/String.hpp"
#include "vl/VirtualFile.hpp"
#include <string>
#include <vector>

Classes

class | vl::BufferedStream< Element_Type, Chunk_Size >
The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.cpp File Reference

#include "vl/Camera.hpp"
#include "vl/OpenGL.hpp"
#include "vl/AABB.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/RenderingCallback.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Camera.hpp File Reference

#include "vl/checks.hpp"
#include "vl/math3D.hpp"
#include "vl/Vector4.hpp"
#include "vl/RenderTarget.hpp"
#include "vl/Viewport.hpp"
#include "vl/Frustum.hpp"
#include "vl/Ray.hpp"

Classes

class | vl::Camera
Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CatmullRomInterpolator.hpp File Reference

#include "vl/Interpolator.hpp"

Classes

class | vl::CatmullRomInterpolator< T >
The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation. More...
class | vl::CatmullRomInterpolatorFVec4
Interpolates vl::fvec4 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorFVec3
Interpolates vl::fvec3 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorFVec2
Interpolates vl::fvec2 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorFloat
Interpolates float values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorDVec4
Interpolates vl::dvec4 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorDVec3
Interpolates vl::dvec3 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorDVec2
Interpolates vl::dvec2 values using a CatmullRomInterpolator. More...
class | vl::CatmullRomInterpolatorDouble
Interpolates double values using a CatmullRomInterpolator. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef CatmullRomInterpolator
< float > 		vl::CatmullRomInterpolatorFloat_T
typedef CatmullRomInterpolator
< vl::fvec2 > 		vl::CatmullRomInterpolatorFVec2_T
typedef CatmullRomInterpolator
< vl::fvec3 > 		vl::CatmullRomInterpolatorFVec3_T
typedef CatmullRomInterpolator
< vl::fvec4 > 		vl::CatmullRomInterpolatorFVec4_T
typedef CatmullRomInterpolator
< double > 		vl::CatmullRomInterpolatorDouble_T
typedef CatmullRomInterpolator
< vl::dvec2 > 		vl::CatmullRomInterpolatorDVec2_T
typedef CatmullRomInterpolator
< vl::dvec3 > 		vl::CatmullRomInterpolatorDVec3_T
typedef CatmullRomInterpolator
< vl::dvec4 > 		vl::CatmullRomInterpolatorDVec4_T
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/checks.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/checks.hpp File Reference

#include "vl/config.hpp"

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | VL_TRAP() {}
#define | VL_CHECK(expr) { if(!(expr)) { ::vl::log_failed_check(#expr,__FILE__,__LINE__); VL_TRAP() } }
#define | VL_WARN(expr) { if(!(expr)) { ::vl::log_failed_check(#expr,__FILE__,__LINE__); } }

Functions

void | vl::log_failed_check (const char *, const char *, int)

Define Documentation

#define VL_TRAP ( ) {}

#define VL_CHECK ( expr ) { if(!(expr)) { ::vl::log_failed_check(#expr,__FILE__,__LINE__); VL_TRAP() } }

#define VL_WARN ( expr ) { if(!(expr)) { ::vl::log_failed_check(#expr,__FILE__,__LINE__); } }

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Clear.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Clear.hpp File Reference

#include "vl/Renderable.hpp"
#include "vl/Vector4.hpp"

Classes

class | vl::Clear
The Clear class is a Renderable used to clear the whole or a portion of the color, stencil or depth buffer. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ClipPlane.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ClipPlane.hpp File Reference

#include "vl/Plane.hpp"
#include "vl/Camera.hpp"
#include "vl/RenderState.hpp"

Classes

class | vl::ClipPlane
Wraps the OpenGL function glClipPlane(). More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Collection.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Collection.hpp File Reference

#include "vl/Object.hpp"
#include <vector>
#include <algorithm>

Classes

class | vl::Collection< T >
Reference counted container that encapsulates the base functionalites of an std::vector<>. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/config.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/config.hpp File Reference

Visualization Library configuration file. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | VL_MESSAGEBOX_CHECK 1
Only for Win32 platforms.
#define | VL_MAX_ACTOR_LOD 4
Defines the maximum number of LOD levels available to the Actor class.
#define | VL_MAX_EFFECT_LOD 4
Defines the maximum number of LOD levels available to the Effect class.
#define | VL_FORCE_CHECKS 0
Forces checks to be done also in non debug modes.
#define | VL_VERBOSITY_LEVEL 2
Verbosity level.
#define | VL_PIPELINE_PRECISION 2
This define is used to set Visualization Library's pipeline precision.
#define | VL_FAST_SQUARE_ROOTS 0
Enables fast square root computation when using single precision mode.
#define | VL_MAX_TEXTURE_UNIT_COUNT 16
Maximum number of texture units used.
#define | VL_STRING_COPY_ON_WRITE 1
Enable String copy-on-write mode.
#define | VL_DEFAULT_BUFFER_BYTE_ALIGNMENT 16
Default byte alignment for the vl::Buffer class.
#define | VL_MAX_TIMERS 16
Maximum timer index that can be passed to vl::Time::start(int index), vl::Time::stop(int index) etc.
#define | VL_DEBUG_LIVING_OBJECTS 0
Enable/disable memory leaks debugging.
#define | VL_glLoadMatrix glLoadMatrixd
Defined as glLoadMatrixd, used internally.
#define | VL_glMultMatrix glMultMatrixd
Defined as glMultMatrixd, used internally.

Typedefs

typedef double | vl::Real
Defined as 'typedef double Real'.

Detailed Description

Visualization Library configuration file.

Define Documentation

#define VL_MESSAGEBOX_CHECK 1

Only for Win32 platforms.

1 = opens a MessageBox on failed check
0 = opens a MessageBox on failed check

#define VL_MAX_ACTOR_LOD 4

Defines the maximum number of LOD levels available to the Actor class.

#define VL_MAX_EFFECT_LOD 4

Defines the maximum number of LOD levels available to the Effect class.

#define VL_FORCE_CHECKS 0

Forces checks to be done also in non debug modes.

if set to 1 the VL_CHECK() and VL_CHECK_OGL() macros will be active also in release mode builds if set to 0 the VL_CHECK() and VL_CHECK_OGL() macros will be active only in debug mode builds

#define VL_VERBOSITY_LEVEL 2

Verbosity level.

#define VL_PIPELINE_PRECISION 2

This define is used to set Visualization Library's pipeline precision.

  • 1 = use floating point single precision pipeline
  • 2 = use floating point double precision pipeline

In single precision mode the classes vec4, vec3, vec2, mat4, mat3, mat2 will be defined as typedefs to their fvec4, fmat4 etc. counter parts.

In double precision mode the classes vec4, vec3, vec2, mat4, mat3, mat2 will be defined as typedefs to their dvec4, dmat4 etc. counter parts.

In single precision mode vl::Real is defined as float, in double precision mode vl::Real is defined as double.

Other classes are affected as well, in particular vl::Transform, vl::quat, vl::AABB and vl::Sphere.

#define VL_FAST_SQUARE_ROOTS 0

Enables fast square root computation when using single precision mode.

  • 0 = disable fast square roots when in single precision floating point pipeline
  • 1 = enable fast square roots when in single precision floating point pipeline

Potential performance improvements:

  • float sqrt will be up to 1.4x quicker
  • float 1.0/sqrt will be up to 3x quicker
  • vec3 normalization will be up to 2x quicker

Please note that the precision of such operations is seriously affected. Use with care! Under some platforms / compiler configurations this might produce wrong results, like objects disappearing, transforms, matrices and vectors filled with garbage data etc.

#define VL_MAX_TEXTURE_UNIT_COUNT 16

Maximum number of texture units used.

  • minimum = 1
  • maximum = OpenGL implementation dependent

#define VL_STRING_COPY_ON_WRITE 1

Enable String copy-on-write mode.

  • 1 = vl::String copy on write feature enabled
  • 0 = vl::String copy on write feature disabled

#define VL_DEFAULT_BUFFER_BYTE_ALIGNMENT 16

Default byte alignment for the vl::Buffer class.

#define VL_MAX_TIMERS 16

Maximum timer index that can be passed to vl::Time::start(int index), vl::Time::stop(int index) etc.

#define VL_DEBUG_LIVING_OBJECTS 0

Enable/disable memory leaks debugging.

  • 0 = disable memory leaks debugging
  • 1 = Objects::mDebug_LivingObjects will contain the set of currently living Object-s.

This is useful when you want to track memory leaks and object construction/destruction.

#define VL_glLoadMatrix glLoadMatrixd

Defined as glLoadMatrixd, used internally.

#define VL_glMultMatrix glMultMatrixd

Defined as glMultMatrixd, used internally.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CopyTexSubImage.hpp File Reference

#include "vl/Camera.hpp"
#include "vl/Texture.hpp"

Classes

class | vl::CopyTexSubImage
Wrapper class of the OpenGL function glCopyTexSubImage. More...
class | vl::CopyTexSubImage1D
Wraps glCopyTexSubImage1D, see also CopyTexSubImage. More...
class | vl::CopyTexSubImage2D
Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures. More...
class | vl::CopyTexSubImage3D
Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CRC32CheckSum.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/CRC32CheckSum.hpp File Reference

#include "vl/VirtualFile.hpp"

Classes

class | vl::CRC32CheckSum
Computes the a CRC32 checksum of a given buffer or VirtualFile. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DepthSortCallback.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DepthSortCallback.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/Camera.hpp"

Classes

class | vl::DepthSortCallback
The DepthSortCallback class sorts the primitives of the Geometry object bound to the Actor in which the callback is installed. More...
class | vl::DepthSortCallback::Point< T >
class | vl::DepthSortCallback::Line< T >
class | vl::DepthSortCallback::Triangle< T >
class | vl::DepthSortCallback::Quad< T >
class | vl::DepthSortCallback::PrimitiveZ
class | vl::DepthSortCallback::Sorter_Back_To_Front
class | vl::DepthSortCallback::Sorter_Front_To_Back

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.cpp File Reference

#include "vl/DiskDirectory.hpp"
#include "vl/DiskFile.hpp"
#include <algorithm>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskDirectory.hpp File Reference

#include "vl/VirtualDirectory.hpp"

Classes

class | vl::DiskDirectory
A VirtualDirectory that operates on reguar disk directories. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.cpp File Reference

#include "vl/DiskFile.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DiskFile.hpp File Reference

#include "vl/VirtualFile.hpp"
#include "vl/DiskDirectory.hpp"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

Classes

class | vl::DiskFile
A VirtualFile that operates on regular disk files. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DistanceLODEvaluator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DistanceLODEvaluator.hpp File Reference

#include "vl/Actor.hpp"

Classes

class | vl::DistanceLODEvaluator
A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.cpp File Reference

#include "vl/DoubleVertexRemover.hpp"
#include "vl/Time.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DoubleVertexRemover.hpp File Reference

#include "vl/Geometry.hpp"
#include <vector>

Classes

class | vl::VertexMapper
Generates a set of new vertices from the old one. More...
class | vl::DoubleVertexRemover
Removes from a Geometry the vertices with the same attributes. More...
class | vl::DoubleVertexRemover::CompareVertex

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawArrays.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawArrays.hpp File Reference

#include "vl/Primitives.hpp"

Classes

class | vl::DrawArrays
Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawElements.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawElements.hpp File Reference

#include "vl/Primitives.hpp"
#include "vl/Array.hpp"
#include <algorithm>

Classes

class | vl::DrawElements< index_type, Tgltype, arr_type >
Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information. More...
class | vl::DrawElements< index_type, Tgltype, arr_type >::Triangle< T >

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef DrawElements< GLuint,
GL_UNSIGNED_INT, ArrayUInt > 		vl::DrawElementsUInt
A DrawElements using indices of type GLuint.
typedef DrawElements< GLushort,
GL_UNSIGNED_SHORT, ArrayUShort > 		vl::DrawElementsUShort
A DrawElements using indices of type GLushort.
typedef DrawElements< GLubyte,
GL_UNSIGNED_BYTE, ArrayUByte > 		vl::DrawElementsUByte
A DrawElements using indices of type GLubyte.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.cpp File Reference

#include "vl/DrawPixels.hpp"
#include "vl/Actor.hpp"
#include "vl/Renderer.hpp"
#include <map>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/DrawPixels.hpp File Reference

#include "vl/Renderable.hpp"
#include "vl/Collection.hpp"
#include "vl/Image.hpp"

Classes

class | vl::DrawPixels
Wraps the OpenGL function glDrawPixels(). More...
class | vl::DrawPixels::Pixels
Represents a bitmap to be drawn on the screen. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.cpp File Reference

#include "vl/EdgeExtractor.hpp"
#include "vl/Rendering.hpp"
#include "vl/SceneManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeExtractor.hpp File Reference

#include "vl/Geometry.hpp"
#include "vl/Renderer.hpp"
#include <vector>

Classes

class | vl::EdgeExtractor
The EdgeExtractor class extracts the edges from one or more Geometry objects. More...
class | vl::EdgeExtractor::Edge
A single edge as extracted from the EdgeExtractor class. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.cpp File Reference

#include "vl/EdgeRenderer.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeRenderer.hpp File Reference

#include "vl/Renderer.hpp"
#include "vl/EdgeExtractor.hpp"
#include "vl/EdgeUpdateCallback.hpp"

Classes

class | vl::EdgeRenderer
The EdgeRenderer class implements a special Renderer that automatically extracts and renders the edges of the objects in the scene. More...
class | vl::EdgeRenderer::WFInfo

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeUpdateCallback.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/EdgeUpdateCallback.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/EdgeExtractor.hpp"

Classes

class | vl::EdgeUpdateCallback
The EdgeUpdateCallback class updates at every frame the edges of an Actor for the purpose of edge-enhancement. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.cpp File Reference

#include "vl/Effect.hpp"
#include "vl/Renderable.hpp"
#include "vl/Camera.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Effect.hpp File Reference

#include "vl/Renderable.hpp"
#include "vl/LODEvaluator.hpp"
#include "vl/Shader.hpp"
#include "vl/Collection.hpp"
#include <vector>

Classes

class | vl::ShaderSequence
A sequence of Shader objects each of which represent a rendering pass. More...
class | vl::Effect
Defines the sequence of Shader objects used to render an Actor. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.cpp File Reference

#include "vl/Extrusion.hpp"
#include "vl/Tessellator.hpp"
#include "vl/GLSLmath.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Extrusion.hpp File Reference

#include "vl/Geometry.hpp"
#include "vl/Vector4.hpp"
#include "vl/Vector3.hpp"
#include "vl/Matrix4.hpp"
#include <vector>

Classes

class | vl::Extrusion
The Extrusion class generates a Geometry extruding a silhouette along a path. More...

Namespaces

namespace | vl
Visualization Library namespace.

Enumerations

enum | vl::ESilhouetteMode { vl::SilhouetteClosed, vl::SilhouetteOpen }
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.cpp File Reference

#include "vl/FileSystem.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FileSystem.hpp File Reference

#include "vl/VirtualDirectory.hpp"
#include "vl/DiskFile.hpp"
#include "vl/Collection.hpp"
#include <vector>

Classes

class | vl::FileSystem
Manages multiple VirtualDirectory objects. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.cpp File Reference

#include "vl/Font.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/FileSystem.hpp"
#include "vl/Image.hpp"
#include <ft2build.h>

Defines

#define | FT_ERRORDEF(e, v, s) { e, s },
#define | FT_ERROR_START_LIST {
#define | FT_ERROR_END_LIST { 0, 0 } };

Define Documentation

#define FT_ERRORDEF | ( | e,
 |  | v,
 |  | s | ) | { e, s },

#define FT_ERROR_START_LIST {

#define FT_ERROR_END_LIST { 0, 0 } };

Variable Documentation

int err_code

const char* err_msg

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Font.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Vector4.hpp"
#include "vl/String.hpp"
#include <map>

Classes

class | vl::Glyph
The Glyph associated to a character of a given Font. More...
class | vl::Font
A font to be used with a Text renderable. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef struct FT_FaceRec_ * | FT_Face

Variables

vl::Glyph vl::ft_errors []
The Glyph associated to a character of a given Font.

Typedef Documentation

typedef struct FT_FaceRec_* FT_Face

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.cpp File Reference

#include "vl/FontManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include <algorithm>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FontManager.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Text.hpp"

Classes

class | vl::FontManager
The FontManager class keeps a map associating a font path, size and smoothing flag to a Font object. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.cpp File Reference

#include "vl/VisualizationLibrary.hpp"
#include "vl/FramebufferObject.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/FramebufferObject.hpp File Reference

#include "vl/Camera.hpp"
#include "vl/Texture.hpp"
#include <set>
#include <map>

Classes

class | vl::FBOAttachmentAbstract
Abstract class that represents a framebuffer object attachment, i.e. More...
class | vl::FBORenderbufferAttachment
Abstract class that represents a framebuffer renderbuffer attachment, i.e. More...
class | vl::FBOColorBufferAttachment
A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBODepthBufferAttachment
A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOStencilBufferAttachment
A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBODepthStencilBufferAttachment
A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOTexture1DAttachment
A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOTexture2DAttachment
A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOTextureAttachment
A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOTexture3DAttachment
A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBOTextureLayerAttachment
A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget). More...
class | vl::FBORenderTarget
Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Frustum.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Frustum.hpp File Reference

#include "vl/Plane.hpp"
#include "vl/AABB.hpp"
#include "vl/Sphere.hpp"

Classes

class | vl::Frustum
A set of planes defining a frustum used for culling purposes (frustum culling). More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.cpp File Reference

#include "vl/Matrix4.hpp"
#include "vl/Geometry.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/Shader.hpp"
#include "vl/Renderer.hpp"
#include "vl/Time.hpp"
#include "vl/DoubleVertexRemover.hpp"
#include <cmath>

Functions

void func ()

Function Documentation

void func ( )

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Geometry.hpp File Reference

#include "vl/GLBufferObject.hpp"
#include "vl/Vector2.hpp"
#include "vl/Vector4.hpp"
#include "vl/Renderable.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vlut/Colors.hpp"
#include "vl/DrawElements.hpp"
#include "vl/DrawArrays.hpp"
#include "vl/Collection.hpp"
#include "vl/VertexAttributeArray.hpp"

Classes

class | vl::Geometry
The Geometry class is a Renderable that implements a polygonal mesh made of polygons, lines and points. More...
class | vl::Geometry::TextureArray

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GeometryLoadCallback.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GeometryLoadCallback.hpp File Reference

#include "vl/Geometry.hpp"
#include "vl/TriangleStripGenerator.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/DoubleVertexRemover.hpp"

Classes

class | vl::GeometryLoadCallback
Defines a set of actions to be executed to a Geometry as soon as it is loaded. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.cpp File Reference

#include "vl/GhostCameraManipulator.hpp"
#include "vl/Time.hpp"
#include "vl/Camera.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GhostCameraManipulator.hpp File Reference

#include "vl/OpenGLContext.hpp"

Classes

class | vl::GhostCameraManipulator
The GhostCameraManipulator class is an UIEventListener that controls the position and orientation of a Camera. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLBufferObject.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLBufferObject.hpp File Reference

#include "vl/Vector2.hpp"
#include "vl/Vector3.hpp"
#include "vl/Vector4.hpp"
#include "vl/Buffer.hpp"
#include "vl/OpenGL.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/Sphere.hpp"
#include "vl/AABB.hpp"

Classes

class | vl::GLBufferObject
The GLBufferObject class is a Buffer that can upload its data on the GPU memory. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.cpp File Reference

#include "vl/GLSL.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/Uniform.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/VirtualFile.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSL.hpp File Reference

#include "vl/Uniform.hpp"
#include "vl/GLSLmath.hpp"
#include "vl/Object.hpp"
#include "vl/RenderState.hpp"
#include "vl/String.hpp"

Classes

class | vl::GLSLShader
Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader. More...
class | vl::GLSLVertexShader
Wraps a GLSL vertex shader to be bound to a GLSL program. More...
class | vl::GLSLFragmentShader
Wraps a GLSL fragment shader to be bound to a GLSL program. More...
class | vl::GLSLGeometryShader
Wraps a GLSL geometry shader to be bound to a GLSL program. More...
class | vl::GLSLProgram
Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSLmath.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSLmath.hpp File Reference

Implements the OpenGL Shading Language convenience functions for scalar and vector operations. More...

#include <cmath>
#include <limits>
#include "vl/Vector4.hpp"
#include "vl/Matrix4.hpp"

Namespaces

namespace | vl
Visualization Library namespace.

Functions

float | vl::asinh (float x)
double | vl::asinh (double x)
float | vl::acosh (float x)
double | vl::acosh (double x)
float | vl::atanh (float x)
double | vl::atanh (double x)
template<typename T >
bool | vl::isnan (T value)
template<typename T >
bool | vl::isinf (T value)
template<typename T >
bool | vl::isinf_pos (T value)
template<typename T >
bool | vl::isinf_neg (T value)
float | vl::modf (float a, float &intpart)
double | vl::modf (double a, double &intpart)
float | vl::radians (float degrees)
fvec2 | vl::radians (const fvec2 &degrees)
fvec3 | vl::radians (const fvec3 &degrees)
fvec4 | vl::radians (const fvec4 &degrees)
double | vl::radians (double degrees)
float | vl::degrees (float radians)
fvec2 | vl::degrees (const fvec2 &radians)
fvec3 | vl::degrees (const fvec3 &radians)
fvec4 | vl::degrees (const fvec4 &radians)
double | vl::degrees (double radians)
float | vl::sin (float a)
fvec2 | vl::sin (const fvec2 &angle)
fvec3 | vl::sin (const fvec3 &angle)
fvec4 | vl::sin (const fvec4 &angle)
double | vl::sin (double a)
float | vl::cos (float a)
fvec2 | vl::cos (const fvec2 &angle)
fvec3 | vl::cos (const fvec3 &angle)
fvec4 | vl::cos (const fvec4 &angle)
double | vl::cos (double a)
float | vl::tan (float a)
fvec2 | vl::tan (const fvec2 &angle)
fvec3 | vl::tan (const fvec3 &angle)
fvec4 | vl::tan (const fvec4 &angle)
double | vl::tan (double a)
float | vl::asin (float a)
fvec2 | vl::asin (const fvec2 &angle)
fvec3 | vl::asin (const fvec3 &angle)
fvec4 | vl::asin (const fvec4 &angle)
double | vl::asin (double a)
float | vl::acos (float a)
fvec2 | vl::acos (const fvec2 &angle)
fvec3 | vl::acos (const fvec3 &angle)
fvec4 | vl::acos (const fvec4 &angle)
double | vl::acos (double a)
float | vl::atan (float a)
fvec2 | vl::atan (const fvec2 &a, const fvec2 &b)
fvec3 | vl::atan (const fvec3 &a, const fvec3 &b)
fvec4 | vl::atan (const fvec4 &a, const fvec4 &b)
double | vl::atan (double a)
float | vl::sinh (float a)
fvec2 | vl::sinh (const fvec2 &a)
fvec3 | vl::sinh (const fvec3 &a)
fvec4 | vl::sinh (const fvec4 &a)
double | vl::sinh (double a)
float | vl::cosh (float a)
fvec2 | vl::cosh (const fvec2 &a)
fvec3 | vl::cosh (const fvec3 &a)
fvec4 | vl::cosh (const fvec4 &a)
double | vl::cosh (double a)
float | vl::tanh (float a)
fvec2 | vl::tanh (const fvec2 &a)
fvec3 | vl::tanh (const fvec3 &a)
fvec4 | vl::tanh (const fvec4 &a)
double | vl::tanh (double a)
fvec2 | vl::asinh (const fvec2 &a)
fvec3 | vl::asinh (const fvec3 &a)
fvec4 | vl::asinh (const fvec4 &a)
fvec2 | vl::acosh (const fvec2 &a)
fvec3 | vl::acosh (const fvec3 &a)
fvec4 | vl::acosh (const fvec4 &a)
fvec2 | vl::atanh (const fvec2 &a)
fvec3 | vl::atanh (const fvec3 &a)
fvec4 | vl::atanh (const fvec4 &a)
float | vl::pow (float a, float b)
fvec2 | vl::pow (const fvec2 &a, const fvec2 &b)
fvec3 | vl::pow (const fvec3 &a, const fvec3 &b)
fvec4 | vl::pow (const fvec4 &a, const fvec4 &b)
double | vl::pow (double a, double b)
float | vl::exp (float a)
fvec2 | vl::exp (const fvec2 &a)
fvec3 | vl::exp (const fvec3 &a)
fvec4 | vl::exp (const fvec4 &a)
double | vl::exp (double a)
float | vl::log (float a)
fvec2 | vl::log (const fvec2 &a)
fvec3 | vl::log (const fvec3 &a)
fvec4 | vl::log (const fvec4 &a)
double | vl::log (double a)
float | vl::exp2 (float a)
fvec2 | vl::exp2 (const fvec2 &a)
fvec3 | vl::exp2 (const fvec3 &a)
fvec4 | vl::exp2 (const fvec4 &a)
double | vl::exp2 (double a)
float | vl::log2 (float a)
fvec2 | vl::log2 (const fvec2 &a)
fvec3 | vl::log2 (const fvec3 &a)
fvec4 | vl::log2 (const fvec4 &a)
double | vl::log2 (double a)
float | vl::log10 (float a)
fvec2 | vl::log10 (const fvec2 &a)
fvec3 | vl::log10 (const fvec3 &a)
fvec4 | vl::log10 (const fvec4 &a)
double | vl::log10 (double a)
float | vl::sqrt (float a)
fvec2 | vl::sqrt (const fvec2 &a)
fvec3 | vl::sqrt (const fvec3 &a)
fvec4 | vl::sqrt (const fvec4 &a)
double | vl::sqrt (double a)
float | vl::inversesqrt (float a)
fvec2 | vl::inversesqrt (const fvec2 &a)
fvec3 | vl::inversesqrt (const fvec3 &a)
fvec4 | vl::inversesqrt (const fvec4 &a)
double | vl::inversesqrt (double a)
float | vl::abs (float a)
fvec2 | vl::abs (const fvec2 &a)
fvec3 | vl::abs (const fvec3 &a)
fvec4 | vl::abs (const fvec4 &a)
double | vl::abs (double a)
int | vl::abs (int a)
float | vl::sign (float a)
fvec2 | vl::sign (const fvec2 &a)
fvec3 | vl::sign (const fvec3 &a)
fvec4 | vl::sign (const fvec4 &a)
double | vl::sign (double a)
int | vl::sign (int a)
float | vl::floor (float a)
fvec2 | vl::floor (const fvec2 &a)
fvec3 | vl::floor (const fvec3 &a)
fvec4 | vl::floor (const fvec4 &a)
double | vl::floor (double a)
float | vl::fract (float)
float | vl::trunc (float a)
fvec2 | vl::trunc (const fvec2 &a)
fvec3 | vl::trunc (const fvec3 &a)
fvec4 | vl::trunc (const fvec4 &a)
double | vl::fract (double)
double | vl::trunc (double a)
float | vl::round (float x)
fvec2 | vl::round (const fvec2 &a)
fvec3 | vl::round (const fvec3 &a)
fvec4 | vl::round (const fvec4 &a)
double | vl::round (double x)
float | vl::roundEven (float a, float epsilon=0.00001f)
fvec2 | vl::roundEven (const fvec2 &a, float epsilon=0.00001f)
fvec3 | vl::roundEven (const fvec3 &a, float epsilon=0.00001f)
fvec4 | vl::roundEven (const fvec4 &a, float epsilon=0.00001f)
double | vl::roundEven (double a, double epsilon=0.00001)
dvec2 | vl::roundEven (const dvec2 &a, double epsilon=0.00001)
dvec3 | vl::roundEven (const dvec3 &a, double epsilon=0.00001)
dvec4 | vl::roundEven (const dvec4 &a, double epsilon=0.00001)
float | vl::ceil (float a)
fvec2 | vl::ceil (const fvec2 &a)
fvec3 | vl::ceil (const fvec3 &a)
fvec4 | vl::ceil (const fvec4 &a)
double | vl::ceil (double a)
fvec2 | vl::fract (const fvec2 &a)
fvec3 | vl::fract (const fvec3 &a)
fvec4 | vl::fract (const fvec4 &a)
float | vl::mod (float a, float b)
fvec2 | vl::mod (const fvec2 &a, float b)
fvec3 | vl::mod (const fvec3 &a, float b)
fvec4 | vl::mod (const fvec4 &a, float b)
fvec2 | vl::mod (const fvec2 &a, const fvec2 &b)
fvec3 | vl::mod (const fvec3 &a, const fvec3 &b)
fvec4 | vl::mod (const fvec4 &a, const fvec4 &b)
double | vl::mod (double a, double b)
dvec2 | vl::mod (const dvec2 &a, double b)
dvec3 | vl::mod (const dvec3 &a, double b)
dvec4 | vl::mod (const dvec4 &a, double b)
fvec2 | vl::modf (const fvec2 &a, fvec2 &intpart)
fvec3 | vl::modf (const fvec3 &a, fvec3 &intpart)
fvec4 | vl::modf (const fvec4 &a, fvec4 &intpart)
float | vl::min (float a, float b)
fvec2 | vl::min (const fvec2 &a, const fvec2 &b)
fvec3 | vl::min (const fvec3 &a, const fvec3 &b)
fvec4 | vl::min (const fvec4 &a, const fvec4 &b)
fvec2 | vl::min (const fvec2 &a, float b)
fvec3 | vl::min (const fvec3 &a, float b)
fvec4 | vl::min (const fvec4 &a, float b)
double | vl::min (double a, double b)
dvec2 | vl::min (const dvec2 &a, double b)
dvec3 | vl::min (const dvec3 &a, double b)
dvec4 | vl::min (const dvec4 &a, double b)
int | vl::min (int a, int b)
ivec2 | vl::min (const ivec2 &a, int b)
ivec3 | vl::min (const ivec3 &a, int b)
ivec4 | vl::min (const ivec4 &a, int b)
unsigned int | vl::min (unsigned int a, unsigned int b)
uvec2 | vl::min (const uvec2 &a, unsigned int b)
uvec3 | vl::min (const uvec3 &a, unsigned int b)
uvec4 | vl::min (const uvec4 &a, unsigned int b)
float | vl::max (float a, float b)
fvec2 | vl::max (const fvec2 &a, const fvec2 &b)
fvec3 | vl::max (const fvec3 &a, const fvec3 &b)
fvec4 | vl::max (const fvec4 &a, const fvec4 &b)
fvec2 | vl::max (const fvec2 &a, float b)
fvec3 | vl::max (const fvec3 &a, float b)
fvec4 | vl::max (const fvec4 &a, float b)
double | vl::max (double a, double b)
dvec2 | vl::max (const dvec2 &a, double b)
dvec3 | vl::max (const dvec3 &a, double b)
dvec4 | vl::max (const dvec4 &a, double b)
int | vl::max (int a, int b)
ivec2 | vl::max (const ivec2 &a, int b)
ivec3 | vl::max (const ivec3 &a, int b)
ivec4 | vl::max (const ivec4 &a, int b)
unsigned int | vl::max (unsigned int a, unsigned int b)
uvec2 | vl::max (const uvec2 &a, unsigned int b)
uvec3 | vl::max (const uvec3 &a, unsigned int b)
uvec4 | vl::max (const uvec4 &a, unsigned int b)
float | vl::clamp (float x, float minval, float maxval)
fvec2 | vl::clamp (const fvec2 &x, float minval, float maxval)
fvec3 | vl::clamp (const fvec3 &x, float minval, float maxval)
fvec4 | vl::clamp (const fvec4 &x, float minval, float maxval)
fvec2 | vl::clamp (const fvec2 &x, const fvec2 &minval, const fvec2 &maxval)
fvec3 | vl::clamp (const fvec3 &x, const fvec3 &minval, const fvec3 &maxval)
fvec4 | vl::clamp (const fvec4 &x, const fvec4 &minval, const fvec4 &maxval)
double | vl::clamp (double x, double minval, double maxval)
dvec2 | vl::clamp (const dvec2 &x, double minval, double maxval)
dvec3 | vl::clamp (const dvec3 &x, double minval, double maxval)
dvec4 | vl::clamp (const dvec4 &x, double minval, double maxval)
int | vl::clamp (int x, int minval, int maxval)
ivec2 | vl::clamp (const ivec2 &x, int minval, int maxval)
ivec3 | vl::clamp (const ivec3 &x, int minval, int maxval)
ivec4 | vl::clamp (const ivec4 &x, int minval, int maxval)
unsigned int | vl::clamp (unsigned int x, unsigned int minval, unsigned int maxval)
uvec2 | vl::clamp (const uvec2 &x, unsigned int minval, unsigned int maxval)
uvec3 | vl::clamp (const uvec3 &x, unsigned int minval, unsigned int maxval)
uvec4 | vl::clamp (const uvec4 &x, unsigned int minval, unsigned int maxval)
float | vl::mix (float a, float b, float t)
fvec2 | vl::mix (const fvec2 &a, const fvec2 &b, float t)
fvec3 | vl::mix (const fvec3 &a, const fvec3 &b, float t)
fvec4 | vl::mix (const fvec4 &a, const fvec4 &b, float t)
fvec2 | vl::mix (const fvec2 &a, const fvec2 &b, const fvec2 &t)
fvec3 | vl::mix (const fvec3 &a, const fvec3 &b, const fvec3 &t)
fvec4 | vl::mix (const fvec4 &a, const fvec4 &b, const fvec4 &t)
double | vl::mix (double a, double b, double t)
dvec2 | vl::mix (const dvec2 &a, const dvec2 &b, double t)
dvec3 | vl::mix (const dvec3 &a, const dvec3 &b, double t)
dvec4 | vl::mix (const dvec4 &a, const dvec4 &b, double t)
float | vl::step (float edge, float a)
fvec2 | vl::step (const fvec2 &edge, const fvec2 &a)
fvec3 | vl::step (const fvec3 &edge, const fvec3 &a)
fvec4 | vl::step (const fvec4 &edge, const fvec4 &a)
double | vl::step (double edge, double a)
float | vl::smoothstep (float edge0, float edge1, float a)
fvec2 | vl::smoothstep (const fvec2 &edge0, const fvec2 &edge1, const fvec2 &a)
fvec3 | vl::smoothstep (const fvec3 &edge0, const fvec3 &edge1, const fvec3 &a)
fvec4 | vl::smoothstep (const fvec4 &edge0, const fvec4 &edge1, const fvec4 &a)
double | vl::smoothstep (double edge0, double edge1, double a)
ivec2 | vl::isnan (const fvec2 &a)
ivec3 | vl::isnan (const fvec3 &a)
ivec4 | vl::isnan (const fvec4 &a)
ivec2 | vl::isinf (const fvec2 &a)
ivec3 | vl::isinf (const fvec3 &a)
ivec4 | vl::isinf (const fvec4 &a)
float | vl::length (float v)
float | vl::length (const fvec2 &v)
float | vl::length (const fvec3 &v)
float | vl::length (const fvec4 &v)
double | vl::length (double v)
float | vl::length (int v)
float | vl::length (unsigned int v)
float | vl::distance (float p0, float p1)
float | vl::distance (const fvec2 &p0, const fvec2 &p1)
float | vl::distance (const fvec3 &p0, const fvec3 &p1)
float | vl::distance (const fvec4 &p0, const fvec4 &p1)
double | vl::distance (double p0, double p1)
float | vl::distance (int p0, int p1)
float | vl::distance (unsigned int p0, unsigned int p1)
float | vl::dot (float a, float b)
float | vl::dot (const fvec2 &v1, const fvec2 &v2)
float | vl::dot (const fvec3 &v1, const fvec3 &v2)
float | vl::dot (const fvec4 &v1, const fvec4 &v2)
double | vl::dot (double a, double b)
float | vl::dot (int a, int b)
float | vl::dot (unsigned int a, unsigned int b)
fvec3 | vl::cross (const fvec3 &v1, const fvec3 &v2)
float | vl::normalize (float)
fvec2 | vl::normalize (const fvec2 &v)
fvec3 | vl::normalize (const fvec3 &v)
fvec4 | vl::normalize (const fvec4 &v)
double | vl::normalize (double)
float | vl::faceforward (float N, float I, float Nref)
fvec2 | vl::faceforward (const fvec2 &N, const fvec2 &I, const fvec2 &Nref)
fvec3 | vl::faceforward (const fvec3 &N, const fvec3 &I, const fvec3 &Nref)
fvec4 | vl::faceforward (const fvec4 &N, const fvec4 &I, const fvec4 &Nref)
double | vl::faceforward (double N, double I, double Nref)
float | vl::reflect (float I, float N)
fvec2 | vl::reflect (const fvec2 &I, const fvec2 &N)
fvec3 | vl::reflect (const fvec3 &I, const fvec3 &N)
fvec4 | vl::reflect (const fvec4 &I, const fvec4 &N)
double | vl::reflect (double I, double N)
float | vl::refract (float I, float N, float eta)
fvec2 | vl::refract (const fvec2 &I, const fvec2 &N, float eta)
fvec3 | vl::refract (const fvec3 &I, const fvec3 &N, float eta)
fvec4 | vl::refract (const fvec4 &I, const fvec4 &N, float eta)
double | vl::refract (double I, double N, double eta)
dvec2 | vl::refract (const dvec2 &I, const dvec2 &N, double eta)
dvec3 | vl::refract (const dvec3 &I, const dvec3 &N, double eta)
dvec4 | vl::refract (const dvec4 &I, const dvec4 &N, double eta)
fmat2 | vl::matrixCompMult (const fmat2 &a, const fmat2 &b)
fmat3 | vl::matrixCompMult (const fmat3 &a, const fmat3 &b)
fmat4 | vl::matrixCompMult (const fmat4 &a, const fmat4 &b)
fmat2 | vl::outerProduct (const fvec2 &a, const fvec2 &b)
fmat3 | vl::outerProduct (const fvec3 &a, const fvec3 &b)
fmat4 | vl::outerProduct (const fvec4 &a, const fvec4 &b)
fmat2 | vl::transpose (const fmat2 &a)
fmat3 | vl::transpose (const fmat3 &a)
fmat4 | vl::transpose (const fmat4 &a)
ivec4 | vl::lessThan (const fvec4 &a, const fvec4 &b)
ivec3 | vl::lessThan (const fvec3 &a, const fvec3 &b)
ivec2 | vl::lessThan (const fvec2 &a, const fvec2 &b)
ivec4 | vl::lessThanEqual (const fvec4 &a, const fvec4 &b)
ivec3 | vl::lessThanEqual (const fvec3 &a, const fvec3 &b)
ivec2 | vl::lessThanEqual (const fvec2 &a, const fvec2 &b)
ivec4 | vl::greaterThan (const fvec4 &a, const fvec4 &b)
ivec3 | vl::greaterThan (const fvec3 &a, const fvec3 &b)
ivec2 | vl::greaterThan (const fvec2 &a, const fvec2 &b)
ivec4 | vl::greaterThanEqual (const fvec4 &a, const fvec4 &b)
ivec3 | vl::greaterThanEqual (const fvec3 &a, const fvec3 &b)
ivec2 | vl::greaterThanEqual (const fvec2 &a, const fvec2 &b)
ivec4 | vl::equal (const fvec4 &a, const fvec4 &b)
ivec3 | vl::equal (const fvec3 &a, const fvec3 &b)
ivec2 | vl::equal (const fvec2 &a, const fvec2 &b)
ivec4 | vl::notEqual (const fvec4 &a, const fvec4 &b)
ivec3 | vl::notEqual (const fvec3 &a, const fvec3 &b)
ivec2 | vl::notEqual (const fvec2 &a, const fvec2 &b)
bool | vl::any (const ivec2 &a)
bool | vl::any (const ivec3 &a)
bool | vl::any (const ivec4 &a)
bool | vl::all (const ivec2 &a)
bool | vl::all (const ivec3 &a)
bool | vl::all (const ivec4 &a)

Detailed Description

Implements the OpenGL Shading Language convenience functions for scalar and vector operations.

This functions are particularly useful when you want to port C++ code to GLSL and vice versa, or when you want to quickly prototype in C++ an algorithm that will be ported later to GLSL.

Note that most of this functions take as arguments not only int, unsigned int, float and double variables but also their vector counterparts like fvec4, dvec4, ivec4, uvec4, fvec3, fvec2 etc. For example you can do the following:

// clamp a float value
float f = someValueFloat()
f = vl::clamp(f, 0.0f, 1.0f);

// clamp a vector value
vl::fvec4 v = someValueVec4();
v = vl::clamp(v, vl::fvec4(1,2,3,4), vl::fvec4(5,6,7,8));

// the same goes for functions like mix(), min(), max(), sin(), cos(), floor() etc!

This module also implements other convenience functions like isnan(), isinf(), isinf_pos(), isinf_neg().

The functions are divided in the following categories:

Angle and trigonometry functions
radians(), degrees(), sin(), cos(), tan(), asin(), acos(), atan()
Hyperbolic functions
sinh(), cosh(), tanh(), asinh(), acosh(), atanh()
Exponential functions
pow(), exp(), log(), exp2(), log2(), log10(), sqrt(), inversesqrt(),
Common functions
abs(), sign(), floor(), trunc(), round(), roundEven(), ceil(), fract(), mod(), modf(), min(), max(), clamp(), mix(), step(), smoothstep(), isnan(), isinf()
Geometric functions
length(), distance(), dot(), cross(), normalize(), faceforward(), reflect(), refract()
Matrix functions
matrixCompMult(), outerProduct(), transpose(),
Vector relational functions
lessThan(), lessThanEqual(), greaterThan(), greaterThanEqual(), equal(), notEqual(), any(), all(), not()
See also:
For more information please refer to the official OpenGL Shading Language manual and specifications. See also the official OpenGL & OpenGL Utility Specifications page.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.cpp File Reference

#include "vl/VisualizationLibrary.hpp"
#include "vl/GZipCodec.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include <zlib.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GZipCodec.hpp File Reference

#include <vl/VirtualFile.hpp>

Classes

class | vl::GZipCodec
The GZipCodec class is a VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.cpp File Reference

#include "vl/Image.hpp"
#include "vl/checks.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/GLSLmath.hpp"
#include "vl/ResourceDatabase.hpp"
#include "vl/LoadWriterManager.hpp"
#include <map>
#include <cmath>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image.hpp File Reference

#include "vl/String.hpp"
#include "vl/GLBufferObject.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/Rect.hpp"
#include "vl/KeyValues.hpp"
#include <vector>

Classes

class | vl::Image
Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

ref< Image > | vl::loadCubemap (const String &xp_file, const String &xn_file, const String &yp_file, const String &yn_file, const String &zp_file, const String &zn_file)
Loads six images and assembles them into a cubemap image.
ref< Image > | vl::loadRAW (VirtualFile *file, int width, int height, int depth, int bytealign, EImageFormat format, EImageType type)
Loads a raw image file.
ref< Image > | vl::loadImage (VirtualFile *file)
Loads an image from the specified file.
ref< Image > | vl::loadImage (const String &path)
Loads an image from the specified path.
bool | vl::loadImagesFromDir (const String &dir_path, const String &ext, std::vector< ref< Image > > &images)
Loads all the images with the specified extension from the given directory.
ref< Image > | vl::assemble3DImage (const std::vector< ref< Image > > &images)
Assembles the given 2D images in a single 2D image, all the images must be 2D images and have the same size, format() and type().
bool | vl::saveImage (Image *img, VirtualFile *file)
Writes an image on the specified file.
bool | vl::saveImage (Image *img, const String &path)
Writes an image on the specified path.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image_Tools.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Image_Tools.cpp File Reference

#include "vl/VirtualFile.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Interpolator.hpp File Reference

#include "vl/Object.hpp"
#include "vl/GLSLmath.hpp"
#include "vl/Vector4.hpp"
#include <vector>

Classes

class | vl::Interpolator
Abstract class for all the interpolators. More...
class | vl::InterpolatorFVec4
Abstract class that interpolates vl::fvec4 values. More...
class | vl::InterpolatorFVec3
Abstract class that interpolates vl::fvec3 values. More...
class | vl::InterpolatorFVec2
Abstract class that interpolates vl::fvec2 values. More...
class | vl::InterpolatorFloat
Abstract class that interpolates float values. More...
class | vl::InterpolatorDVec4
Abstract class that interpolates vl::dvec4 values. More...
class | vl::InterpolatorDVec3
Abstract class that interpolates vl::dvec3 values. More...
class | vl::InterpolatorDVec2
Abstract class that interpolates vl::dvec2 values. More...
class | vl::InterpolatorDouble
Abstract class that interpolates double values. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.cpp File Reference

#include "vl/KeyValues.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/KeyValues.hpp File Reference

#include "vl/Object.hpp"
#include "vl/String.hpp"
#include <map>

Classes

class | vl::KeyValues
A set of key/value pairs used to store generic information. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.cpp File Reference

#include "vl/Light.hpp"
#include "vl/Transform.hpp"
#include "vl/Camera.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Light.hpp File Reference

#include "vl/Vector4.hpp"
#include "vl/Transform.hpp"
#include "vl/RenderState.hpp"

Classes

class | vl::Light
Wraps the OpenGL function glLight(). More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LinearInterpolator.hpp File Reference

#include "vl/Interpolator.hpp"

Classes

class | vl::LinearInterpolator< T >
The LinearInterpolator class is a template class that implements linear interpolation. More...
class | vl::LinearInterpolatorFVec4
Interpolates vl::fvec4 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorFVec3
Interpolates vl::fvec3 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorFVec2
Interpolates vl::fvec2 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorFloat
Interpolates float values using a LinearInterpolator. More...
class | vl::LinearInterpolatorDVec4
Interpolates vl::dvec4 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorDVec3
Interpolates vl::dvec3 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorDVec2
Interpolates vl::dvec2 values using a LinearInterpolator. More...
class | vl::LinearInterpolatorDouble
Interpolates double values using a LinearInterpolator. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef LinearInterpolator< float > | vl::LinearInterpolatorFloat_T
typedef LinearInterpolator
< vl::fvec2 > 		vl::LinearInterpolatorFVec2_T
typedef LinearInterpolator
< vl::fvec3 > 		vl::LinearInterpolatorFVec3_T
typedef LinearInterpolator
< vl::fvec4 > 		vl::LinearInterpolatorFVec4_T
typedef LinearInterpolator
< double > 		vl::LinearInterpolatorDouble_T
typedef LinearInterpolator
< vl::dvec2 > 		vl::LinearInterpolatorDVec2_T
typedef LinearInterpolator
< vl::dvec3 > 		vl::LinearInterpolatorDVec3_T
typedef LinearInterpolator
< vl::dvec4 > 		vl::LinearInterpolatorDVec4_T
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.cpp File Reference

#include "vl/Actor.hpp"
#include "vl/Primitives.hpp"
#include "vl/Geometry.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LoadWriterManager.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Collection.hpp"
#include "vl/MemoryFile.hpp"
#include "vl/VisualizationLibrary.hpp"

Classes

class | vl::LoadCallback
Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback. More...
class | vl::WriteCallback
Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback. More...
class | vl::LoadWriterManager
The LoadWriterManager class loads and writes resources using the registered ResourceLoadWriter objects. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LODEvaluator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/LODEvaluator.hpp File Reference

#include "vl/Object.hpp"

Classes

class | vl::LODEvaluator
Abstract class to compute the appropriate LOD of an Actor or Effect. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.cpp File Reference

#include "vl/Log.hpp"
#include "vl/checks.hpp"
#include "vl/VisualizationLibrary.hpp"
#include <cstdio>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Log.hpp File Reference

#include "vl/String.hpp"

Classes

class | vl::Log
The Log class is the abstract base class used to generate logging data. More...
class | vl::StandardLog
The StandardLog class outputs the log messages on the stdout device and optionally also on a specified file. More...

Namespaces

namespace | vl
Visualization Library namespace.

Enumerations

enum vl::ELogLevel {
vl::LogNormal, vl::LogDebug, vl::LogInfo, vl::LogWarning,
vl::LogError, vl::LogBug
}
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.cpp File Reference

#include "vl/math3D.hpp"
#include "vl/AABB.hpp"
#include "vl/Vector2.hpp"
#include "vl/Vector4.hpp"
#include "vl/quat.hpp"
#include "vl/Plane.hpp"
#include "vl/checks.hpp"
#include <cstdlib>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/math3D.hpp File Reference

#include "vl/GLSLmath.hpp"
#include "vl/Plane.hpp"
#include <cstdio>
#include <memory.h>
#include <vector>

Namespaces

namespace | vl
Visualization Library namespace.

Functions

Real | vl::randomMinMax (Real min, Real max)
Returns a random number N that between 'min' and 'max' included.
int | vl::greaterEqualPow2 (int n)
Returns a number N that is a power of 2 and that is equal to or greater than 'n'.
int | vl::smallerEqualPow2 (int n)
Returns a number N that is a power of 2 and that is equal to or smaller than 'n'.
void | vl::extractPlanes (Plane *planes, const mat4 &modelviewproj)
Extracts the 6 frustum planes for the given model-view-projection matrix.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix2.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix2.hpp File Reference

#include "vl/checks.hpp"
#include <cstring>

Classes

class | vl::Matrix2< scalar_type >
The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Matrix2< GLdouble > | vl::dmat2
A 2x2 matrix using GLdouble precision.
typedef Matrix2< GLfloat > | vl::fmat2
A 2x2 matrix using GLfloat precision.
typedef Matrix2< GLint > | vl::imat2
A 2x2 matrix using GLint precision.
typedef Matrix2< GLuint > | vl::umat2
A 2x2 matrix using GLuint precision.
typedef dmat2 | vl::mat2
Defined as: 'typedef dmat2 mat2'. See also VL_PIPELINE_PRECISION.

Functions

template<typename scalar_type >
Matrix2< scalar_type > | vl::operator* (const Matrix2< scalar_type > &m2, const Matrix2< scalar_type > &m1)
template<typename scalar_type >
Matrix2< scalar_type > | vl::operator+ (scalar_type d, const Matrix2< scalar_type > &m)
template<typename scalar_type >
Matrix2< scalar_type > | vl::operator* (scalar_type d, const Matrix2< scalar_type > &m)
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Matrix2< scalar_type > &m, const Vector2< scalar_type > &v)
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Vector2< scalar_type > &v, const Matrix2< scalar_type > &m)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix3.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix3.hpp File Reference

#include "vl/Vector3.hpp"
#include "vl/Matrix2.hpp"

Classes

class | vl::Matrix3< scalar_type >
The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Matrix3< GLdouble > | vl::dmat3
A 3x3 matrix using GLdouble precision.
typedef Matrix3< GLfloat > | vl::fmat3
A 3x3 matrix using GLfloat precision.
typedef Matrix3< GLint > | vl::imat3
A 3x3 matrix using GLint precision.
typedef Matrix3< GLuint > | vl::umat3
A 3x3 matrix using GLuint precision.
typedef dmat3 | vl::mat3
Defined as: 'typedef dmat3 mat3'. See also VL_PIPELINE_PRECISION.

Functions

template<typename scalar_type >
Matrix3< scalar_type > | vl::operator* (const Matrix3< scalar_type > &m2, const Matrix3< scalar_type > &m1)
template<typename scalar_type >
Matrix3< scalar_type > | vl::operator+ (scalar_type d, const Matrix3< scalar_type > &m)
template<typename scalar_type >
Matrix3< scalar_type > | vl::operator* (scalar_type d, const Matrix3< scalar_type > &m)
template<typename scalar_type >
Vector3< scalar_type > | vl::operator* (const Matrix3< scalar_type > &m, const Vector3< scalar_type > &v)
Post multiplication: matrix * column vector.
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Matrix3< scalar_type > &m, const Vector2< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector3<scalar_type> with the component z = 0.
template<typename scalar_type >
Vector3< scalar_type > | vl::operator* (const Vector3< scalar_type > &v, const Matrix3< scalar_type > &m)
Pre multiplication: row vector * matrix.
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Vector2< scalar_type > &v, const Matrix3< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector3<scalar_type> with the component z = 0.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix4.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Matrix4.hpp File Reference

#include "vl/Vector4.hpp"
#include "vl/Matrix3.hpp"

Classes

class | vl::Matrix4< scalar_type >
The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Matrix4< GLdouble > | vl::dmat4
A 4x4 matrix using GLdouble precision.
typedef Matrix4< GLfloat > | vl::fmat4
A 4x4 matrix using GLfloat precision.
typedef Matrix4< GLint > | vl::imat4
A 4x4 matrix using GLint precision.
typedef Matrix4< GLuint > | vl::umat4
A 4x4 matrix using GLuint precision.
typedef dmat4 | vl::mat4
Defined as: 'typedef dmat4 mat4'. See also VL_PIPELINE_PRECISION.

Functions

template<typename scalar_type >
Matrix4< scalar_type > | vl::operator* (const Matrix4< scalar_type > &m2, const Matrix4< scalar_type > &m1)
template<typename scalar_type >
Matrix4< scalar_type > | vl::operator+ (scalar_type d, const Matrix4< scalar_type > &m)
template<typename scalar_type >
Matrix4< scalar_type > | vl::operator* (scalar_type d, const Matrix4< scalar_type > &m)
template<typename scalar_type >
Vector4< scalar_type > | vl::operator* (const Matrix4< scalar_type > &m, const Vector4< scalar_type > &v)
Post multiplication: matrix * column vector.
template<typename scalar_type >
Vector3< scalar_type > | vl::operator* (const Matrix4< scalar_type > &m, const Vector3< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with the component w = 1.
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Matrix4< scalar_type > &m, const Vector2< scalar_type > &v)
Post multiplication: matrix * column vector The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.
template<typename scalar_type >
Vector4< scalar_type > | vl::operator* (const Vector4< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix.
template<typename scalar_type >
Vector3< scalar_type > | vl::operator* (const Vector3< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with the component w = 1.
template<typename scalar_type >
Vector2< scalar_type > | vl::operator* (const Vector2< scalar_type > &v, const Matrix4< scalar_type > &m)
Pre multiplication: row vector * matrix The incoming vector is considered a Vector4<scalar_type> with components: z = 0 and w = 1.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.cpp File Reference

#include "vl/MD5CheckSum.hpp"
#include "vl/VirtualFile.hpp"
#include "md5/md5.c"
#include <stdio.h>
#include <string.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MD5CheckSum.hpp File Reference

#include <string>
#include <string.h>

Classes

class | vl::MD5CheckSum
Computes the MD5 of a given buffer or VirtualFile. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.cpp File Reference

#include "vl/MemoryDirectory.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryDirectory.hpp File Reference

#include "vl/VirtualDirectory.hpp"
#include "vl/MemoryFile.hpp"
#include "vl/String.hpp"
#include <map>
#include <set>

Classes

class | vl::MemoryDirectory
A VirtualDirectory to manipulate directories stored in memory. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.cpp File Reference

#include "vl/MemoryFile.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MemoryFile.hpp File Reference

#include "vl/VirtualFile.hpp"
#include "vl/Buffer.hpp"

Classes

class | vl::MemoryFile
A VirtualFile to manipulate files stored in memory. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.cpp File Reference

#include "vl/MorphingActor.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/MorphingActor.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::MorphingCallback
The MorphingCallback class is used by MorphingActor to implement the morphing animation on the GPU. More...
class | vl::MorphingActor
The MorphingActor class animates a Geometry by interpolating its position and normal array. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.cpp File Reference

#include "vl/Object.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Object.hpp File Reference

#include "vl/checks.hpp"
#include <string>

Classes

class | vl::Object
The base class for all the reference counted objects. More...
class | vl::ref< T >
The ref<> class is used to reference-count an Object. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

template<class T1 , class T2 >
bool | vl::operator== (const ref< T1 > &o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | vl::operator!= (const ref< T1 > &o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | vl::operator== (const ref< T1 > &o1, T2 *o2)
template<class T1 , class T2 >
bool | vl::operator!= (const ref< T1 > &o1, T2 *o2)
template<class T1 , class T2 >
bool | vl::operator== (T1 *o1, const ref< T2 > &o2)
template<class T1 , class T2 >
bool | vl::operator!= (T1 *o1, const ref< T2 > &o2)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.cpp File Reference

#include "vl/OpenGL.hpp"

Functions

void | VL_glBindBuffer (GLenum target, GLuint buffer)
void | VL_glGenBuffers (GLsizei n, GLuint *buffers)
void | VL_glDeleteBuffers (GLsizei n, const GLuint *buffers)
void | VL_glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
void | VL_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
void * | VL_glMapBuffer (GLenum target, GLenum access)
GLboolean | VL_glUnmapBuffer (GLenum target)
void | VL_glSecondaryColor3f (float r, float g, float b)
void | VL_glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void | VL_glFogCoordPointer (GLenum type, GLsizei stride, GLvoid *pointer)
void | VL_glEnableVertexAttribArray (GLuint index)
void | VL_glDisableVertexAttribArray (GLuint index)
void | VL_glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
void | VL_glVertexAttribIPointer (GLuint name, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void | VL_glClientActiveTexture (GLenum texture)
void | VL_glActiveTexture (GLenum texture)
void | VL_glBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
void | VL_glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
void | VL_glBlendEquation (GLenum mode)
void | VL_glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
void | VL_glPointParameterfv (GLenum pname, const GLfloat *params)
void | VL_glPointParameterf (GLenum pname, GLfloat param)
void | VL_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
void | VL_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
void | VL_glSampleCoverage (GLclampf value, GLboolean invert)
void | VL_glBindRenderbuffer (GLenum target, GLuint renderbuffer)
void | VL_glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
void | VL_glGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
void | VL_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
void | VL_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
GLboolean | VL_glIsFramebuffer (GLuint framebuffer)
void | VL_glBindFramebuffer (GLenum target, GLuint framebuffer)
void | VL_glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
void | VL_glGenFramebuffers (GLsizei n, GLuint *framebuffers)
GLenum | VL_glCheckFramebufferStatus (GLenum target)
void | VL_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
void | VL_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
void | VL_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
void | VL_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
void | VL_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
void | VL_glGenerateMipmap (GLenum target)
void | VL_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
void | VL_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
void | VL_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
void | VL_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
void | VL_glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
void | VL_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei primcount)
void | VL_glProgramParameteri (GLuint program, GLenum pname, GLint value)
void | VL_glBindFragDataLocation (GLuint program, GLuint colorNumber, const GLchar *name)
void | VL_glUniform1uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform2uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform3uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform4uiv (GLint location, GLsizei count, const GLuint *value)

Function Documentation

void VL_glBindBuffer | ( | GLenum | target,
 |  | GLuint | buffer
 | ) |  |

void VL_glGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) |  |

void VL_glDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) |  |

void VL_glBufferData | ( | GLenum | target,
 |  | GLsizeiptr | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) |  |

void VL_glBufferSubData | ( | GLenum | target,
 |  | GLintptr | offset,
 |  | GLsizeiptr | size,
 |  | const GLvoid * | data
 | ) |  |

void* VL_glMapBuffer | ( | GLenum | target,
 |  | GLenum | access
 | ) |  |

GLboolean VL_glUnmapBuffer ( GLenum target )

void VL_glSecondaryColor3f | ( | float | r,
 |  | float | g,
 |  | float | b
 | ) |  |

void VL_glSecondaryColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glFogCoordPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | GLvoid * | pointer
 | ) |  |

void VL_glEnableVertexAttribArray ( GLuint index )

void VL_glDisableVertexAttribArray ( GLuint index )

void VL_glVertexAttribPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLboolean | normalized,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glVertexAttribIPointer | ( | GLuint | name,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glClientActiveTexture ( GLenum texture )

void VL_glActiveTexture ( GLenum texture )

void VL_glBlendFuncSeparate | ( | GLenum | srcRGB,
 |  | GLenum | dstRGB,
 |  | GLenum | srcAlpha,
 |  | GLenum | dstAlpha
 | ) |  |

void VL_glBlendEquationSeparate | ( | GLenum | modeRGB,
 |  | GLenum | modeAlpha
 | ) |  |

void VL_glBlendEquation ( GLenum mode )

void VL_glBlendColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) |  |

void VL_glPointParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) |  |

void VL_glPointParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) |  |

void VL_glStencilFuncSeparate | ( | GLenum | face,
 |  | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) |  |

void VL_glStencilOpSeparate | ( | GLenum | face,
 |  | GLenum | sfail,
 |  | GLenum | dpfail,
 |  | GLenum | dppass
 | ) |  |

void VL_glSampleCoverage | ( | GLclampf | value,
 |  | GLboolean | invert
 | ) |  |

void VL_glBindRenderbuffer | ( | GLenum | target,
 |  | GLuint | renderbuffer
 | ) |  |

void VL_glDeleteRenderbuffers | ( | GLsizei | n,
 |  | const GLuint * | renderbuffers
 | ) |  |

void VL_glGenRenderbuffers | ( | GLsizei | n,
 |  | GLuint * | renderbuffers
 | ) |  |

void VL_glRenderbufferStorage | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) |  |

void VL_glGetRenderbufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) |  |

GLboolean VL_glIsFramebuffer ( GLuint framebuffer )

void VL_glBindFramebuffer | ( | GLenum | target,
 |  | GLuint | framebuffer
 | ) |  |

void VL_glDeleteFramebuffers | ( | GLsizei | n,
 |  | const GLuint * | framebuffers
 | ) |  |

void VL_glGenFramebuffers | ( | GLsizei | n,
 |  | GLuint * | framebuffers
 | ) |  |

GLenum VL_glCheckFramebufferStatus ( GLenum target )

void VL_glFramebufferTexture1D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTexture2D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTexture3D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | zoffset
 | ) |  |

void VL_glFramebufferRenderbuffer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | renderbuffertarget,
 |  | GLuint | renderbuffer
 | ) |  |

void VL_glGetFramebufferAttachmentParameteriv | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) |  |

void VL_glGenerateMipmap ( GLenum target )

void VL_glFramebufferTexture | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTextureLayer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | layer
 | ) |  |

void VL_glRenderbufferStorageMultisample | ( | GLenum | target,
 |  | GLsizei | samples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) |  |

void VL_glBlitFramebuffer | ( | GLint | srcX0,
 |  | GLint | srcY0,
 |  | GLint | srcX1,
 |  | GLint | srcY1,
 |  | GLint | dstX0,
 |  | GLint | dstY0,
 |  | GLint | dstX1,
 |  | GLint | dstY1,
 |  | GLbitfield | mask,
 |  | GLenum | filter
 | ) |  |

void VL_glDrawElementsInstanced | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices,
 |  | GLsizei | primcount
 | ) |  |

void VL_glDrawArraysInstanced | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count,
 |  | GLsizei | primcount
 | ) |  |

void VL_glProgramParameteri | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint | value
 | ) |  |

void VL_glBindFragDataLocation | ( | GLuint | program,
 |  | GLuint | colorNumber,
 |  | const GLchar * | name
 | ) |  |

void VL_glUniform1uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform2uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform3uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform4uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGL.hpp File Reference

#include "vl/config.hpp"
#include "GL/glew.h"

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | GLEW_STATIC
#define | VL_CHECK_OGL() { if ( ::vl::glcheck( __FILE__, __LINE__ ) ) {VL_TRAP( )} }

Functions

int | vl::glcheck (const char *file, int line)
void | VL_glBindBuffer (GLenum target, GLuint buffer)
void | VL_glGenBuffers (GLsizei n, GLuint *buffers)
void | VL_glDeleteBuffers (GLsizei n, const GLuint *buffers)
void | VL_glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
void | VL_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
void * | VL_glMapBuffer (GLenum target, GLenum access)
GLboolean | VL_glUnmapBuffer (GLenum target)
void | VL_glSecondaryColor3f (float, float, float)
void | VL_glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void | VL_glFogCoordPointer (GLenum type, GLsizei stride, GLvoid *pointer)
void | VL_glEnableVertexAttribArray (GLuint index)
void | VL_glDisableVertexAttribArray (GLuint index)
void | VL_glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
void | VL_glVertexAttribIPointer (GLuint name, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void | VL_glClientActiveTexture (GLenum texture)
void | VL_glActiveTexture (GLenum texture)
void | VL_glBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
void | VL_glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
void | VL_glBlendEquation (GLenum mode)
void | VL_glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
void | VL_glPointParameterf (GLenum pname, GLfloat param)
void | VL_glPointParameterfv (GLenum pname, const GLfloat *params)
void | VL_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
void | VL_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
void | VL_glSampleCoverage (GLclampf value, GLboolean invert)
void | VL_glBindRenderbuffer (GLenum target, GLuint renderbuffer)
void | VL_glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
void | VL_glGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
void | VL_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
void | VL_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
GLboolean | VL_glIsFramebuffer (GLuint framebuffer)
void | VL_glBindFramebuffer (GLenum target, GLuint framebuffer)
void | VL_glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
void | VL_glGenFramebuffers (GLsizei n, GLuint *framebuffers)
GLenum | VL_glCheckFramebufferStatus (GLenum target)
void | VL_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
void | VL_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
void | VL_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
void | VL_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
void | VL_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
void | VL_glGenerateMipmap (GLenum target)
void | VL_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
void | VL_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
void | VL_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
void | VL_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
void | VL_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei primcount)
void | VL_glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
void | VL_glProgramParameteri (GLuint program, GLenum pname, GLint value)
void | VL_glBindFragDataLocation (GLuint program, GLuint colorNumber, const GLchar *name)
void | VL_glUniform1uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform2uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform3uiv (GLint location, GLsizei count, const GLuint *value)
void | VL_glUniform4uiv (GLint location, GLsizei count, const GLuint *value)

Define Documentation

#define GLEW_STATIC

#define VL_CHECK_OGL ( ) { if ( ::vl::glcheck( __FILE__, __LINE__ ) ) {VL_TRAP( )} }

Function Documentation

void VL_glBindBuffer | ( | GLenum | target,
 |  | GLuint | buffer
 | ) |  |

void VL_glGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) |  |

void VL_glDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) |  |

void VL_glBufferData | ( | GLenum | target,
 |  | GLsizeiptr | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) |  |

void VL_glBufferSubData | ( | GLenum | target,
 |  | GLintptr | offset,
 |  | GLsizeiptr | size,
 |  | const GLvoid * | data
 | ) |  |

void* VL_glMapBuffer | ( | GLenum | target,
 |  | GLenum | access
 | ) |  |

GLboolean VL_glUnmapBuffer ( GLenum target )

void VL_glSecondaryColor3f | ( | float | ,
 |  | float | ,
 |  | float |
 | ) |  |

void VL_glSecondaryColorPointer | ( | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glFogCoordPointer | ( | GLenum | type,
 |  | GLsizei | stride,
 |  | GLvoid * | pointer
 | ) |  |

void VL_glEnableVertexAttribArray ( GLuint index )

void VL_glDisableVertexAttribArray ( GLuint index )

void VL_glVertexAttribPointer | ( | GLuint | index,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLboolean | normalized,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glVertexAttribIPointer | ( | GLuint | name,
 |  | GLint | size,
 |  | GLenum | type,
 |  | GLsizei | stride,
 |  | const GLvoid * | pointer
 | ) |  |

void VL_glClientActiveTexture ( GLenum texture )

void VL_glActiveTexture ( GLenum texture )

void VL_glBlendFuncSeparate | ( | GLenum | srcRGB,
 |  | GLenum | dstRGB,
 |  | GLenum | srcAlpha,
 |  | GLenum | dstAlpha
 | ) |  |

void VL_glBlendEquationSeparate | ( | GLenum | modeRGB,
 |  | GLenum | modeAlpha
 | ) |  |

void VL_glBlendEquation ( GLenum mode )

void VL_glBlendColor | ( | GLclampf | red,
 |  | GLclampf | green,
 |  | GLclampf | blue,
 |  | GLclampf | alpha
 | ) |  |

void VL_glPointParameterf | ( | GLenum | pname,
 |  | GLfloat | param
 | ) |  |

void VL_glPointParameterfv | ( | GLenum | pname,
 |  | const GLfloat * | params
 | ) |  |

void VL_glStencilFuncSeparate | ( | GLenum | face,
 |  | GLenum | func,
 |  | GLint | ref,
 |  | GLuint | mask
 | ) |  |

void VL_glStencilOpSeparate | ( | GLenum | face,
 |  | GLenum | sfail,
 |  | GLenum | dpfail,
 |  | GLenum | dppass
 | ) |  |

void VL_glSampleCoverage | ( | GLclampf | value,
 |  | GLboolean | invert
 | ) |  |

void VL_glBindRenderbuffer | ( | GLenum | target,
 |  | GLuint | renderbuffer
 | ) |  |

void VL_glDeleteRenderbuffers | ( | GLsizei | n,
 |  | const GLuint * | renderbuffers
 | ) |  |

void VL_glGenRenderbuffers | ( | GLsizei | n,
 |  | GLuint * | renderbuffers
 | ) |  |

void VL_glRenderbufferStorage | ( | GLenum | target,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) |  |

void VL_glGetRenderbufferParameteriv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) |  |

GLboolean VL_glIsFramebuffer ( GLuint framebuffer )

void VL_glBindFramebuffer | ( | GLenum | target,
 |  | GLuint | framebuffer
 | ) |  |

void VL_glDeleteFramebuffers | ( | GLsizei | n,
 |  | const GLuint * | framebuffers
 | ) |  |

void VL_glGenFramebuffers | ( | GLsizei | n,
 |  | GLuint * | framebuffers
 | ) |  |

GLenum VL_glCheckFramebufferStatus ( GLenum target )

void VL_glFramebufferTexture1D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTexture2D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTexture3D | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | textarget,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | zoffset
 | ) |  |

void VL_glFramebufferRenderbuffer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | renderbuffertarget,
 |  | GLuint | renderbuffer
 | ) |  |

void VL_glGetFramebufferAttachmentParameteriv | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) |  |

void VL_glGenerateMipmap ( GLenum target )

void VL_glFramebufferTexture | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level
 | ) |  |

void VL_glFramebufferTextureLayer | ( | GLenum | target,
 |  | GLenum | attachment,
 |  | GLuint | texture,
 |  | GLint | level,
 |  | GLint | layer
 | ) |  |

void VL_glRenderbufferStorageMultisample | ( | GLenum | target,
 |  | GLsizei | samples,
 |  | GLenum | internalformat,
 |  | GLsizei | width,
 |  | GLsizei | height
 | ) |  |

void VL_glBlitFramebuffer | ( | GLint | srcX0,
 |  | GLint | srcY0,
 |  | GLint | srcX1,
 |  | GLint | srcY1,
 |  | GLint | dstX0,
 |  | GLint | dstY0,
 |  | GLint | dstX1,
 |  | GLint | dstY1,
 |  | GLbitfield | mask,
 |  | GLenum | filter
 | ) |  |

void VL_glDrawArraysInstanced | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count,
 |  | GLsizei | primcount
 | ) |  |

void VL_glDrawElementsInstanced | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices,
 |  | GLsizei | primcount
 | ) |  |

void VL_glProgramParameteri | ( | GLuint | program,
 |  | GLenum | pname,
 |  | GLint | value
 | ) |  |

void VL_glBindFragDataLocation | ( | GLuint | program,
 |  | GLuint | colorNumber,
 |  | const GLchar * | name
 | ) |  |

void VL_glUniform1uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform2uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform3uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

void VL_glUniform4uiv | ( | GLint | location,
 |  | GLsizei | count,
 |  | const GLuint * | value
 | ) |  |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.cpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vl/OpenGL.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include <algorithm>
#include "../3rdparty/glew/src/glew.c"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/OpenGLContext.hpp File Reference

#include "vl/Object.hpp"
#include "vl/UIEventListener.hpp"
#include "vl/FramebufferObject.hpp"
#include <vector>
#include <set>

Classes

class | vl::OpenGLContextFormat
The OpenGLContextFormat class encapsulates the settings of an OpenGL rendering context. More...
class | vl::OpenGLContext
Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.cpp File Reference

#include "vl/PixelLODEvaluator.hpp"
#include "vl/Camera.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PixelLODEvaluator.hpp File Reference

#include "vl/Actor.hpp"

Classes

class | vl::PixelLODEvaluator
A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.cpp File Reference

#include "vl/Plane.hpp"
#include "vl/AABB.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Plane.hpp File Reference

#include "vl/Object.hpp"
#include "vl/GLSLmath.hpp"
#include "vl/Transform.hpp"

Classes

class | vl::Plane
The Plane class defines a plane using a normal and an origin. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.cpp File Reference

#include "vl/PolygonSimplifier.hpp"
#include "vl/DoubleVertexRemover.hpp"
#include "vl/Time.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include <set>

Defines

#define SHUFFLE_VERTICES 0

Define Documentation

#define SHUFFLE_VERTICES 0

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/PolygonSimplifier.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Vector3.hpp"
#include "vl/GLSLmath.hpp"
#include <vector>
#include <algorithm>

Classes

class | vl::PolygonSimplifier
The PolygonSimplifier class reduces the amount of polygons present in a Geometry using a quadric error metric. More...
class | vl::PolygonSimplifier::QErr
The quadric error metric as defined by PolygonSimplifier. More...
class | vl::PolygonSimplifier::Triangle
A Triangle as defined by PolygonSimplifier. More...
class | vl::PolygonSimplifier::Vertex
A Vertex as defined by PolygonSimplifier. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Primitives.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Primitives.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Array.hpp"

Classes

class | vl::Primitives
This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays(). More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.cpp File Reference

#include "vl/quat.hpp"
#include "vl/math3D.hpp"
#include <cmath>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/quat.hpp File Reference

#include "vl/GLSLmath.hpp"

Classes

class | vl::quat
The quat class implements a quaternion using vl::Real precision. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

quat | vl::operator* (Real r, const quat &q)
quat | vl::operator* (const quat &q1, const quat &q2)
vec3 | vl::operator* (const quat &q, const vec3 &v)
vec4 | vl::operator* (const quat &q, const vec4 &v)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Ray.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Ray.hpp File Reference

#include "vl/Vector4.hpp"

Classes

class | vl::Ray
The Ray class defines a ray as an origin and direction using Real precision. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.cpp File Reference

#include "vl/RayIntersector.hpp"
#include "vl/SceneManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RayIntersector.hpp File Reference

#include "vl/Ray.hpp"
#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/Vector4.hpp"
#include "vl/Matrix4.hpp"

Classes

class | vl::RayIntersection
The RayIntersection encapsulates all the information relative to a Ray/Actor intersection. More...
class | vl::RayIntersectionGeometry
The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor. More...
class | vl::RayIntersector
The RayIntersector class is used to detect the intersection points between a Ray and a set of Actor[s]. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ReadPixels.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ReadPixels.hpp File Reference

#include "vl/Camera.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
#include "vl/RenderingCallback.hpp"
#include "vl/vlTGA.hpp"
#include "vl/vlTIFF.hpp"
#include "vl/vlPNG.hpp"
#include "vl/vlJPG.hpp"

Classes

class | vl::ReadPixels
A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rect.hpp File Reference

#include "vl/Vector2.hpp"

Classes

class | vl::Rect< T >
Implements the common functions of RectI and RectF. More...
class | vl::RectI
The RectI class represents a 2D rectangular area using int precision. More...
class | vl::RectF
The RectF class represents a 2D rectangular area using float precision. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderable.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderable.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Transform.hpp"
#include "vl/AABB.hpp"
#include "vl/Sphere.hpp"

Classes

class | vl::Renderable
An abstract class that represents all the objects that can be rendered. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.cpp File Reference

#include "vl/Renderer.hpp"
#include "vl/Effect.hpp"
#include "vl/Transform.hpp"
#include "vl/checks.hpp"
#include "vl/OpenGL.hpp"
#include "vl/Time.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Renderer.hpp File Reference

#include "vl/RenderQueue.hpp"
#include "vl/Camera.hpp"
#include "vl/Renderable.hpp"
#include "vl/Shader.hpp"
#include "vl/Effect.hpp"
#include "vl/OpenGLContext.hpp"
#include <vector>
#include <map>
#include <set>

Classes

class | vl::Renderer
The Renderer class executes the actual rendering on the given RenderQueue. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.cpp File Reference

#include "vl/Rendering.hpp"
#include "vl/SceneManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Rendering.hpp File Reference

#include "vl/RenderingAbstract.hpp"
#include "vl/Renderer.hpp"

Classes

class | vl::Rendering
The Rendering class collects all the information to perform the rendering of a scene. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.cpp File Reference

#include "vl/RenderingAbstract.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingAbstract.hpp File Reference

#include "vl/RenderingCallback.hpp"
#include "vl/Collection.hpp"

Classes

class | vl::RenderingAbstract
The RenderingAbstract class implements the abstract rendering interface. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingCallback.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingCallback.hpp File Reference

#include "vl/Object.hpp"
#include "vl/vlnamespace.hpp"

Classes

class | vl::RenderingCallback
An abstract class used to perform operations at the end or at the beginning of a rendering. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.cpp File Reference

#include "vl/RenderingTree.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderingTree.hpp File Reference

#include "vl/RenderingAbstract.hpp"

Classes

class | vl::RenderingTree
The RenderingTree class organizes a set of renderings into a tree-like data structure. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueue.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueue.hpp File Reference

#include "vl/RenderQueueSorter.hpp"

Classes

class | vl::RenderQueue
The RenderQueue class collects a list of RenderToken objects to be sorted and rendered. More...
class | vl::RenderQueue::Sorter

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef std::map< float, ref
< RenderQueue > > 		vl::TRenderQueueMap
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderQueueSorter.hpp File Reference

#include "vl/RenderToken.hpp"

Classes

class | vl::RenderQueueSorter
The RenderQueueSorter class is the abstract base class of all the algorithms used to sort a set of RenderToken. More...
class | vl::RenderQueueSorterByShader
Sorts the RenderTokens by their Shader pointer. More...
class | vl::RenderQueueSorterByRenderable
Sorts the RenderTokens by their Renderable pointer. More...
class | vl::RenderQueueSorterBasic
Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer. More...
class | vl::RenderQueueSorterStandard
Implements the default RenderQueueSorter. More...
class | vl::RenderQueueSorterOcclusion
Implements a RenderQueueSorter to be used with occlusion culling. More...
class | vl::RenderQueueSorterAggressive
Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderState.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderState.hpp File Reference

#include "vl/Object.hpp"
#include "vl/vlnamespace.hpp"

Classes

class | vl::RenderState
Base class for most of the OpenGL render state wrapper classes. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.cpp File Reference

#include "vl/RenderTarget.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include <map>
#include <set>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderTarget.hpp File Reference

#include "vl/vlnamespace.hpp"
#include "vl/Object.hpp"
#include <vector>

Classes

class | vl::RenderTarget
The RenderTarget class defines an abstract 'surface' where OpenGL can render into. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderToken.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/RenderToken.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Camera.hpp"
#include "vl/Renderable.hpp"
#include "vl/Shader.hpp"
#include "vl/Effect.hpp"

Classes

class | vl::RenderToken
Internally used by the rendering engine. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceDatabase.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceDatabase.hpp File Reference

#include "vl/Object.hpp"
#include "vl/String.hpp"
#include <vector>
#include <algorithm>

Classes

class | vl::ResourceDatabase
The ResourceDatabase class contains and manipulates a set of resources. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

ref< ResourceDatabase > | vl::loadResource (const String &path, bool quick=true)
Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(const String& path, bool quick).
ref< ResourceDatabase > | vl::loadResource (VirtualFile *file, bool quick=true)
Loads the specified resource. Equivalent to VisualizationLibrary::loadWriterManager()->loadResource(VirtualFile* file).
bool | vl::canLoad (const String &path)
Returns true if there is a ResourceLoadWriter registered to load the specified path or extension.
bool | vl::canLoad (VirtualFile *file)
Returns true if there is a ResourceLoadWriter registered to load the specified file.
bool | vl::canWrite (const String &path)
Returns true if there is a ResourceLoadWriter registered to write the specified path or extension.
bool | vl::canWrite (VirtualFile *file)
Returns true if there is a ResourceLoadWriter registered to write the specified file.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceLoadWriter.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ResourceLoadWriter.hpp File Reference

#include "vl/String.hpp"

Classes

class | vl::ResourceLoadWriter
The ResourceLoadWriter class is an abstract class used to implement read/write support for one or more resource types. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.cpp File Reference

#include "vl/Say.hpp"
#include <cmath>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Say.hpp File Reference

#include "vl/String.hpp"
#include <string>

Classes

class | vl::SayArg
Used internally by the Say class. More...
class | vl::Say
A simple String formatting class. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.cpp File Reference

#include "vl/SceneManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManager.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Camera.hpp"

Classes

class | vl::SceneManager
The SceneManager class is the base class for all the scene managers. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.cpp File Reference

#include "vl/SceneManagerKdTree.hpp"
#include <set>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorKdTree.hpp File Reference

#include "vl/SceneManagerBVH.hpp"
#include "vl/ActorKdTree.hpp"

Classes

class | vl::SceneManagerActorKdTree
A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorTree.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerActorTree.hpp File Reference

#include "vl/SceneManagerBVH.hpp"
#include "vl/ActorTree.hpp"

Classes

class | vl::SceneManagerActorTree
A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerBVH.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerBVH.hpp File Reference

#include "vl/SceneManager.hpp"

Classes

class | vl::SceneManagerBVH< T >
The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.cpp File Reference

#include "vl/SceneManagerPortals.hpp"
#include "vl/Geometry.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/SceneManagerPortals.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Vector4.hpp"
#include "vl/Vector3.hpp"
#include "vl/SceneManager.hpp"
#include "vl/Log.hpp"

Classes

class | vl::Portal
A planar convex polygon used to define the visibility from one Sector to another. More...
class | vl::Sector
Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s]. More...
class | vl::Sector::VisibilityCallback
A callback object called each time a Sector becomes visible through a Portal. More...
class | vl::SceneManagerPortals
The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Scissor.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Scissor.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Rect.hpp"

Classes

class | vl::Scissor
The Scissor class wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.cpp File Reference

#include "vl/Shader.hpp"
#include "vl/OpenGL.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"

Defines

#define | GET_OR_CREATE(RS)
#define | GET_OR_CREATE_IDX(RS, index)

Define Documentation

#define GET_OR_CREATE ( RS )

Value:

RS* rs = dynamic_cast<RS*>( gocRenderStateSet()->renderState( RS_##RS ) ); \
  if ( rs == NULL ) \
  { \
    rs = new RS; \
    gocRenderStateSet()->setRenderState( rs ); \
  } \
  return rs;

#define GET_OR_CREATE_IDX | ( | RS,
 |  | index | )

Value:

RS* rs = dynamic_cast<RS*>( gocRenderStateSet()->renderState( (ERenderState)(RS_##RS##0 + index) ) ); \
  if ( rs == NULL ) \
  { \
    rs = new RS(index); \
    gocRenderStateSet()->setRenderState( rs ); \
  } \
  return rs;

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Shader.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Light.hpp"
#include "vl/ClipPlane.hpp"
#include "vl/Texture.hpp"
#include "vl/GLSL.hpp"
#include "vl/Uniform.hpp"
#include "vl/Scissor.hpp"
#include <vector>
#include <bitset>

Classes

class | vl::PixelTransfer
Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information. More...
class | vl::Hint
Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information. More...
class | vl::CullFace
Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information. More...
class | vl::FrontFace
Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information. More...
class | vl::DepthFunc
Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information. More...
class | vl::DepthMask
Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information. More...
class | vl::PolygonMode
Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information. More...
class | vl::ShadeModel
Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information. More...
class | vl::BlendFunc
Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information. More...
class | vl::BlendEquation
Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information. More...
class | vl::SampleCoverage
Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information. More...
class | vl::AlphaFunc
Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information. More...
class | vl::Material
Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information. More...
class | vl::LightModel
Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information. More...
class | vl::Fog
Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information. More...
class | vl::PolygonOffset
Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information. More...
class | vl::LogicOp
Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information. More...
class | vl::DepthRange
Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information. More...
class | vl::LineWidth
Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information. More...
class | vl::PointSize
Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information. More...
class | vl::PolygonStipple
Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information. More...
class | vl::LineStipple
Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information. More...
class | vl::PointParameter
Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information. More...
class | vl::StencilFunc
Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information. More...
class | vl::StencilOp
Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information. More...
class | vl::StencilMask
Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information. More...
class | vl::BlendColor
Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information. More...
class | vl::ColorMask
Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information. More...
class | vl::TextureMatrix
The TextureMatrix class uses a 4x4 matrix to transform the texture coordinates of a texture unit. More...
class | vl::TexEnv
Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information. More...
class | vl::TexGen
Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information. More...
class | vl::TextureUnit
The TextureUnit class associates a Texture object to an OpenGL texture unit. More...
class | vl::RenderStateSet
A set of RenderState objects managed by a Shader. More...
class | vl::EnableSet
A set of enables managed by Shader. More...
class | vl::Shader
Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ShaderNode.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ShaderNode.hpp File Reference

#include "vl/Shader.hpp"
#include "vl/vlnamespace.hpp"
#include <vector>
#include <map>

Classes

class | vl::ShaderNode
The ShaderNode class is used to conveniently manage complex hierarchies of Shader[s]. More...
class | vl::ShaderNode::EnableInfo
class | vl::ShaderNode::RenderStateInfo
class | vl::ShaderNode::UniformInfo

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Sphere.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Sphere.hpp File Reference

#include "vl/AABB.hpp"

Classes

class | vl::Sphere
The Sphere class defines a sphere using a center and a radius using vl::Real precision. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.cpp File Reference

#include "vl/String.hpp"
#include "vl/String_Tables.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/VisualizationLibrary.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String.hpp File Reference

#include "vl/vlnamespace.hpp"
#include "vl/Object.hpp"
#include <vector>
#include <string.h>

Classes

class | vl::String
The String class implements an advanced UTF16 (Unicode BMP) string manipulation engine. More...
class | vl::String::StringData

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | VL_PLATFORM_DEFAULT_ENCODING SE_UTF8

Functions

String | vl::operator+ (const wchar_t *pstr, const String &str)
String | vl::operator+ (const char *pstr, const String &str)
String | vl::operator+ (wchar_t ch, const String &str)
String | vl::operator+ (char ch, const String &str)

Define Documentation

#define VL_PLATFORM_DEFAULT_ENCODING SE_UTF8

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String_Tables.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/String_Tables.hpp File Reference

#include <cstdlib>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.cpp File Reference

#include "vl/Terrain.hpp"
#include "vl/Actor.hpp"
#include "vl/Effect.hpp"
#include "vl/Geometry.hpp"
#include "vlut/GeometryPrimitives.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Terrain.hpp File Reference

#include "vl/SceneManagerActorKdTree.hpp"
#include "vl/ShaderNode.hpp"

Classes

class | vl::Terrain
The Terrain class implements a ActorKdTree-based terrain scene manager. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.cpp File Reference

#include "vl/Tessellator.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Tessellator.hpp File Reference

#include "vl/OpenGL.hpp"
#include "vl/Geometry.hpp"
#include "vl/Vector3.hpp"
#include <vector>

Classes

class | vl::Tessellator
Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.cpp File Reference

#include "vl/Text.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/DiskFile.hpp"
#include "vl/Image.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
#include "vl/Actor.hpp"
#include "vl/Renderer.hpp"
#include <ft2build.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Text.hpp File Reference

#include "vl/Font.hpp"
#include "vl/Renderable.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/String.hpp"
#include "vl/Rect.hpp"
#include <map>

Classes

class | vl::Text
A Renderable that renders text with a given Font. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TextStream.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TextStream.hpp File Reference

#include "vl/BufferedStream.hpp"

Classes

class | vl::TextStream
The TextStream class can be used to conveniently read or parse utf8-encoded text files. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.cpp File Reference

#include "vl/Texture.hpp"
#include "vl/checks.hpp"
#include "vl/Image.hpp"
#include "vl/math3D.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Texture.hpp File Reference

#include "vl/String.hpp"
#include "vl/Vector4.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/Image.hpp"

Classes

class | vl::TexParameter
Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information. More...
class | vl::Texture
Wraps an OpenGL texture object. More...
class | vl::Texture::SetupParams
The SetupParams function wraps all the parameters neede to crate a Texture. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.cpp File Reference

#include "vl/Time.hpp"
#include <ctime>
#include <cmath>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Time.hpp File Reference

#include "vl/Object.hpp"

Classes

class | vl::Time
Simple class to be used as a timer and to retrieve the current time and date. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.cpp File Reference

#include "vl/TrackballManipulator.hpp"
#include "vl/Camera.hpp"
#include "vl/Actor.hpp"
#include "vl/SceneManager.hpp"
#include "vl/Rendering.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TrackballManipulator.hpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vl/Camera.hpp"
#include "vl/Vector3.hpp"
#include "vl/Actor.hpp"

Classes

class | vl::TrackballManipulator
This class lets you rotate a Camera or a Transform node using a vitual trackball. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.cpp File Reference

#include "vl/Transform.hpp"
#include "vl/Camera.hpp"
#include <algorithm>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Transform.hpp File Reference

#include "vl/vlnamespace.hpp"
#include "vl/Object.hpp"
#include "vl/Matrix4.hpp"
#include <vector>

Classes

class | vl::Transform
Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.cpp File Reference

#include "../3rdparty/tristripper/tri_stripper.cpp"
#include "../3rdparty/tristripper/policy.cpp"
#include "../3rdparty/tristripper/connectivity_graph.cpp"
#include "vl/TriangleStripGenerator.hpp"
#include "vl/Geometry.hpp"
#include "vl/DoubleVertexRemover.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/TriangleStripGenerator.hpp File Reference

Classes

class | vl::TriangleStripGenerator
The TriangleStripGenerator class is used to substitute lists of triangles or quads with triangle strips. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/UIEventListener.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/UIEventListener.hpp File Reference

#include "vl/String.hpp"

Classes

class | vl::UIEventListener
The UIEventListener class listens to the events emitted by an OpenGLContext. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Uniform.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Uniform.hpp File Reference

#include "vlnamespace.hpp"
#include "vl/Object.hpp"
#include "vl/Vector4.hpp"
#include "vl/Matrix4.hpp"
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>

Classes

class | vl::Uniform
Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram. More...
class | vl::UniformSet
A set of Uniform objects managed by a Shader. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector2.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector2.hpp File Reference

#include "vl/OpenGL.hpp"
#include <cmath>

Classes

class | vl::Vector2< scalar_type >
The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | VL_FLOAT_SQRT(x) ((float)::sqrt(x))
#define | VL_FLOAT_INVSQRT(x) (1.0f/(float)::sqrt(x))

Typedefs

typedef Vector2< GLint > | vl::ivec2
A 2 components vector with GLint precision.
typedef Vector2< GLuint > | vl::uvec2
A 2 components vector with GLuint precision.
typedef Vector2< GLfloat > | vl::fvec2
A 2 components vector with GLfloat precision.
typedef Vector2< GLdouble > | vl::dvec2
A 2 components vector with GLdouble precision.
typedef Vector2< GLbyte > | vl::bvec2
A 2 components vector with GLbyte precision.
typedef Vector2< GLubyte > | vl::ubvec2
A 2 components vector with GLubyte precision.
typedef Vector2< GLshort > | vl::svec2
A 2 components vector with GLshort precision.
typedef Vector2< GLushort > | vl::usvec2
A 2 components vector with GLushort precision.
typedef dvec2 | vl::vec2
Defined as: 'typedef dvec2 vec2'. See also VL_PIPELINE_PRECISION.

Functions

float | vl::fast1_inversesqrt (float x)
float | vl::fast2_inversesqrt (float x)
float | vl::fast_sqrt (float x)
template<typename T >
const Vector2< T > | vl::operator* (T val, const Vector2< T > &v)

Variables

const double | vl::dPi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845
Greek Pi constant using double precision.
const double | vl::dDEG_TO_RAD = dPi / 180.0
Constant to convert degrees into radians using double precision.
const double | vl::dRAD_TO_DEG = 180.0 / dPi
Constant to convert radians into degrees using double precision.
const float | vl::fPi = (float)3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093845
Greek Pi constant using float precision.
const float | vl::fDEG_TO_RAD = float(dPi / 180.0)
Constant to convert degrees into radians using float precision.
const float | vl::fRAD_TO_DEG = float(180.0 / dPi)
Constant to convert radians into degrees using float precision.

Define Documentation

#define VL_FLOAT_SQRT ( x ) ((float)::sqrt(x))

#define VL_FLOAT_INVSQRT ( x ) (1.0f/(float)::sqrt(x))

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector3.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector3.hpp File Reference

#include "vl/Vector2.hpp"

Classes

class | vl::Vector3< scalar_type >
The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Vector3< GLint > | vl::ivec3
A 3 components vector with GLint precision.
typedef Vector3< GLuint > | vl::uvec3
A 3 components vector with GLuint precision.
typedef Vector3< GLfloat > | vl::fvec3
A 3 components vector with GLfloat precision.
typedef Vector3< GLdouble > | vl::dvec3
A 3 components vector with GLdouble precision.
typedef Vector3< GLbyte > | vl::bvec3
A 3 components vector with GLbyte precision.
typedef Vector3< GLubyte > | vl::ubvec3
A 3 components vector with GLubyte precision.
typedef Vector3< GLshort > | vl::svec3
A 3 components vector with GLshort precision.
typedef Vector3< GLushort > | vl::usvec3
A 3 components vector with GLushort precision.
typedef dvec3 | vl::vec3
Defined as: 'typedef dvec3 vec3'. See also VL_PIPELINE_PRECISION.

Functions

template<typename T >
const Vector3< T > | vl::operator* (T val, const Vector3< T > &v)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector4.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Vector4.hpp File Reference

#include "vl/Vector3.hpp"

Classes

class | vl::Vector4< scalar_type >
The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4. More...

Namespaces

namespace | vl
Visualization Library namespace.

Typedefs

typedef Vector4< GLint > | vl::ivec4
A 4 components vector with GLint precision.
typedef Vector4< GLuint > | vl::uvec4
A 4 components vector with GLuint precision.
typedef Vector4< GLfloat > | vl::fvec4
A 4 components vector with GLfloat precision.
typedef Vector4< GLdouble > | vl::dvec4
A 4 components vector with GLdouble precision.
typedef Vector4< GLbyte > | vl::bvec4
A 4 components vector with GLbyte precision.
typedef Vector4< GLubyte > | vl::ubvec4
A 4 components vector with GLubyte precision.
typedef Vector4< GLshort > | vl::svec4
A 4 components vector with GLshort precision.
typedef Vector4< GLushort > | vl::usvec4
A 4 components vector with GLushort precision.
typedef dvec4 | vl::vec4
Defined as: 'typedef dvec4 vec4'. See also VL_PIPELINE_PRECISION.

Functions

template<typename T >
const Vector4< T > | vl::operator* (T val, const Vector4< T > &v)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/version.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/version.hpp File Reference

Defines

#define | VL_Major 2009
#define | VL_Minor 8
#define | VL_Build 800
#define | VL_BuildType "Stable"
#define | VL_Version 0x200908

Define Documentation

#define VL_Major 2009

#define VL_Minor 8

#define VL_Build 800

#define VL_BuildType "Stable"

#define VL_Version 0x200908

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VertexAttributeArray.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VertexAttributeArray.hpp File Reference

#include "vl/Object.hpp"

Classes

class | vl::VertexAttributeArray
Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.cpp File Reference

#include "vl/Viewport.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/Viewport.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Rect.hpp"
#include "vl/Vector4.hpp"
#include "vl/vlnamespace.hpp"

Classes

class | vl::Viewport
Implements the viewport and clearing settings associated to a Camera. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.cpp File Reference

#include "vl/VirtualDirectory.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualDirectory.hpp File Reference

#include "vl/Object.hpp"
#include "vl/String.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/VirtualFile.hpp"

Classes

class | vl::VirtualDirectory
Abstact class representing a directory of files. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.cpp File Reference

#include "vl/VirtualFile.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/CRC32CheckSum.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VirtualFile.hpp File Reference

#include "vl/Object.hpp"
#include "vl/vlnamespace.hpp"
#include "vl/String.hpp"
#include "vl/MD5CheckSum.hpp"
#include <map>

Classes

class | vl::VirtualFile
An abstract class representing a file. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

ref< VirtualFile > | vl::locateFile (const String &path)
Utility function, equivalent to vl::VisualizationLibrary::fileSystem()->locateFile(path).
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.cpp File Reference

#include "../license_signature.vls"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FontManager.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/Time.hpp"
#include "vl/Rendering.hpp"
#include "vl/FileSystem.hpp"
#include "vl/DiskDirectory.hpp"
#include "vl/ZippedDirectory.hpp"
#include "vl/MemoryDirectory.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/GeometryLoadCallback.hpp"
#include "vl/quat.hpp"
#include "vl/Object.hpp"
#include "vl/KeyValues.hpp"
#include "ft2build.h"
#include "vl/vlJPG.hpp"
#include "vl/vlPNG.hpp"
#include "vl/vlTIFF.hpp"
#include "vl/vlTGA.hpp"
#include "vl/vlDAT.hpp"
#include "vl/vlDDS.hpp"
#include "vl/vlBMP.hpp"
#include "vl/vl3DS.hpp"
#include "vl/vlOBJ.hpp"
#include "vl/vlAC3D.hpp"
#include "vl/vlPLY.hpp"
#include "vl/vlMD2.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/VisualizationLibrary.hpp File Reference

#include "vl/VirtualFile.hpp"
#include "vl/version.hpp"

Classes

class | vl::VisualizationLibrary
Used to initialize/shutdown VisualizationLibrary and to access important global data. More...

Namespaces

namespace | vl
Visualization Library namespace.

Functions

void | vl::showWin32Console ()
Shows a console window that displays the standard output. This function is to be used only under Windows.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.cpp File Reference

#include "vl/vl3DS.hpp"
#include "vl/Effect.hpp"
#include "vl/Geometry.hpp"
#include "vl/Actor.hpp"
#include "vl/Texture.hpp"
#include "vl/Image.hpp"
#include "vl/Camera.hpp"
#include "vl/Time.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include <set>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vl3DS.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"
#include "vl/String.hpp"
#include <vector>

Classes

class | vl::LoadWriter3DS
The LoadWriter3DS class is a ResourceLoadWriter capable of reading 3DS files. More...
class | vl::A3DSTexture
The A3DSTexture class represents a texture in a 3DS file. More...
class | vl::A3DSMaterial
The A3DSMaterial class represents a material in a 3DS file. More...
class | vl::A3DSTriFace
The A3DSTriFace class represents a triangle in a 3DS file. More...
class | vl::A3DSMaterialFaceMapping
The A3DSMaterialFaceMapping class represents the material/face mapping in a 3DS file. More...
class | vl::A3DSVertex
The A3DSVertex class represents a vertex in a 3DS file. More...
class | vl::A3DSObject
The A3DSObject class represents an object in a 3DS file. More...
class | vl::A3DSLoader
The A3DSLoader class loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | Load3DS_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::load3DS (VirtualFile *file)
ref< ResourceDatabase > | vl::load3DS (const String &path)

Define Documentation

#define Load3DS_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.cpp File Reference

#include "vl/vlAC3D.hpp"
#include "vl/checks.hpp"
#include "vl/Effect.hpp"
#include "vl/Geometry.hpp"
#include "vl/Image.hpp"
#include "vl/Texture.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/TextStream.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/DoubleVertexRemover.hpp"
#include <map>
#include "vl/LoadWriterManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlAC3D.hpp File Reference

#include "vl/Vector3.hpp"
#include "vl/Actor.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterAC3D
The LoadWriterAC3D class is a ResourceLoadWriter capable of reading AC3D files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | LoadAC3D_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::loadAC3D (VirtualFile *file)
Loads and AC3D file (.ac).
ref< ResourceDatabase > | vl::loadAC3D (const String &path)
Loads and AC3D file (.ac).

Define Documentation

#define LoadAC3D_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.cpp File Reference

#include "vl/vlBMP.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include "Image_Tools.cpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlBMP.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterBMP
The LoadWriterBMP class is a ResourceLoadWriter capable of reading BMP files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioBMP_INCLUDE_ONCE

Functions

ref< Image > | vl::loadBMP (VirtualFile *file)
ref< Image > | vl::loadBMP (const String &path)
Loads a BMP file.
bool | vl::isBMP (VirtualFile *file)

Define Documentation

#define ioBMP_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.cpp File Reference

#include "vl/vlDAT.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include "vl/TextStream.hpp"
#include "Image_Tools.cpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDAT.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterDAT
The LoadWriterDAT class is a ResourceLoadWriter capable of reading DAT files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioDAT_INCLUDE_ONCE

Functions

ref< Image > | vl::loadDAT (VirtualFile *file)
ref< Image > | vl::loadDAT (const String &path)
bool | vl::isDAT (VirtualFile *file)

Define Documentation

#define ioDAT_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.cpp File Reference

#include "vl/vlDDS.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include "Image_Tools.cpp"

Defines

#define | IS_BGRA8(pf)
#define | IS_BGRX8(pf)
#define | IS_BGR8(pf)
#define | IS_GRAY8(pf)
#define | IS_GRAY8_ALPHA8(pf)
#define | IS_PALETTE8(pf) isFOURCC("P8 ", pf.dwFourCC )
#define | IS_DXT1(pf) isFOURCC("DXT1", pf.dwFourCC)
#define | IS_DXT3(pf) isFOURCC("DXT3", pf.dwFourCC)
#define | IS_DXT5(pf) isFOURCC("DXT5", pf.dwFourCC)

Enumerations

enum

Define Documentation

#define IS_BGRA8 ( pf )

Value:

((pf.dwFlags & DDPF_RGB) && \
     (pf.dwFlags & DDPF_ALPHAPIXELS) && \
     (pf.dwRGBBitCount == 32))

#define IS_BGRX8 ( pf )

Value:

((pf.dwFlags & DDPF_RGB) && \
     !(pf.dwFlags & DDPF_ALPHAPIXELS) && \
     (pf.dwRGBBitCount == 32))

#define IS_BGR8 ( pf )

Value:

((pf.dwFlags & DDPF_RGB) && \
    !(pf.dwFlags & DDPF_ALPHAPIXELS) && \
     (pf.dwRGBBitCount == 24))

#define IS_GRAY8 ( pf )

Value:

((((pf.dwFlags & DDPF_LUMINANCE) || (pf.dwFlags & DDPF_ALPHA) ) && \
    (pf.dwRGBBitCount == 8) && !(pf.dwFlags & DDPF_ALPHAPIXELS) ) || \
     isFOURCC("G8  ", pf.dwFourCC ) )

#define IS_GRAY8_ALPHA8 ( pf )

Value:

(((pf.dwFlags & DDPF_LUMINANCE) && \
    (pf.dwRGBBitCount == 16) && (pf.dwFlags & DDPF_ALPHAPIXELS)) || \
     isFOURCC("AG8 ", pf.dwFourCC ) )

#define IS_PALETTE8 ( pf ) isFOURCC("P8 ", pf.dwFourCC )

#define IS_DXT1 ( pf ) isFOURCC("DXT1", pf.dwFourCC)

#define IS_DXT3 ( pf ) isFOURCC("DXT3", pf.dwFourCC)

#define IS_DXT5 ( pf ) isFOURCC("DXT5", pf.dwFourCC)

Enumeration Type Documentation

anonymous enum

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDDS.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterDDS
The LoadWriterDDS class is a ResourceLoadWriter capable of reading DDS files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioDDS_INCLUDE_ONCE

Functions

ref< Image > | vl::loadDDS (VirtualFile *file)
ref< Image > | vl::loadDDS (const String &path)
Loads a DDS file.
bool | vl::isDDS (VirtualFile *file)

Define Documentation

#define ioDDS_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.cpp File Reference

#include "vl/vlDICOM.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/GLSLmath.hpp"
#include "vl/FileSystem.hpp"
#include "gdcmReader.h"
#include "gdcmWriter.h"
#include "gdcmAttribute.h"
#include "gdcmImageReader.h"
#include "gdcmImageWriter.h"
#include "gdcmImage.h"
#include "gdcmPhotometricInterpretation.h"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlDICOM.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"
#include "vl/Image.hpp"

Classes

class | vl::LoadWriterDICOM
The LoadWriterDICOM class is a ResourceLoadWriter capable of reading DICOM files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioDICOM_INCLUDE_ONCE

Functions

ref< Image > | vl::loadDICOM (VirtualFile *file)
Loads a DICOM file.
ref< Image > | vl::loadDICOM (const String &path)
Loads a DICOM file.
bool | vl::saveDICOM (const Image *src, const String &path)
Writes a DICOM file.
bool | vl::saveDICOM (const Image *src, VirtualFile *file)
Writes a DICOM file.
bool | vl::isDICOM (VirtualFile *file)
Checks if the given file is a DICOM file.

Define Documentation

#define ioDICOM_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.cpp File Reference

#include "vl/vlJPG.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include "vl/LoadWriterManager.hpp"
#include <jpeglib.h>
#include <jconfig.h>
#include <jerror.h>
#include <jmorecfg.h>
#include <setjmp.h>
#include <cstdio>

Defines

#define | INPUT_BUF_SIZE 4096
#define | OUTPUT_BUF_SIZE 4096

Define Documentation

#define INPUT_BUF_SIZE 4096

#define OUTPUT_BUF_SIZE 4096

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlJPG.hpp File Reference

#include "vl/Object.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterJPG
The LoadWriterJPG class is a ResourceLoadWriter capable of reading JPG files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioJPG_INCLUDE_ONCE

Functions

ref< Image > | vl::loadJPG (VirtualFile *file)
ref< Image > | vl::loadJPG (const String &path)
bool | vl::isJPG (VirtualFile *file)
bool | vl::saveJPG (const Image *src, const String &path, int quality=95)
bool | vl::saveJPG (const Image *src, VirtualFile *file, int quality=95)

Define Documentation

#define ioJPG_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.cpp File Reference

#include "vl/vlMD2.hpp"
#include "vl/Time.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/DoubleVertexRemover.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlMD2.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/MorphingActor.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterMD2
The LoadWriterMD2 class is a ResourceLoadWriter capable of reading MD2 files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | LoadMD2_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::loadMD2 (const String &path)
ref< ResourceDatabase > | vl::loadMD2 (VirtualFile *file)

Define Documentation

#define LoadMD2_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlnamespace.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlnamespace.hpp File Reference

Visualization Library's enums in the 'vl' namespace. More...

#include "vl/OpenGL.hpp"
#include "vl/config.hpp"
#include "vl/version.hpp"

Namespaces

namespace | vl
Visualization Library namespace.

Enumerations

enum vl::ETextureFormat {
vl::TF_ALPHA = GL_ALPHA, vl::TF_ALPHA4 = GL_ALPHA4, vl::TF_ALPHA8 = GL_ALPHA8, vl::TF_ALPHA12 = GL_ALPHA12,
vl::TF_ALPHA16 = GL_ALPHA16, vl::TF_INTENSITY = GL_INTENSITY, vl::TF_INTENSITY4 = GL_INTENSITY4, vl::TF_INTENSITY8 = GL_INTENSITY8,
vl::TF_INTENSITY12 = GL_INTENSITY12, vl::TF_INTENSITY16 = GL_INTENSITY16, vl::TF_LUMINANCE = GL_LUMINANCE, vl::TF_LUMINANCE4 = GL_LUMINANCE4,
vl::TF_LUMINANCE8 = GL_LUMINANCE8, vl::TF_LUMINANCE12 = GL_LUMINANCE12, vl::TF_LUMINANCE16 = GL_LUMINANCE16, vl::TF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA,
vl::TF_LUMINANCE4_ALPHA4 = GL_LUMINANCE4_ALPHA4, vl::TF_LUMINANCE6_ALPHA2 = GL_LUMINANCE6_ALPHA2, vl::TF_LUMINANCE8_ALPHA8 = GL_LUMINANCE8_ALPHA8, vl::TF_LUMINANCE12_ALPHA4 = GL_LUMINANCE12_ALPHA4,
vl::TF_LUMINANCE12_ALPHA12 = GL_LUMINANCE12_ALPHA12, vl::TF_LUMINANCE16_ALPHA16 = GL_LUMINANCE16_ALPHA16, vl::TF_R3_G3_B2 = GL_R3_G3_B2, vl::TF_RGB = GL_RGB,
vl::TF_RGB4 = GL_RGB4, vl::TF_RGB5 = GL_RGB5, vl::TF_RGB8 = GL_RGB8, vl::TF_RGB10 = GL_RGB10,
vl::TF_RGB12 = GL_RGB12, vl::TF_RGB16 = GL_RGB16, vl::TF_RGBA = GL_RGBA, vl::TF_RGBA2 = GL_RGBA2,
vl::TF_RGBA4 = GL_RGBA4, vl::TF_RGB5_A1 = GL_RGB5_A1, vl::TF_RGBA8 = GL_RGBA8, vl::TF_RGB10_A2 = GL_RGB10_A2,
vl::TF_RGBA12 = GL_RGBA12, vl::TF_RGBA16 = GL_RGBA16, vl::TF_RGBA32F = GL_RGBA32F_ARB, vl::TF_RGB32F = GL_RGB32F_ARB,
vl::TF_ALPHA32F = GL_ALPHA32F_ARB, vl::TF_INTENSITY32F = GL_INTENSITY32F_ARB, vl::TF_LUMINANCE32F = GL_LUMINANCE32F_ARB, vl::TF_LUMINANCE_ALPHA32F = GL_LUMINANCE_ALPHA32F_ARB,
vl::TF_RGBA16F = GL_RGBA16F_ARB, vl::TF_RGB16F = GL_RGB16F_ARB, vl::TF_ALPHA16F = GL_ALPHA16F_ARB, vl::TF_INTENSITY16F = GL_INTENSITY16F_ARB,
vl::TF_LUMINANCE16F = GL_LUMINANCE16F_ARB, vl::TF_LUMINANCE_ALPHA16F = GL_LUMINANCE_ALPHA16F_ARB, vl::TF_RGBA_FLOAT32_ATI = GL_RGBA_FLOAT32_ATI, vl::TF_RGB_FLOAT32_ATI = GL_RGB_FLOAT32_ATI,
vl::TF_ALPHA_FLOAT32_ATI = GL_ALPHA_FLOAT32_ATI, vl::TF_INTENSITY_FLOAT32_ATI = GL_INTENSITY_FLOAT32_ATI, vl::TF_LUMINANCE_FLOAT32_ATI = GL_LUMINANCE_FLOAT32_ATI, vl::TF_LUMINANCE_ALPHA_FLOAT32_ATI = GL_LUMINANCE_ALPHA_FLOAT32_ATI,
vl::TF_RGBA_FLOAT16_ATI = GL_RGBA_FLOAT16_ATI, vl::TF_RGB_FLOAT16_ATI = GL_RGB_FLOAT16_ATI, vl::TF_ALPHA_FLOAT16_ATI = GL_ALPHA_FLOAT16_ATI, vl::TF_INTENSITY_FLOAT16_ATI = GL_INTENSITY_FLOAT16_ATI,
vl::TF_LUMINANCE_FLOAT16_ATI = GL_LUMINANCE_FLOAT16_ATI, vl::TF_LUMINANCE_ALPHA_FLOAT16_ATI = GL_LUMINANCE_ALPHA_FLOAT16_ATI, vl::TF_RGB9_E5 = GL_RGB9_E5_EXT, vl::TF_11F_G11F_B10F = GL_R11F_G11F_B10F_EXT,
vl::TF_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, vl::TF_DEPTH_COMPONENT32F = GL_DEPTH_COMPONENT32F_NV, vl::TF_DEPTH32F_STENCIL8 = GL_DEPTH32F_STENCIL8_NV, vl::TF_DEPTH_COMPONENT = GL_DEPTH_COMPONENT,
vl::TF_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16, vl::TF_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24, vl::TF_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32, vl::TF_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA_ARB,
vl::TF_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY_ARB, vl::TF_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE_ARB, vl::TF_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA_ARB, vl::TF_COMPRESSED_RGB = GL_COMPRESSED_RGB_ARB,
vl::TF_COMPRESSED_RGBA = GL_COMPRESSED_RGBA_ARB, vl::TF_COMPRESSED_RGB_FXT1_3DFX = GL_COMPRESSED_RGB_FXT1_3DFX, vl::TF_COMPRESSED_RGBA_FXT1_3DFX = GL_COMPRESSED_RGBA_FXT1_3DFX, vl::TF_COMPRESSED_RGB_S3TC_DXT1 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
vl::TF_COMPRESSED_RGBA_S3TC_DXT1 = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, vl::TF_COMPRESSED_RGBA_S3TC_DXT3 = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, vl::TF_COMPRESSED_RGBA_S3TC_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, vl::TF_COMPRESSED_LUMINANCE_LATC1 = GL_COMPRESSED_LUMINANCE_LATC1_EXT,
vl::TF_COMPRESSED_SIGNED_LUMINANCE_LATC1 = GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, vl::TF_COMPRESSED_LUMINANCE_ALPHA_LATC2 = GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, vl::TF_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 = GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, vl::TF_COMPRESSED_RED_RGTC1 = GL_COMPRESSED_RED_RGTC1_EXT,
vl::TF_COMPRESSED_SIGNED_RED_RGTC1 = GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, vl::TF_COMPRESSED_RED_GREEN_RGTC2 = GL_COMPRESSED_RED_GREEN_RGTC2_EXT, vl::TF_COMPRESSED_SIGNED_RED_GREEN_RGTC2 = GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, vl::TF_RGBA32UI = GL_RGBA32UI_EXT,
vl::TF_RGB32UI = GL_RGB32UI_EXT, vl::TF_ALPHA32UI = GL_ALPHA32UI_EXT, vl::TF_INTENSITY32UI = GL_INTENSITY32UI_EXT, vl::TF_LUMINANCE32UI = GL_LUMINANCE32UI_EXT,
vl::TF_LUMINANCE_ALPHA32UI = GL_LUMINANCE_ALPHA32UI_EXT, vl::TF_RGBA16UI = GL_RGBA16UI_EXT, vl::TF_RGB16UI = GL_RGB16UI_EXT, vl::TF_ALPHA16UI = GL_ALPHA16UI_EXT,
vl::TF_INTENSITY16UI = GL_INTENSITY16UI_EXT, vl::TF_LUMINANCE16UI = GL_LUMINANCE16UI_EXT, vl::TF_LUMINANCE_ALPHA16UI = GL_LUMINANCE_ALPHA16UI_EXT, vl::TF_RGBA8UI = GL_RGBA8UI_EXT,
vl::TF_RGB8UI = GL_RGB8UI_EXT, vl::TF_ALPHA8UI = GL_ALPHA8UI_EXT, vl::TF_INTENSITY8UI = GL_INTENSITY8UI_EXT, vl::TF_LUMINANCE8UI = GL_LUMINANCE8UI_EXT,
vl::TF_LUMINANCE_ALPHA8UI = GL_LUMINANCE_ALPHA8UI_EXT, vl::TF_RGBA32I = GL_RGBA32I_EXT, vl::TF_RGB32I = GL_RGB32I_EXT, vl::TF_ALPHA32I = GL_ALPHA32I_EXT,
vl::TF_INTENSITY32I = GL_INTENSITY32I_EXT, vl::TF_LUMINANCE32I = GL_LUMINANCE32I_EXT, vl::TF_LUMINANCE_ALPHA32I = GL_LUMINANCE_ALPHA32I_EXT, vl::TF_RGBA16I = GL_RGBA16I_EXT,
vl::TF_RGB16I = GL_RGB16I_EXT, vl::TF_ALPHA16I = GL_ALPHA16I_EXT, vl::TF_INTENSITY16I = GL_INTENSITY16I_EXT, vl::TF_LUMINANCE16I = GL_LUMINANCE16I_EXT,
vl::TF_LUMINANCE_ALPHA16I = GL_LUMINANCE_ALPHA16I_EXT, vl::TF_RGBA8I = GL_RGBA8I_EXT, vl::TF_RGB8I = GL_RGB8I_EXT, vl::TF_ALPHA8I = GL_ALPHA8I_EXT,
vl::TF_INTENSITY8I = GL_INTENSITY8I_EXT, vl::TF_LUMINANCE8I = GL_LUMINANCE8I_EXT, vl::TF_LUMINANCE_ALPHA8I = GL_LUMINANCE_ALPHA8I_EXT
}
enum vl::EColorBufferFormat {
vl::CBF_RGB = GL_RGB, vl::CBF_RGBA = GL_RGBA, vl::CBF_R3_G3_B2 = GL_R3_G3_B2, vl::CBF_RGB4 = GL_RGB4,
vl::CBF_RGB5 = GL_RGB5, vl::CBF_RGB8 = GL_RGB8, vl::CBF_RGB10 = GL_RGB10, vl::CBF_RGB12 = GL_RGB12,
vl::CBF_RGB16 = GL_RGB16, vl::CBF_RGBA2 = GL_RGBA2, vl::CBF_RGBA4 = GL_RGBA4, vl::CBF_RGB5_A1 = GL_RGB5_A1,
vl::CBF_RGBA8 = GL_RGBA8, vl::CBF_RGB10_A2 = GL_RGB10_A2, vl::CBF_RGBA12 = GL_RGBA12, vl::CBF_RGBA16 = GL_RGBA16,
vl::CBF_FLOAT_R_NV = GL_FLOAT_R_NV, vl::CBF_FLOAT_RG_NV = GL_FLOAT_RG_NV, vl::CBF_FLOAT_RGB_NV = GL_FLOAT_RGB_NV, vl::CBF_FLOAT_RGBA_NV = GL_FLOAT_RGBA_NV,
vl::CBF_FLOAT_R16_NV = GL_FLOAT_R16_NV, vl::CBF_FLOAT_RG16_NV = GL_FLOAT_RG16_NV, vl::CBF_FLOAT_RGB16_NV = GL_FLOAT_RGB16_NV, vl::CBF_FLOAT_RGBA16_NV = GL_FLOAT_RGBA16_NV,
vl::CBF_FLOAT_R32_NV = GL_FLOAT_R32_NV, vl::CBF_FLOAT_RG32_NV = GL_FLOAT_RG32_NV, vl::CBF_FLOAT_RGB32_NV = GL_FLOAT_RGB32_NV, vl::CBF_FLOAT_RGBA32_NV = GL_FLOAT_RGBA32_NV,
vl::CBF_RGB9_E5 = GL_RGB9_E5_EXT, vl::CBF_11F_G11F_B10F = GL_R11F_G11F_B10F_EXT
}
enum vl::EAttachmentPoint {
vl::AP_NO_ATTACHMENT = 0, vl::AP_COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT, vl::AP_COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1_EXT, vl::AP_COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2_EXT,
vl::AP_COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3_EXT, vl::AP_COLOR_ATTACHMENT4 = GL_COLOR_ATTACHMENT4_EXT, vl::AP_COLOR_ATTACHMENT5 = GL_COLOR_ATTACHMENT5_EXT, vl::AP_COLOR_ATTACHMENT6 = GL_COLOR_ATTACHMENT6_EXT,
vl::AP_COLOR_ATTACHMENT7 = GL_COLOR_ATTACHMENT7_EXT, vl::AP_COLOR_ATTACHMENT8 = GL_COLOR_ATTACHMENT8_EXT, vl::AP_COLOR_ATTACHMENT9 = GL_COLOR_ATTACHMENT9_EXT, vl::AP_COLOR_ATTACHMENT10 = GL_COLOR_ATTACHMENT10_EXT,
vl::AP_COLOR_ATTACHMENT11 = GL_COLOR_ATTACHMENT11_EXT, vl::AP_COLOR_ATTACHMENT12 = GL_COLOR_ATTACHMENT12_EXT, vl::AP_COLOR_ATTACHMENT13 = GL_COLOR_ATTACHMENT13_EXT, vl::AP_COLOR_ATTACHMENT14 = GL_COLOR_ATTACHMENT14_EXT,
vl::AP_COLOR_ATTACHMENT15 = GL_COLOR_ATTACHMENT15_EXT, vl::AP_DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT_EXT, vl::AP_STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT_EXT
}
enum vl::ETex2DTarget {
vl::T2DT_TEXTURE_2D = GL_TEXTURE_2D, vl::T2DT_TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, vl::T2DT_TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, vl::T2DT_TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
vl::T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, vl::T2DT_TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, vl::T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, vl::T2DT_TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE_ARB,
vl::T2DT_TEXTURE_1D_ARRAY = GL_TEXTURE_1D_ARRAY_EXT
}
enum vl::EImageFormat {
vl::IF_RGB = GL_RGB, vl::IF_RGBA = GL_RGBA, vl::IF_BGR = GL_BGR, vl::IF_BGRA = GL_BGRA,
vl::IF_RED = GL_RED, vl::IF_GREEN = GL_GREEN, vl::IF_BLUE = GL_BLUE, vl::IF_ALPHA = GL_ALPHA,
vl::IF_LUMINANCE = GL_LUMINANCE, vl::IF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA, vl::IF_DEPTH_COMPONENT = GL_DEPTH_COMPONENT, vl::IF_STENCIL_INDEX = GL_STENCIL_INDEX,
vl::IF_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, vl::IF_COMPRESSED_RGB_S3TC_DXT1 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT, vl::IF_COMPRESSED_RGBA_S3TC_DXT1 = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, vl::IF_COMPRESSED_RGBA_S3TC_DXT3 = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
vl::IF_COMPRESSED_RGBA_S3TC_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, vl::IF_RED_INTEGER = GL_RED_INTEGER_EXT, vl::IF_GREEN_INTEGER = GL_GREEN_INTEGER_EXT, vl::IF_BLUE_INTEGER = GL_BLUE_INTEGER_EXT,
vl::IF_ALPHA_INTEGER = GL_ALPHA_INTEGER_EXT, vl::IF_RGB_INTEGER = GL_RGB_INTEGER_EXT, vl::IF_RGBA_INTEGER = GL_RGBA_INTEGER_EXT, vl::IF_BGR_INTEGER = GL_BGR_INTEGER_EXT,
vl::IF_BGRA_INTEGER = GL_BGRA_INTEGER_EXT, vl::IF_LUMINANCE_INTEGER = GL_LUMINANCE_INTEGER_EXT, vl::IF_LUMINANCE_ALPHA_INTEGER = GL_LUMINANCE_ALPHA_INTEGER_EXT
}
enum vl::EDepthType {
vl::DT_DEPTH_COMPONENT = GL_DEPTH_COMPONENT, vl::DT_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16, vl::DT_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24, vl::DT_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32,
vl::DT_DEPTH_COMPONENT32F = GL_DEPTH_COMPONENT32F_NV
}
enum | vl::EStencilType { vl::ST_STENCIL_INDEX1 = GL_STENCIL_INDEX1_EXT, vl::ST_STENCIL_INDEX4 = GL_STENCIL_INDEX4_EXT, vl::ST_STENCIL_INDEX8 = GL_STENCIL_INDEX8_EXT, vl::ST_STENCIL_INDEX16 = GL_STENCIL_INDEX16_EXT }
enum | vl::EDepthStencilType { vl::DST_DEPTH_STENCIL = GL_DEPTH_STENCIL_EXT, vl::DST_DEPTH24_STENCIL8 = GL_DEPTH_STENCIL_EXT, vl::DST_DEPTH32F_STENCIL8 = GL_DEPTH32F_STENCIL8_NV }
enum vl::EClearFlags {
vl::CF_DO_NOT_CLEAR = 0, vl::CF_CLEAR_COLOR = GL_COLOR_BUFFER_BIT, vl::CF_CLEAR_DEPTH = GL_DEPTH_BUFFER_BIT, vl::CF_CLEAR_STENCIL = GL_STENCIL_BUFFER_BIT,
vl::CF_CLEAR_COLOR_DEPTH = CF_CLEAR_COLOR + CF_CLEAR_DEPTH, vl::CF_CLEAR_COLOR_STENCIL = CF_CLEAR_COLOR + CF_CLEAR_STENCIL, vl::CF_CLEAR_DEPTH_STENCIL = CF_CLEAR_DEPTH + CF_CLEAR_STENCIL, vl::CF_CLEAR_COLOR_DEPTH_STENCIL = CF_CLEAR_COLOR + CF_CLEAR_DEPTH + CF_CLEAR_STENCIL
}
enum | vl::EClearColorMode { vl::CCM_Float, vl::CCM_Int, vl::CCM_UInt }
enum vl::EBlendFactor {
vl::BF_ZERO = GL_ZERO, vl::BF_ONE = GL_ONE, vl::BF_SRC_COLOR = GL_SRC_COLOR, vl::BF_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR,
vl::BF_DST_COLOR = GL_DST_COLOR, vl::BF_ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR, vl::BF_SRC_ALPHA = GL_SRC_ALPHA, vl::BF_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA,
vl::BF_DST_ALPHA = GL_DST_ALPHA, vl::BF_ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA, vl::BF_CONSTANT_COLOR = GL_CONSTANT_COLOR, vl::BF_ONE_MINUS_CONSTANT_COLOR = GL_ONE_MINUS_CONSTANT_COLOR,
vl::BF_CONSTANT_ALPHA = GL_CONSTANT_ALPHA, vl::BF_ONE_MINUS_CONSTANT_ALPHA = GL_ONE_MINUS_CONSTANT_ALPHA, vl::BF_SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE
}
enum vl::ETextureDimension {
vl::TD_TEXTURE_1D = GL_TEXTURE_1D, vl::TD_TEXTURE_2D = GL_TEXTURE_2D, vl::TD_TEXTURE_3D = GL_TEXTURE_3D, vl::TD_TEXTURE_CUBE_MAP = GL_TEXTURE_CUBE_MAP,
vl::TD_TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE_ARB, vl::TD_TEXTURE_1D_ARRAY = GL_TEXTURE_1D_ARRAY_EXT, vl::TD_TEXTURE_2D_ARRAY = GL_TEXTURE_2D_ARRAY_EXT
}
enum | vl::ETexCompareMode { vl::TCM_NONE = GL_NONE, vl::TCM_COMPARE_R_TO_TEXTURE = GL_COMPARE_R_TO_TEXTURE, vl::TCM_COMPARE_REF_DEPTH_TO_TEXTURE = GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT }
enum vl::ETexCompareFunc {
vl::TCF_LEQUAL = GL_LEQUAL, vl::TCF_GEQUAL = GL_GEQUAL, vl::TCF_LESS = GL_LESS, vl::TCF_GREATER = GL_GREATER,
vl::TCF_EQUAL = GL_EQUAL, vl::TCF_NOTEQUAL = GL_NOTEQUAL, vl::TCF_ALWAYS = GL_ALWAYS, vl::TCF_NEVER = GL_NEVER
}
enum | vl::EDepthTextureMode { vl::DTM_LUMINANCE = GL_LUMINANCE, vl::DTM_INTENSITY = GL_INTENSITY, vl::DTM_ALPHA = GL_ALPHA }
enum vl::EReadDrawBuffer {
vl::RDB_NONE = GL_NONE, vl::RDB_FRONT_LEFT = GL_FRONT_LEFT, vl::RDB_FRONT_RIGHT = GL_FRONT_RIGHT, vl::RDB_BACK_LEFT = GL_BACK_LEFT,
vl::RDB_BACK_RIGHT = GL_BACK_RIGHT, vl::RDB_AUX0 = GL_AUX0, vl::RDB_AUX1 = GL_AUX1, vl::RDB_AUX2 = GL_AUX2,
vl::RDB_AUX3 = GL_AUX3, vl::RDB_COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT, vl::RDB_COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1_EXT, vl::RDB_COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2_EXT,
vl::RDB_COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3_EXT, vl::RDB_COLOR_ATTACHMENT4 = GL_COLOR_ATTACHMENT4_EXT, vl::RDB_COLOR_ATTACHMENT5 = GL_COLOR_ATTACHMENT5_EXT, vl::RDB_COLOR_ATTACHMENT6 = GL_COLOR_ATTACHMENT6_EXT,
vl::RDB_COLOR_ATTACHMENT7 = GL_COLOR_ATTACHMENT7_EXT, vl::RDB_COLOR_ATTACHMENT8 = GL_COLOR_ATTACHMENT8_EXT, vl::RDB_COLOR_ATTACHMENT9 = GL_COLOR_ATTACHMENT9_EXT, vl::RDB_COLOR_ATTACHMENT10 = GL_COLOR_ATTACHMENT10_EXT,
vl::RDB_COLOR_ATTACHMENT11 = GL_COLOR_ATTACHMENT11_EXT, vl::RDB_COLOR_ATTACHMENT12 = GL_COLOR_ATTACHMENT12_EXT, vl::RDB_COLOR_ATTACHMENT13 = GL_COLOR_ATTACHMENT13_EXT, vl::RDB_COLOR_ATTACHMENT14 = GL_COLOR_ATTACHMENT14_EXT,
vl::RDB_COLOR_ATTACHMENT15 = GL_COLOR_ATTACHMENT15_EXT
}
enum vl::EImageType {
vl::IT_COMPRESSED_TYPE = 0, vl::IT_UNSIGNED_BYTE = GL_UNSIGNED_BYTE, vl::IT_BYTE = GL_BYTE, vl::IT_UNSIGNED_SHORT = GL_UNSIGNED_SHORT,
vl::IT_SHORT = GL_SHORT, vl::IT_UNSIGNED_INT = GL_UNSIGNED_INT, vl::IT_INT = GL_INT, vl::IT_FLOAT = GL_FLOAT,
vl::IT_UNSIGNED_BYTE_3_3_2 = GL_UNSIGNED_BYTE_3_3_2, vl::IT_UNSIGNED_BYTE_2_3_3_REV = GL_UNSIGNED_BYTE_2_3_3_REV, vl::IT_UNSIGNED_SHORT_5_6_5 = GL_UNSIGNED_SHORT_5_6_5, vl::IT_UNSIGNED_SHORT_5_6_5_REV = GL_UNSIGNED_SHORT_5_6_5_REV,
vl::IT_UNSIGNED_SHORT_4_4_4_4 = GL_UNSIGNED_SHORT_4_4_4_4, vl::IT_UNSIGNED_SHORT_4_4_4_4_REV = GL_UNSIGNED_SHORT_4_4_4_4_REV, vl::IT_UNSIGNED_SHORT_5_5_5_1 = GL_UNSIGNED_SHORT_5_5_5_1, vl::IT_UNSIGNED_SHORT_1_5_5_5_REV = GL_UNSIGNED_SHORT_1_5_5_5_REV,
vl::IT_UNSIGNED_INT_8_8_8_8 = GL_UNSIGNED_INT_8_8_8_8, vl::IT_UNSIGNED_INT_8_8_8_8_REV = GL_UNSIGNED_INT_8_8_8_8_REV, vl::IT_UNSIGNED_INT_10_10_10_2 = GL_UNSIGNED_INT_10_10_10_2, vl::IT_UNSIGNED_INT_2_10_10_10_REV = GL_UNSIGNED_INT_2_10_10_10_REV,
vl::IT_UNSIGNED_INT_5_9_9_9_REV = GL_UNSIGNED_INT_5_9_9_9_REV_EXT, vl::IT_UNSIGNED_INT_10F_11F_11F_REV = GL_UNSIGNED_INT_10F_11F_11F_REV_EXT, vl::IT_UNSIGNED_INT_24_8 = GL_UNSIGNED_INT_24_8_EXT, vl::IT_FLOAT_32_UNSIGNED_INT_24_8_REV = GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV
}
enum vl::EPrimitiveType {
vl::PT_POINTS = GL_POINTS, vl::PT_LINES = GL_LINES, vl::PT_LINE_LOOP = GL_LINE_LOOP, vl::PT_LINE_STRIP = GL_LINE_STRIP,
vl::PT_TRIANGLES = GL_TRIANGLES, vl::PT_TRIANGLE_STRIP = GL_TRIANGLE_STRIP, vl::PT_TRIANGLE_FAN = GL_TRIANGLE_FAN, vl::PT_QUADS = GL_QUADS,
vl::PT_QUAD_STRIP = GL_QUAD_STRIP, vl::PT_POLYGON = GL_POLYGON, vl::PT_LINES_ADJACENCY = GL_LINES_ADJACENCY_EXT, vl::PT_LINE_STRIP_ADJACENCY = GL_LINE_STRIP_ADJACENCY_EXT,
vl::PT_TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY_EXT, vl::PT_TRIANGLE_STRIP_ADJACENCY = GL_TRIANGLE_STRIP_ADJACENCY_EXT
}
enum | vl::EPolygonFace { vl::PF_FRONT = GL_FRONT, vl::PF_BACK = GL_BACK, vl::PF_FRONT_AND_BACK = GL_FRONT_AND_BACK }
enum | vl::EHintMode { vl::HM_FASTEST = GL_FASTEST, vl::HM_NICEST = GL_NICEST, vl::HM_DONT_CARE = GL_DONT_CARE }
enum | vl::EFrontFace { vl::FF_CW = GL_CW, vl::FF_CCW = GL_CCW }
enum vl::EFunction {
vl::FU_NEVER = GL_NEVER, vl::FU_LESS = GL_LESS, vl::FU_EQUAL = GL_EQUAL, vl::FU_LEQUAL = GL_LEQUAL,
vl::FU_GREATER = GL_GREATER, vl::FU_NOTEQUAL = GL_NOTEQUAL, vl::FU_GEQUAL = GL_GEQUAL, vl::FU_ALWAYS = GL_ALWAYS
}
enum | vl::EPolygonMode { vl::PM_FILL = GL_FILL, vl::PM_LINE = GL_LINE, vl::PM_POINT = GL_POINT }
enum | vl::EShadeModel { vl::SM_FLAT = GL_FLAT, vl::SM_SMOOTH = GL_SMOOTH }
enum vl::EBlendEquation {
vl::BE_FUNC_ADD = GL_FUNC_ADD, vl::BE_FUNC_SUBTRACT = GL_FUNC_SUBTRACT, vl::BE_FUNC_REVERSE_SUBTRACT = GL_FUNC_REVERSE_SUBTRACT, vl::BE_MIN = GL_MIN,
vl::BE_MAX = GL_MAX
}
enum vl::EColorMaterial {
vl::CM_EMISSION = GL_EMISSION, vl::CM_AMBIENT = GL_AMBIENT, vl::CM_DIFFUSE = GL_DIFFUSE, vl::CM_SPECULAR = GL_SPECULAR,
vl::CM_AMBIENT_AND_DIFFUSE = GL_AMBIENT_AND_DIFFUSE
}
enum | vl::EColorControl { vl::CC_SEPARATE_SPECULAR_COLOR = GL_SEPARATE_SPECULAR_COLOR, vl::CC_SINGLE_COLOR = GL_SINGLE_COLOR }
enum | vl::EFogMode { vl::FM_LINEAR = GL_LINEAR, vl::FM_EXP = GL_EXP, vl::FM_EXP2 = GL_EXP2 }
enum vl::ELogicOp {
vl::LO_CLEAR = GL_CLEAR, vl::LO_SET = GL_SET, vl::LO_COPY = GL_COPY, vl::LO_COPY_INVERTED = GL_COPY_INVERTED,
vl::LO_NOOP = GL_NOOP, vl::LO_INVERT = GL_INVERT, vl::LO_AND = GL_AND, vl::LO_NAND = GL_NAND,
vl::LO_OR = GL_OR, vl::LO_NOR = GL_NOR, vl::LO_XOR = GL_XOR, vl::LO_EQUIV = GL_EQUIV,
vl::LO_AND_REVERSE = GL_AND_REVERSE, vl::LO_AND_INVERTED = GL_AND_INVERTED, vl::LO_OR_REVERSE = GL_OR_REVERSE, vl::LO_OR_INVERTED = GL_OR_INVERTED
}
enum vl::EStencilOp {
vl::SO_KEEP = GL_KEEP, vl::SO_ZERO = GL_ZERO, vl::SO_REPLACE = GL_REPLACE, vl::SO_INCR = GL_INCR,
vl::SO_INCR_WRAP = GL_INCR_WRAP, vl::SO_DECR = GL_DECR, vl::SO_DECR_WRAP = GL_DECR_WRAP, vl::SO_INVERT = GL_INVERT
}
enum vl::ETexParamFilter {
vl::TPF_NEAREST = GL_NEAREST, vl::TPF_LINEAR = GL_LINEAR, vl::TPF_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST, vl::TPF_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
vl::TPF_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR, vl::TPF_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
}
enum vl::ETexParamWrap {
vl::TPW_CLAMP = GL_CLAMP, vl::TPW_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER, vl::TPW_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE, vl::TPW_MIRRORED_REPEAT = GL_MIRRORED_REPEAT,
vl::TPW_REPEAT = GL_REPEAT
}
enum vl::ETexEnvMode {
vl::TEM_DECAL = GL_DECAL, vl::TEM_MODULATE = GL_MODULATE, vl::TEM_ADD = GL_ADD, vl::TEM_BLEND = GL_BLEND,
vl::TEM_REPLACE = GL_REPLACE, vl::TEM_COMBINE = GL_COMBINE, vl::TEM_ADD_SIGN = GL_ADD_SIGNED, vl::TEM_INTERPOLATE = GL_INTERPOLATE,
vl::TEM_SUBTRACT = GL_SUBTRACT, vl::TEM_DOT3_RGB = GL_DOT3_RGB, vl::TEM_DOT3_RGBA = GL_DOT3_RGBA
}
enum vl::ETexEnvSource {
vl::TES_TEXTURE = GL_TEXTURE, vl::TES_TEXTURE0 = GL_TEXTURE0, vl::TES_TEXTURE1 = GL_TEXTURE1, vl::TES_TEXTURE2 = GL_TEXTURE2,
vl::TES_TEXTURE3 = GL_TEXTURE3, vl::TES_TEXTURE4 = GL_TEXTURE4, vl::TES_TEXTURE5 = GL_TEXTURE5, vl::TES_TEXTURE6 = GL_TEXTURE6,
vl::TES_TEXTURE7 = GL_TEXTURE7, vl::TES_CONSTANT = GL_CONSTANT, vl::TES_PRIMARY_COLOR = GL_PRIMARY_COLOR, vl::TES_PREVIOUS = GL_PREVIOUS
}
enum | vl::ETexEnvOperand { vl::TEO_SRC_COLOR = GL_SRC_COLOR, vl::TEO_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR, vl::TEO_SRC_ALPHA = GL_SRC_ALPHA, vl::TEO_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA }
enum vl::ETexGenMode {
vl::TGM_DISABLED = 0, vl::TGM_EYE_LINEAR = GL_EYE_LINEAR, vl::TGM_OBJECT_LINEAR = GL_OBJECT_LINEAR, vl::TGM_SPHERE_MAP = GL_SPHERE_MAP,
vl::TGM_REFLECTION_MAP = GL_REFLECTION_MAP, vl::TGM_NORMAL_MAP = GL_NORMAL_MAP
}
Texture generation modes, see http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information. More...
enum vl::EEnable {
vl::EN_ALPHA_TEST, vl::EN_BLEND, vl::EN_COLOR_LOGIC_OP, vl::EN_LIGHTING,
vl::EN_COLOR_SUM, vl::EN_CULL_FACE, vl::EN_DEPTH_TEST, vl::EN_FOG,
vl::EN_LINE_SMOOTH, vl::EN_LINE_STIPPLE, vl::EN_POLYGON_STIPPLE, vl::EN_NORMALIZE,
vl::EN_POINT_SMOOTH, vl::EN_POINT_SPRITE, vl::EN_POLYGON_SMOOTH, vl::EN_POLYGON_OFFSET_FILL,
vl::EN_POLYGON_OFFSET_LINE, vl::EN_POLYGON_OFFSET_POINT, vl::EN_RESCALE_NORMAL, vl::EN_STENCIL_TEST,
vl::EN_VERTEX_PROGRAM_POINT_SIZE, vl::EN_VERTEX_PROGRAM_TWO_SIDE, vl::EN_MULTISAMPLE, vl::EN_SAMPLE_ALPHA_TO_COVERAGE,
vl::EN_SAMPLE_ALPHA_TO_ONE, vl::EN_SAMPLE_COVERAGE, vl::EN_EnableCount, vl::EN_UnknownEnable
}
Constant that enable/disable a specific OpenGL feature, see also Shader, Shader::enable(), Shader::disable(), Shader::isEnabled(). More...
enum vl::EGLBufferUsage {
vl::GBU_STREAM_DRAW = GL_STREAM_DRAW, vl::GBU_STREAM_READ = GL_STREAM_READ, vl::GBU_STREAM_COPY = GL_STREAM_COPY, vl::GBU_STATIC_DRAW = GL_STATIC_DRAW,
vl::GBU_STATIC_READ = GL_STATIC_READ, vl::GBU_STATIC_COPY = GL_STATIC_COPY, vl::GBU_DYNAMIC_DRAW = GL_DYNAMIC_DRAW, vl::GBU_DYNAMIC_READ = GL_DYNAMIC_READ,
vl::GBU_DYNAMIC_COPY = GL_DYNAMIC_COPY
}
enum | vl::EGLBufferAccess { vl::GBA_READ_ONLY = GL_READ_ONLY, vl::GBA_WRITE_ONLY = GL_WRITE_ONLY, vl::GBA_READ_WRITE = GL_READ_WRITE }
enum vl::EAlign {
vl::AlignLeft = 1, vl::AlignHCenter = 2, vl::AlignRight = 4, vl::AlignTop = 8,
vl::AlignVCenter = 16, vl::AlignBottom = 32
}
enum | vl::ETextAlign { vl::TextAlignLeft, vl::TextAlignRight, vl::TextAlignCenter, vl::TextAlignJustify }
enum | vl::ETextMode { vl::Text2D = 1, vl::Text3D = 2 }
enum | vl::ETextLayout { vl::LeftToRightText, vl::RightToLeftText, vl::TopToBottomText }
enum | vl::EDepthSortMode { vl::NeverDepthSort, vl::AlwaysDepthSort, vl::AlphaDepthSort }
enum vl::EImageDimension {
vl::ID_Error = 0, vl::ID_1D = 1, vl::ID_2D = 2, vl::ID_3D = 3,
vl::ID_Cubemap = 4
}
enum vl::EStateType {
vl::ST_RenderStates = 1, vl::ST_Enables = 2, vl::ST_TextureUnits = 4, vl::ST_Lights = 8,
vl::ST_ClipPlanes = 16
}
enum vl::ERenderState {
vl::RS_AlphaFunc, vl::RS_BlendColor, vl::RS_BlendEquation, vl::RS_BlendFunc,
vl::RS_ColorMask, vl::RS_CullFace, vl::RS_DepthFunc, vl::RS_DepthMask,
vl::RS_DepthRange, vl::RS_Fog, vl::RS_FrontFace, vl::RS_PolygonMode,
vl::RS_Hint, vl::RS_LightModel, vl::RS_LineStipple, vl::RS_LineWidth,
vl::RS_LogicOp, vl::RS_Material, vl::RS_PixelTransfer, vl::RS_PointParameter,
vl::RS_PointSize, vl::RS_PolygonOffset, vl::RS_PolygonStipple, vl::RS_SampleCoverage,
vl::RS_ShadeModel, vl::RS_StencilFunc, vl::RS_StencilMask, vl::RS_StencilOp,
vl::RS_GLSLProgram, vl::RS_Light0, vl::RS_Light1, vl::RS_Light2,
vl::RS_Light3, vl::RS_Light4, vl::RS_Light5, vl::RS_Light6,
vl::RS_Light7, vl::RS_ClipPlane0, vl::RS_ClipPlane1, vl::RS_ClipPlane2,
vl::RS_ClipPlane3, vl::RS_ClipPlane4, vl::RS_ClipPlane5, vl::RS_TextureUnit0,
vl::RS_TexGen0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*1, vl::RS_TexEnv0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*2, vl::RS_TextureMatrix0 = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*3, vl::RS_COUNT = RS_TextureUnit0 + VL_MAX_TEXTURE_UNIT_COUNT*4,
vl::RS_NONE
}
enum | vl::ERenderingCallback { vl::RC_PreRendering, vl::RC_PostRendering }
enum vl::EGeometryInputType {
vl::GIT_POINTS = GL_POINTS, vl::GIT_LINES = GL_LINES, vl::GIT_LINES_ADJACENCY = GL_LINES_ADJACENCY_EXT, vl::GIT_TRIANGLES = GL_TRIANGLES,
vl::GIT_TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY_EXT
}
enum | vl::EGeometryOutputType { vl::GOT_POINTS = GL_POINTS, vl::GOT_LINE_STRIP = GL_LINE_STRIP, vl::GOT_TRIANGLE_STRIP = GL_TRIANGLE_STRIP }
enum | vl::EBufferBits { vl::BB_COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT, vl::BB_DEPTH_BUFFER_BIT = GL_DEPTH_BUFFER_BIT, vl::BB_STENCIL_BUFFER_BIT = GL_STENCIL_BUFFER_BIT }
enum | vl::EBillboardType { vl::BT_AxisAlignedBillboard = 1, vl::BT_SphericalBillboard = 2 }
enum | vl::ESortMode { vl::SM_SortBackToFront, vl::SM_SortFrontToBack }
enum | vl::EGetMode { vl::GM_GetOrCreate, vl::GM_DontCreate }
enum vl::EStringEncoding {
vl::SE_Unknown, vl::SE_ASCII, vl::SE_UTF8, vl::SE_UTF16_BE,
vl::SE_UTF16_LE, vl::SE_UTF32_BE, vl::SE_UTF32_LE, vl::SE_LATIN1
}
enum | vl::EOpenMode { vl::OM_ReadOnly, vl::OM_WriteOnly }
enum vl::EKey {
vl::Key_None = 0, vl::Key_0, vl::Key_1, vl::Key_2,
vl::Key_3, vl::Key_4, vl::Key_5, vl::Key_6,
vl::Key_7, vl::Key_8, vl::Key_9, vl::Key_A,
vl::Key_B, vl::Key_C, vl::Key_D, vl::Key_E,
vl::Key_F, vl::Key_G, vl::Key_H, vl::Key_I,
vl::Key_J, vl::Key_K, vl::Key_L, vl::Key_M,
vl::Key_N, vl::Key_O, vl::Key_P, vl::Key_Q,
vl::Key_R, vl::Key_S, vl::Key_T, vl::Key_U,
vl::Key_V, vl::Key_W, vl::Key_X, vl::Key_Y,
vl::Key_Z, vl::Key_Return, vl::Key_BackSpace, vl::Key_Tab,
vl::Key_Space, vl::Key_Clear, vl::Key_Escape, vl::Key_Exclam,
vl::Key_QuoteDbl, vl::Key_Hash, vl::Key_Dollar, vl::Key_Ampersand,
vl::Key_Quote, vl::Key_LeftParen, vl::Key_RightParen, vl::Key_Asterisk,
vl::Key_Plus, vl::Key_Comma, vl::Key_Minus, vl::Key_Period,
vl::Key_Slash, vl::Key_Colon, vl::Key_Semicolon, vl::Key_Less,
vl::Key_Equal, vl::Key_Greater, vl::Key_Question, vl::Key_At,
vl::Key_LeftBracket, vl::Key_BackSlash, vl::Key_RightBracket, vl::Key_Caret,
vl::Key_Underscore, vl::Key_QuoteLeft, vl::Key_Ctrl, vl::Key_LeftCtrl,
vl::Key_RightCtrl, vl::Key_Alt, vl::Key_LeftAlt, vl::Key_RightAlt,
vl::Key_Shift, vl::Key_LeftShift, vl::Key_RightShift, vl::Key_Insert,
vl::Key_Delete, vl::Key_Home, vl::Key_End, vl::Key_Print,
vl::Key_Pause, vl::Key_PageUp, vl::Key_PageDown, vl::Key_Left,
vl::Key_Right, vl::Key_Up, vl::Key_Down, vl::Key_F1,
vl::Key_F2, vl::Key_F3, vl::Key_F4, vl::Key_F5,
vl::Key_F6, vl::Key_F7, vl::Key_F8, vl::Key_F9,
vl::Key_F10, vl::Key_F11, vl::Key_F12, vl::Key_Unknown,
vl::Key_NumberOfKeys
}
enum vl::EMouseButton {
vl::NoButton = 0, vl::LeftButton = 1, vl::RightButton = 2, vl::MiddleButton = 4,
vl::UnknownButton
}
enum vl::EInheritance {
vl::IN_Local = 0x00, vl::IN_Propagate = 0x01, vl::IN_Sticky = 0x04, vl::IN_Propagate_Overrides_Sticky = 0x01 | 0x02 | 0x04,
vl::IN_Propagate_Overrides = 0x01 | 0x02, vl::IN_Propagate_Sticky = 0x01 | 0x04
}
enum | vl::EShaderType { vl::ST_VERTEX_SHADER = GL_VERTEX_SHADER, vl::ST_FRAGMENT_SHADER = GL_FRAGMENT_SHADER, vl::ST_GEOMETRY_SHADER = GL_GEOMETRY_SHADER_EXT }
enum vl::ETessellationWinding {
vl::TW_TESS_WINDING_ODD = GLU_TESS_WINDING_ODD, vl::TW_TESS_WINDING_NONZERO = GLU_TESS_WINDING_NONZERO, vl::TW_TESS_WINDING_POSITIVE = GLU_TESS_WINDING_POSITIVE, vl::TW_TESS_WINDING_NEGATIVE = GLU_TESS_WINDING_NEGATIVE,
vl::TW_TESS_WINDING_ABS_GEQ_TWO = GLU_TESS_WINDING_ABS_GEQ_TWO
}

Detailed Description

Visualization Library's enums in the 'vl' namespace.

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.cpp File Reference

#include "vl/vlOBJ.hpp"
#include "vl/TextStream.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/VirtualDirectory.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/DoubleVertexRemover.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/Effect.hpp"
#include "vl/Actor.hpp"
#include <string>
#include <vector>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlOBJ.hpp File Reference

#include "vl/String.hpp"
#include "vl/Geometry.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"
#include <map>

Classes

class | vl::LoadWriterOBJ
The LoadWriterOBJ class is a ResourceLoadWriter capable of reading OBJ files. More...
class | vl::ObjTexture
Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader. More...
class | vl::ObjMaterial
Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader. More...
class | vl::ObjMesh
Represents a Wavefront OBJ mesh. See also ObjLoader. More...
class | vl::ObjLoader
Loads a Wavefront OBJ file. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | LoadOBJ_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::loadOBJ (const String &path)
Loads a Wavefront OBJ file. See also ObjLoader.
ref< ResourceDatabase > | vl::loadOBJ (VirtualFile *file)
Loads a Wavefront OBJ file. See also ObjLoader.

Define Documentation

#define LoadOBJ_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.cpp File Reference

#include "vl/vlPLY.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/TextStream.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Effect.hpp"
#include "vl/Actor.hpp"
#include "vl/LoadWriterManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPLY.hpp File Reference

#include "vl/Geometry.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterPLY
The LoadWriterPLY class is a ResourceLoadWriter capable of reading PLY files. More...
class | vl::PlyLoader
Loads a PLY file. More...
class | vl::PlyLoader::PlyPropertyAbstract
Used by PlyLoader. More...
class | vl::PlyLoader::PlyScalar
Used by PlyLoader. More...
class | vl::PlyLoader::PlyScalarList
Used by PlyLoader. More...
class | vl::PlyLoader::PlyElement
Used by PlyLoader. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | LoadPLY_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::loadPLY (VirtualFile *file)
ref< ResourceDatabase > | vl::loadPLY (const String &path)

Define Documentation

#define LoadPLY_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.cpp File Reference

#include "vl/vlPNG.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include <png.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlPNG.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterPNG
The LoadWriterPNG class is a ResourceLoadWriter capable of reading PNG files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioPNG_INCLUDE_ONCE

Functions

ref< Image > | vl::loadPNG (VirtualFile *file)
ref< Image > | vl::loadPNG (const String &path)
bool | vl::isPNG (VirtualFile *file)
bool | vl::savePNG (const Image *src, const String &path, int compression=6)
bool | vl::savePNG (const Image *src, VirtualFile *file, int compression=6)

Define Documentation

#define ioPNG_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.cpp File Reference

#include "vl/vlSTL.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/TextStream.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Effect.hpp"
#include "vl/Actor.hpp"
#include "vl/LoadWriterManager.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlSTL.hpp File Reference

#include "vl/Geometry.hpp"
#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterSTL
The LoadWriterSTL class is a ResourceLoadWriter capable of reading STL files. More...
class | vl::STLLoader
Loads an STL file. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | LoadSTL_INCLUDE_ONCE

Functions

ref< ResourceDatabase > | vl::loadSTL (VirtualFile *file)
ref< ResourceDatabase > | vl::loadSTL (const String &path)

Define Documentation

#define LoadSTL_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.cpp File Reference

#include "vl/vlTGA.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/DiskFile.hpp"
#include "vl/Image.hpp"
#include "Image_Tools.cpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTGA.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterTGA
The LoadWriterTGA class is a ResourceLoadWriter capable of reading TGA files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioTGA_INCLUDE_ONCE

Functions

ref< Image > | vl::loadTGA (VirtualFile *file)
ref< Image > | vl::loadTGA (const String &path)
Loads a TGA file.
bool | vl::isTGA (VirtualFile *file)
A TGA file is accepted only if it has a 'TGA' extension.
bool | vl::saveTGA (const Image *src, const String &path)
bool | vl::saveTGA (const Image *src, VirtualFile *file)

Define Documentation

#define ioTGA_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.cpp File Reference

#include "vl/vlTIFF.hpp"
#include "vl/LoadWriterManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include "vl/VirtualFile.hpp"
#include "vl/Image.hpp"
#include <tiffio.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/vlTIFF.hpp File Reference

#include "vl/ResourceLoadWriter.hpp"
#include "vl/ResourceDatabase.hpp"

Classes

class | vl::LoadWriterTIFF
The LoadWriterTIFF class is a ResourceLoadWriter capable of reading TIFF files. More...

Namespaces

namespace | vl
Visualization Library namespace.

Defines

#define | ioTIFF_INCLUDE_ONCE

Functions

ref< Image > | vl::loadTIFF (VirtualFile *file)
ref< Image > | vl::loadTIFF (const String &path)
bool | vl::isTIFF (VirtualFile *file)
bool | vl::saveTIFF (const Image *src, const String &path)
bool | vl::saveTIFF (const Image *src, VirtualFile *file)

Define Documentation

#define ioTIFF_INCLUDE_ONCE

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.cpp File Reference

#include "vl/ZippedDirectory.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/FileSystem.hpp"
#include <set>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedDirectory.hpp File Reference

#include "vl/VirtualDirectory.hpp"
#include "vl/DiskFile.hpp"
#include "vl/ZippedFile.hpp"
#include <algorithm>

Classes

class | vl::ZippedDirectory
A VirtualDirectory capable of reading files from a .zip file. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.cpp File Reference

#include "vl/ZippedFile.hpp"
#include "vl/CRC32CheckSum.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include <zlib.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/ZippedFile.hpp File Reference

#include "vl/VirtualFile.hpp"

Classes

class | vl::ZippedFileInfo
Collects the information about a ZippedFile. More...
class | vl::ZippedFile
A VirtualFile used to read a file contained in a .zip archive. More...

Namespaces

namespace | vl
Visualization Library namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.cpp File Reference

#include "vlGLUT/GLUTWindow.hpp"
#include "vlut/Applet.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGLUT/GLUTWindow.hpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vl/Vector4.hpp"
#include <map>
#include <cstdlib>
#include <GL/freeglut.h>

Classes

class | vlGLUT::GLUTWindow
The GLUTWindow class implements an OpenGLContext using the GLUT API. More...

Namespaces

namespace | vlut
Visualization Library utility namespace.
namespace | vlGLUT
The GLUT bindings namespace.

Functions

void | vlGLUT::atexit_visualization_library_shutdown ()
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.cpp File Reference

#include "StdAfx.h"
#include "vlMFC/MFCWindow.hpp"
#include "vlWin32/Win32Window.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/Time.hpp"
#include <shellapi.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/MFCWindow.hpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vlWin32/Win32Context.hpp"

Classes

class | vlMFC::MFCWindow
The MFCWindow class is an MFC CWnd with the functionalities of a Win32Context. More...

Namespaces

namespace | vlMFC
The MFC bindings namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/StdAfx.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMFC/StdAfx.cpp File Reference

#include "stdafx.h"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Atom.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Atom.hpp File Reference

#include "vl/Object.hpp"
#include "vl/Vector4.hpp"
#include "vlMolecule/chem_database.hpp"
#include <vector>

Classes

class | vlMolecule::Atom
The Atom class represents an atom to be used with the Molecule class. More...

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Bond.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Bond.hpp File Reference

#include "vl/Object.hpp"

Classes

class | vlMolecule::Bond
The Bond class represents a bond to be used with the Molecule class. More...

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.

Enumerations

enum vlMolecule::EBondType {
vlMolecule::BT_None, vlMolecule::BT_Single, vlMolecule::BT_Double, vlMolecule::BT_Triple,
vlMolecule::BT_Aromatic, vlMolecule::BT_Amide, vlMolecule::BT_Dummy, vlMolecule::BT_Unknown
}
Bond types. More...
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.cpp File Reference

#include "vlMolecule/chem_database.hpp"

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.

Functions

const AtomInfo & | vlMolecule::atomInfo (EAtomType type)
Returns an AtomInfo representing the properties of the given atom type.
EAtomType | vlMolecule::atomType (const char *type)
Translates a string containing atom type name, atom symbol or a Sybyl type into an EAtomType.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/chem_database.hpp File Reference

#include "vl/Vector4.hpp"
#include "vl/String.hpp"

Classes

class | vlMolecule::AtomInfo
Encapsulates information regarding an atom type. More...

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.

Enumerations

enum vlMolecule::EAtomType {
vlMolecule::AT_Hydrogen, vlMolecule::AT_Helium, vlMolecule::AT_Lithium, vlMolecule::AT_Beryllium,
vlMolecule::AT_Boron, vlMolecule::AT_Carbon, vlMolecule::AT_Nitrogen, vlMolecule::AT_Oxygen,
vlMolecule::AT_Fluorine, vlMolecule::AT_Neon, vlMolecule::AT_Sodium, vlMolecule::AT_Magnesium,
vlMolecule::AT_Aluminium, vlMolecule::AT_Silicon, vlMolecule::AT_Phosphorus, vlMolecule::AT_Sulfur,
vlMolecule::AT_Chlorine, vlMolecule::AT_Argon, vlMolecule::AT_Potassium, vlMolecule::AT_Calcium,
vlMolecule::AT_Scandium, vlMolecule::AT_Titanium, vlMolecule::AT_Vanadium, vlMolecule::AT_Chromium,
vlMolecule::AT_Manganese, vlMolecule::AT_Iron, vlMolecule::AT_Cobalt, vlMolecule::AT_Nickel,
vlMolecule::AT_Copper, vlMolecule::AT_Zinc, vlMolecule::AT_Gallium, vlMolecule::AT_Germanium,
vlMolecule::AT_Arsenic, vlMolecule::AT_Selenium, vlMolecule::AT_Bromine, vlMolecule::AT_Krypton,
vlMolecule::AT_Rubidium, vlMolecule::AT_Strontium, vlMolecule::AT_Yttrium, vlMolecule::AT_Zirconium,
vlMolecule::AT_Niobium, vlMolecule::AT_Molybdenum, vlMolecule::AT_Technetium, vlMolecule::AT_Ruthenium,
vlMolecule::AT_Rhodium, vlMolecule::AT_Palladium, vlMolecule::AT_Silver, vlMolecule::AT_Cadmium,
vlMolecule::AT_Indium, vlMolecule::AT_Tin, vlMolecule::AT_Antimony, vlMolecule::AT_Tellurium,
vlMolecule::AT_Iodine, vlMolecule::AT_Xenon, vlMolecule::AT_Caesium, vlMolecule::AT_Barium,
vlMolecule::AT_Lanthanum, vlMolecule::AT_Cerium, vlMolecule::AT_Praseodymium, vlMolecule::AT_Neodymium,
vlMolecule::AT_Promethium, vlMolecule::AT_Samarium, vlMolecule::AT_Europium, vlMolecule::AT_Gadolinium,
vlMolecule::AT_Terbium, vlMolecule::AT_Dysprosium, vlMolecule::AT_Holmium, vlMolecule::AT_Erbium,
vlMolecule::AT_Thulium, vlMolecule::AT_Ytterbium, vlMolecule::AT_Lutetium, vlMolecule::AT_Hafnium,
vlMolecule::AT_Tantalum, vlMolecule::AT_Tungsten, vlMolecule::AT_Rhenium, vlMolecule::AT_Osmium,
vlMolecule::AT_Iridium, vlMolecule::AT_Platinum, vlMolecule::AT_Gold, vlMolecule::AT_Mercury,
vlMolecule::AT_Thallium, vlMolecule::AT_Lead, vlMolecule::AT_Bismuth, vlMolecule::AT_Polonium,
vlMolecule::AT_Astatine, vlMolecule::AT_Radon, vlMolecule::AT_Francium, vlMolecule::AT_Radium,
vlMolecule::AT_Actinium, vlMolecule::AT_Thorium, vlMolecule::AT_Protactinium, vlMolecule::AT_Uranium,
vlMolecule::AT_Neptunium, vlMolecule::AT_Plutonium, vlMolecule::AT_Americium, vlMolecule::AT_Curium,
vlMolecule::AT_Berkelium, vlMolecule::AT_Californium, vlMolecule::AT_Einsteinium, vlMolecule::AT_Fermium,
vlMolecule::AT_Mendelevium, vlMolecule::AT_Nobelium, vlMolecule::AT_Lawrencium, vlMolecule::AT_Rutherfordium,
vlMolecule::AT_Dubnium, vlMolecule::AT_Seaborgium, vlMolecule::AT_Bohrium, vlMolecule::AT_Hassium,
vlMolecule::AT_Meitnerium, vlMolecule::AT_Darmstadtium, vlMolecule::AT_Roentgenium, vlMolecule::AT_Ununbium,
vlMolecule::AT_Ununtrium, vlMolecule::AT_Ununquadium, vlMolecule::AT_Ununpentium, vlMolecule::AT_Ununhexium,
vlMolecule::AT_Ununseptium, vlMolecule::AT_Ununoctium, vlMolecule::AT_Unknown, vlMolecule::AT_Count
}
Element types. More...

Functions

const AtomInfo & | vlMolecule::atomInfo (EAtomType type)
Returns an AtomInfo representing the properties of the given atom type.
EAtomType | vlMolecule::atomType (const char *type)
Translates a string containing atom type name, atom symbol or a Sybyl type into an EAtomType.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.cpp File Reference

#include "vlMolecule/Molecule.hpp"
#include "vlMolecule/RingExtractor.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule.hpp File Reference

#include "vlMolecule/Atom.hpp"
#include "vlMolecule/Bond.hpp"
#include "vl/Geometry.hpp"
#include "vl/KeyValues.hpp"
#include "vl/Actor.hpp"
#include "vl/ActorTree.hpp"
#include "vl/Text.hpp"

Classes

class | vlMolecule::Molecule
The Molecule class is used to manage and render 3D molecular structures. More...

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.

Enumerations

enum | vlMolecule::EMoleculeStyle { vlMolecule::MS_AtomsOnly, vlMolecule::MS_BallAndStick, vlMolecule::MS_Sticks, vlMolecule::MS_Wireframe }
Defines the main molecule styles. More...

Functions

bool | vlMolecule::loadMOL2 (const vl::String &path, std::vector< vl::ref< Molecule > > &structures)
Loads a Tripos MOL2 file.
bool | vlMolecule::loadMOL2 (vl::VirtualFile *vfile, std::vector< vl::ref< Molecule > > &structures)
Loads a Tripos MOL2 file.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule_rendering.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/Molecule_rendering.cpp File Reference

#include "vlMolecule/Molecule.hpp"
#include "vlut/GeometryPrimitives.hpp"
#include "vl/Text.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/RingExtractor.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/RingExtractor.hpp File Reference

#include "vl/GLSLmath.hpp"
#include <vector>
#include <algorithm>
#include <map>
#include <set>

Classes

class | vlMolecule::RingExtractor
The RingExtractor class traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection. More...

Namespaces

namespace | vlMolecule
The Molecule Visualization namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/vlMOL2.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlMolecule/vlMOL2.cpp File Reference

#include "vl/DiskFile.hpp"
#include "vl/MemoryFile.hpp"
#include "vlMolecule/Molecule.hpp"
#include "vlMolecule/RingExtractor.hpp"
#include "vl/TextStream.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.cpp File Reference

#include "vlQt4/Qt4Widget.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlQt4/Qt4Widget.hpp File Reference

#include <vl/VisualizationLibrary.hpp>
#include <vl/OpenGLContext.hpp>
#include <QtGui/QApplication>
#include <QtGui/QMouseEvent>
#include <QtGui/QWidget>
#include <QtCore/QUrl>
#include <QtCore/QTimer>
#include <QtCore/QObject>
#include <QtOpenGL/QGLWidget>
#include <QtOpenGL/QGLFormat>

Classes

class | vlQt4::Qt4Widget
The Qt4Widget class implements an OpenGLContext using the Trolltech's Qt4 API. More...

Namespaces

namespace | vlQt4
The Qt4 bindings namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.cpp File Reference

#include "vlSDL/SDLWindow.hpp"
#include "vl/OpenGL.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vlut/Applet.hpp"
#include <algorithm>
#include <SDL.h>
#include <map>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlSDL/SDLWindow.hpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vl/String.hpp"
#include "vl/Vector4.hpp"
#include <SDL.h>

Classes

class | vlSDL::SDLWindow
The SDLWindow class implements an OpenGLContext using the SDL API. More...

Namespaces

namespace | vlut
Visualization Library utility namespace.
namespace | vlSDL
The SDL bindings namespace.

Functions

void | vlSDL::messageLoop ()
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.cpp File Reference

#include "vlut/Applet.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vl/SceneManager.hpp"
#include "vl/Time.hpp"
#include "vl/Say.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Applet.hpp File Reference

#include "vl/UIEventListener.hpp"
#include "vl/TrackballManipulator.hpp"
#include "vl/GhostCameraManipulator.hpp"
#include "vl/Rendering.hpp"
#include "vl/SceneManagerActorTree.hpp"

Classes

class | vlut::Applet
The Applet class is an utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline. More...

Namespaces

namespace | vlut
Visualization Library utility namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Colors.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/Colors.hpp File Reference

#include "vl/Vector4.hpp"

Namespaces

namespace | vlut
Visualization Library utility namespace.

Functions

vl::fvec4 | vlut::makeColor (unsigned int color)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.cpp File Reference

#include "vlut/GeometryPrimitives.hpp"
#include "vl/Geometry.hpp"
#include "vl/DoubleVertexRemover.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlut/GeometryPrimitives.hpp File Reference

#include "vl/Vector4.hpp"
#include "vl/Geometry.hpp"
#include "vlut/Colors.hpp"

Namespaces

namespace | vlut
Visualization Library utility namespace.

Enumerations

enum | vlut::ECapsuleCap { vlut::CC_FlatCap, vlut::CC_RoundedCap, vlut::CC_NoCap }

Functions

vl::ref< vl::Geometry > | vlut::makeIcosphere (const vl::vec3 &pos, vl::Real radius=1, int detail=2, bool remove_doubles=true)
Creates a sphere by iteratively subdividing an icosahedron.
vl::ref< vl::Geometry > | vlut::makeCylinder (const vl::vec3 &origin, vl::Real diameter=1, vl::Real height=1, int phi=20, int theta=2, bool top=true, bool bottom=true)
Creates a cylinder.
vl::ref< vl::Geometry > | vlut::makeUVSphere (const vl::vec3 &origin, vl::Real diameter=1, int phi=20, int theta=20)
Creates a uv sphere.
vl::ref< vl::Geometry > | vlut::makeTorus (const vl::vec3 &origin, vl::Real diameter=1, vl::Real thickness=0.2, int phi=10, int theta=10)
Creates torus.
vl::ref< vl::Geometry > | vlut::makeCone (const vl::vec3 &origin, vl::Real diameter=1, vl::Real height=1, int phi=10, bool bottom=true)
Creates a cone.
vl::ref< vl::Geometry > | vlut::makePyramid (const vl::vec3 &origin, vl::Real side=1, vl::Real height=1)
Creates a pyramid.
vl::ref< vl::Geometry > | vlut::makeBox (const vl::vec3 &origin, vl::Real xside=1, vl::Real yside=1, vl::Real zside=1, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | vlut::makeBox (const vl::vec3 &min, const vl::vec3 &max, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | vlut::makeBox (const vl::AABB &aabb, bool tex_coords=true)
Creates a box.
vl::ref< vl::Geometry > | vlut::makeGrid (const vl::vec3 &origin, vl::Real xside, vl::Real zside, int x, int z, bool gen_texcoords=false, vl::fvec2 uv0=vl::fvec2(), vl::fvec2 uv1=vl::fvec2())
Creates a 2D grid.
vl::ref< vl::Geometry > | vlut::makeIcosahedron (const vl::vec3 &origin, vl::Real diameter)
Creates an icosahedron.
vl::ref< vl::Geometry > | vlut::makePoints (const std::vector< vl::vec3 > &pos, const vl::fvec4 &color=vlut::white)
Creates a Geometry representing a set of points.
vl::ref< vl::Geometry > | vlut::makeCircle (vl::vec3 origin, vl::Real radius, int slices=60)
Creates a 2D circle.
vl::ref< vl::Geometry > | vlut::makeCapsule (float radius, float height, int segments, ECapsuleCap top_cap, ECapsuleCap bottom_cap, const vl::fvec4 &top_col, const vl::fvec4 &bottom_col)
Creates a 3d capsule with rounded, flat or no caps.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/SceneManagerVectorGraphics.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/SceneManagerVectorGraphics.hpp File Reference

#include "vl/SceneManager.hpp"
#include "vl/Collection.hpp"
#include "vl/Frustum.hpp"

Classes

class | vlVG::SceneManagerVectorGraphics
The SceneManagerVectorGraphics class is a SceneManager that contains VectorGraphics objects. More...

Namespaces

namespace | vlVG
The Vector Graphics namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/VectorGraphics.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVG/VectorGraphics.hpp File Reference

#include "vl/Image.hpp"
#include "vl/Text.hpp"
#include "vl/Effect.hpp"
#include "vl/SceneManager.hpp"
#include "vl/Clear.hpp"
#include "vl/Scissor.hpp"

Classes

class | vlVG::VectorGraphics
The VectorGraphics class is used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics. More...
class | vlVG::VectorGraphics::ImageState
class | vlVG::VectorGraphics::State

Namespaces

namespace | vlVG
The Vector Graphics namespace.

Enumerations

enum | vlVG::ETextureMode { vlVG::TextureMode_Clamp, vlVG::TextureMode_Repeat }
Defines how the texture is applied to the rendering primitive. More...
enum vlVG::EPolygonStipple {
vlVG::PolygonStipple_Solid, vlVG::PolygonStipple_Dot, vlVG::PolygonStipple_Chain, vlVG::PolygonStipple_HLine,
vlVG::PolygonStipple_VLine
}
Poligon stipple patterns. More...
enum vlVG::ELineStipple {
vlVG::LineStipple_Solid, vlVG::LineStipple_Dot, vlVG::LineStipple_Dash, vlVG::LineStipple_Dash4,
vlVG::LineStipple_Dash8, vlVG::LineStipple_DashDot, vlVG::LineStipple_DashDotDot
}
Line stipple patterns. More...
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.cpp File Reference

#include "vlVolume/MarchingCubes.hpp"
#include "vl/Time.hpp"
#include "vl/DoubleVertexRemover.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/MarchingCubes.hpp File Reference

#include "vl/Geometry.hpp"

Classes

class | vlVolume::Volume
Defines the volume data to be used with a MarchingCube object. More...
struct | vlVolume::Volume::Cube
A Volume cell.
class | vlVolume::VolumeInfo
Defines the volume parameters to be used with a MarchingCube and Volume object. More...
class | vlVolume::MarchingCubes
An efficient implementation of the Marching Cubes algorithm. More...
struct | vlVolume::MarchingCubes::Edge

Namespaces

namespace | vlVolume
The Volume Rendering namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.cpp File Reference

#include "vlVolume/SlicedVolume.hpp"
#include "vl/Time.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/SlicedVolume.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/Light.hpp"

Classes

class | vlVolume::SlicedVolume
An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices. More...

Namespaces

namespace | vlVolume
The Volume Rendering namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.cpp File Reference

#include "vlVolume/VolumePlot.hpp"
#include "vl/SceneManager.hpp"
#include "vl/FontManager.hpp"
#include "vl/VisualizationLibrary.hpp"
#include "vlut/GeometryPrimitives.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlVolume/VolumePlot.hpp File Reference

#include "vl/Actor.hpp"
#include "vl/Geometry.hpp"
#include "vl/Text.hpp"
#include "vl/Effect.hpp"
#include "vl/Transform.hpp"
#include "vl/ActorTreeAbstract.hpp"
#include "vl/SceneManagerActorTree.hpp"
#include "vlVolume/MarchingCubes.hpp"

Classes

class | vlVolume::VolumePlot
Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm. More...
class | vlVolume::VolumePlot::Function
A function to be used with VolumePlot. More...

Namespaces

namespace | vl
Visualization Library namespace.
namespace | vlVolume
The Volume Rendering namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.cpp File Reference

#include "vlWin32/Win32Context.hpp"
#include "vl/Log.hpp"
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Context.hpp File Reference

#include "vl/OpenGLContext.hpp"

Classes

class | vlWin32::Win32Context
The Win32Context class implements an OpenGLContext using the Win32 API. More...

Namespaces

namespace | vlWin32
The Win32 bindings namespace.

Functions

int | vlWin32::choosePixelFormat (const vl::OpenGLContextFormat &fmt, bool verbose=true)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.cpp File Reference

#include "vlWin32/Win32Window.hpp"
#include "vl/Log.hpp"
#include "vl/Say.hpp"
#include "vl/Time.hpp"
#include <shellapi.h>
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWin32/Win32Window.hpp File Reference

#include "vl/OpenGLContext.hpp"
#include "vlWin32/Win32Context.hpp"
#include <map>

Classes

class | vlWin32::Win32Window
The Win32Window class is a Win32Context that can be used as a top or child window. More...

Namespaces

namespace | vlWin32
The Win32 bindings namespace.

Functions

int | vlWin32::messageLoop ()
void | vlWin32::peekMessage (MSG &msg)
void | vlWin32::dispatchUpdate ()
void | vlWin32::translateKeyEvent (WPARAM wParam, LPARAM lParam, unsigned short &unicode_out, vl::EKey &key_out)
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.cpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.cpp File Reference

#include "vlWX/vlWXGLCanvas.hpp"

Functions

void translateKey (int &unicode, EKey &key, const wxKeyEvent &ev)

Function Documentation

void translateKey | ( | int & | unicode,
 |  | EKey & | key,
 |  | const wxKeyEvent & | ev
 | ) |  |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.hpp File Reference

  • File List
  • File Members

E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlWX/vlWXGLCanvas.hpp File Reference

#include <vl/OpenGLContext.hpp>
#include <vl/Time.hpp>
#include "wx/frame.h"
#include "wx/glcanvas.h"
#include "wx/timer.h"
#include "wx/dcclient.h"
#include "wx/image.h"
#include "wx/app.h"

Classes

class | vlWX::vlWXGLCanvas
The vlWXGLCanvas class implements a vl::OpenGLContext using the wxWidgets library. More...

Namespaces

namespace | vlWX
The wxWidgets bindings namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:05 2009.


Visualization Library: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Defines
  • e
  • f
  • g
  • i
  • l
  • o
  • s
  • t
  • v
Here is a list of all file members with links to the files they belong to:

- e -

  • err_code : Font.cpp
  • err_msg : Font.cpp

- f -

  • FT_ERROR_END_LIST : Font.cpp
  • FT_ERROR_START_LIST : Font.cpp
  • FT_ERRORDEF : Font.cpp
  • FT_Face : Font.hpp
  • func() : Geometry.cpp

- g -

  • GET_OR_CREATE : Shader.cpp
  • GET_OR_CREATE_IDX : Shader.cpp
  • GLEW_STATIC : OpenGL.hpp

- i -

  • INPUT_BUF_SIZE : vlJPG.cpp
  • ioBMP_INCLUDE_ONCE : vlBMP.hpp
  • ioDAT_INCLUDE_ONCE : vlDAT.hpp
  • ioDDS_INCLUDE_ONCE : vlDDS.hpp
  • ioDICOM_INCLUDE_ONCE : vlDICOM.hpp
  • ioJPG_INCLUDE_ONCE : vlJPG.hpp
  • ioPNG_INCLUDE_ONCE : vlPNG.hpp
  • ioTGA_INCLUDE_ONCE : vlTGA.hpp
  • ioTIFF_INCLUDE_ONCE : vlTIFF.hpp
  • IS_BGR8 : vlDDS.cpp
  • IS_BGRA8 : vlDDS.cpp
  • IS_BGRX8 : vlDDS.cpp
  • IS_DXT1 : vlDDS.cpp
  • IS_DXT3 : vlDDS.cpp
  • IS_DXT5 : vlDDS.cpp
  • IS_GRAY8 : vlDDS.cpp
  • IS_GRAY8_ALPHA8 : vlDDS.cpp
  • IS_PALETTE8 : vlDDS.cpp

- l -

  • Load3DS_INCLUDE_ONCE : vl3DS.hpp
  • LoadAC3D_INCLUDE_ONCE : vlAC3D.hpp
  • LoadMD2_INCLUDE_ONCE : vlMD2.hpp
  • LoadOBJ_INCLUDE_ONCE : vlOBJ.hpp
  • LoadPLY_INCLUDE_ONCE : vlPLY.hpp
  • LoadSTL_INCLUDE_ONCE : vlSTL.hpp

- o -

  • OUTPUT_BUF_SIZE : vlJPG.cpp

- s -

  • SHUFFLE_VERTICES : PolygonSimplifier.cpp

- t -

  • translateKey() : vlWXGLCanvas.cpp

- v -

  • VL_Build : version.hpp
  • VL_BuildType : version.hpp
  • VL_CHECK : checks.hpp
  • VL_CHECK_OGL : OpenGL.hpp
  • VL_DEBUG_LIVING_OBJECTS : config.hpp
  • VL_DEFAULT_BUFFER_BYTE_ALIGNMENT : config.hpp
  • VL_FAST_SQUARE_ROOTS : config.hpp
  • VL_FLOAT_INVSQRT : Vector2.hpp
  • VL_FLOAT_SQRT : Vector2.hpp
  • VL_FORCE_CHECKS : config.hpp
  • VL_glActiveTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glBindBuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBindFragDataLocation() : OpenGL.hpp , OpenGL.cpp
  • VL_glBindFramebuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBindRenderbuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendColor() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendEquation() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendEquationSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendFuncSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlitFramebuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBufferData() : OpenGL.hpp , OpenGL.cpp
  • VL_glBufferSubData() : OpenGL.cpp , OpenGL.hpp
  • VL_glCheckFramebufferStatus() : OpenGL.cpp , OpenGL.hpp
  • VL_glClientActiveTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glDeleteBuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glDeleteFramebuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glDeleteRenderbuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glDisableVertexAttribArray() : OpenGL.cpp , OpenGL.hpp
  • VL_glDrawArraysInstanced() : OpenGL.cpp , OpenGL.hpp
  • VL_glDrawElementsInstanced() : OpenGL.cpp , OpenGL.hpp
  • VL_glEnableVertexAttribArray() : OpenGL.cpp , OpenGL.hpp
  • VL_glFogCoordPointer() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferRenderbuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture1D() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture2D() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture3D() : OpenGL.hpp , OpenGL.cpp
  • VL_glFramebufferTextureLayer() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenBuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenerateMipmap() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenFramebuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenRenderbuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glGetFramebufferAttachmentParameteriv() : OpenGL.hpp , OpenGL.cpp
  • VL_glGetRenderbufferParameteriv() : OpenGL.cpp , OpenGL.hpp
  • VL_glIsFramebuffer() : OpenGL.hpp , OpenGL.cpp
  • VL_glLoadMatrix : config.hpp
  • VL_glMapBuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glMultMatrix : config.hpp
  • VL_glPointParameterf() : OpenGL.cpp , OpenGL.hpp
  • VL_glPointParameterfv() : OpenGL.cpp , OpenGL.hpp
  • VL_glProgramParameteri() : OpenGL.cpp , OpenGL.hpp
  • VL_glRenderbufferStorage() : OpenGL.cpp , OpenGL.hpp
  • VL_glRenderbufferStorageMultisample() : OpenGL.cpp , OpenGL.hpp
  • VL_glSampleCoverage() : OpenGL.hpp , OpenGL.cpp
  • VL_glSecondaryColor3f() : OpenGL.hpp , OpenGL.cpp
  • VL_glSecondaryColorPointer() : OpenGL.hpp , OpenGL.cpp
  • VL_glStencilFuncSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glStencilOpSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glUniform1uiv() : OpenGL.hpp , OpenGL.cpp
  • VL_glUniform2uiv() : OpenGL.hpp , OpenGL.cpp
  • VL_glUniform3uiv() : OpenGL.hpp , OpenGL.cpp
  • VL_glUniform4uiv() : OpenGL.hpp , OpenGL.cpp
  • VL_glUnmapBuffer() : OpenGL.hpp , OpenGL.cpp
  • VL_glVertexAttribIPointer() : OpenGL.hpp , OpenGL.cpp
  • VL_glVertexAttribPointer() : OpenGL.hpp , OpenGL.cpp
  • VL_Major : version.hpp
  • VL_MAX_ACTOR_LOD : config.hpp
  • VL_MAX_EFFECT_LOD : config.hpp
  • VL_MAX_TEXTURE_UNIT_COUNT : config.hpp
  • VL_MAX_TIMERS : config.hpp
  • VL_MESSAGEBOX_CHECK : config.hpp
  • VL_Minor : version.hpp
  • VL_PIPELINE_PRECISION : config.hpp
  • VL_PLATFORM_DEFAULT_ENCODING : String.hpp
  • VL_STRING_COPY_ON_WRITE : config.hpp
  • VL_TRAP : checks.hpp
  • VL_VERBOSITY_LEVEL : config.hpp
  • VL_Version : version.hpp
  • VL_WARN : checks.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Alphabetical List

Class Index

A | B | C | D | E | F | G | H | I | K | L | M | O | P | Q | R | S | T | U | V | W | Z

A
GLSLShader (vl) RayIntersectionGeometry (vl)
A3DSLoader (vl) GLSLVertexShader (vl) RayIntersector (vl)
A3DSMaterial (vl) GLUTWindow (vlGLUT) ReadPixels (vl)
A3DSMaterialFaceMapping (vl) Glyph (vl) Rect (vl)
A3DSObject (vl) GZipCodec (vl) RectF (vl)
A3DSTexture (vl)
H
RectI (vl)
A3DSTriFace (vl) Hint (vl) ref (vl)
A3DSVertex (vl)
I
Renderable (vl)
AABB (vl) Image (vl) Renderer (vl)
Actor (vl) Interpolator (vl) Rendering (vl)
ActorKdTree (vl) InterpolatorDouble (vl) RenderingAbstract (vl)
ActorRenderingCallback (vl) InterpolatorDVec2 (vl) RenderingCallback (vl)
ActorTree (vl) InterpolatorDVec3 (vl) RenderingTree (vl)
ActorTreeAbstract (vl) InterpolatorDVec4 (vl) RenderQueue (vl)
AlphaFunc (vl) InterpolatorFloat (vl) RenderQueueSorter (vl)
Applet (vlut) InterpolatorFVec2 (vl) RenderQueueSorterAggressive (vl)
Array (vl) InterpolatorFVec3 (vl) RenderQueueSorterBasic (vl)
ArrayAbstract (vl) InterpolatorFVec4 (vl) RenderQueueSorterByRenderable (vl)
Atom (vlMolecule)
K
RenderQueueSorterByShader (vl)
AtomInfo (vlMolecule) KeyValues (vl) RenderQueueSorterOcclusion (vl)
B
L
RenderQueueSorterStandard (vl)
BezierPatch (vl) Light (vl) RenderState (vl)
BezierSurface (vl) LightModel (vl) RenderStateSet (vl)
Billboard (vl) LinearInterpolator (vl) RenderTarget (vl)
BlendColor (vl) LinearInterpolatorDouble (vl) RenderToken (vl)
BlendEquation (vl) LinearInterpolatorDVec2 (vl) ResourceDatabase (vl)
BlendFunc (vl) LinearInterpolatorDVec3 (vl) ResourceLoadWriter (vl)
BlitFramebuffer (vl) LinearInterpolatorDVec4 (vl) RingExtractor (vlMolecule)
Bond (vlMolecule) LinearInterpolatorFloat (vl)
S
Buffer (vl) LinearInterpolatorFVec2 (vl) SampleCoverage (vl)
BufferedStream (vl) LinearInterpolatorFVec3 (vl) Say (vl)
C
LinearInterpolatorFVec4 (vl) SayArg (vl)
Camera (vl) LineStipple (vl) SceneManager (vl)
CatmullRomInterpolator (vl) LineWidth (vl) SceneManagerActorKdTree (vl)
CatmullRomInterpolatorDouble (vl) LoadCallback (vl) SceneManagerActorTree (vl)
CatmullRomInterpolatorDVec2 (vl) LoadWriter3DS (vl) SceneManagerBVH (vl)
CatmullRomInterpolatorDVec3 (vl) LoadWriterAC3D (vl) SceneManagerPortals (vl)
CatmullRomInterpolatorDVec4 (vl) LoadWriterBMP (vl) SceneManagerVectorGraphics (vlVG)
CatmullRomInterpolatorFloat (vl) LoadWriterDAT (vl) Scissor (vl)
CatmullRomInterpolatorFVec2 (vl) LoadWriterDDS (vl) SDLWindow (vlSDL)
CatmullRomInterpolatorFVec3 (vl) LoadWriterDICOM (vl) Sector (vl)
CatmullRomInterpolatorFVec4 (vl) LoadWriterJPG (vl) Texture::SetupParams (vl)
Clear (vl) LoadWriterManager (vl) ShadeModel (vl)
ClipPlane (vl) LoadWriterMD2 (vl) Shader (vl)
Collection (vl) LoadWriterOBJ (vl) ShaderNode (vl)
ColorMask (vl) LoadWriterPLY (vl) ShaderSequence (vl)
CopyTexSubImage (vl) LoadWriterPNG (vl) SlicedVolume (vlVolume)
CopyTexSubImage1D (vl) LoadWriterSTL (vl) Sphere (vl)
CopyTexSubImage2D (vl) LoadWriterTGA (vl) StandardLog (vl)
CopyTexSubImage3D (vl) LoadWriterTIFF (vl) StencilFunc (vl)
CRC32CheckSum (vl) LODEvaluator (vl) StencilMask (vl)
CullFace (vl) Log (vl) StencilOp (vl)
D
LogicOp (vl) STLLoader (vl)
DepthFunc (vl)
M
String (vl)
DepthMask (vl) MarchingCubes (vlVolume)
T
DepthRange (vl) Material (vl) Terrain (vl)
DepthSortCallback (vl) Matrix2 (vl) Tessellator (vl)
DiskDirectory (vl) Matrix3 (vl) TexEnv (vl)
DiskFile (vl) Matrix4 (vl) TexGen (vl)
DistanceLODEvaluator (vl) MD5CheckSum (vl) TexParameter (vl)
DoubleVertexRemover (vl) MemoryDirectory (vl) Text (vl)
DrawArrays (vl) MemoryFile (vl) TextStream (vl)
DrawElements (vl) MFCWindow (vlMFC) Texture (vl)
DrawPixels (vl) Molecule (vlMolecule) TextureMatrix (vl)
E
MorphingActor (vl) TextureUnit (vl)
EdgeExtractor::Edge (vl) MorphingCallback (vl) Time (vl)
EdgeExtractor (vl)
O
TrackballManipulator (vl)
EdgeRenderer (vl) Object (vl) Transform (vl)
EdgeUpdateCallback (vl) ObjLoader (vl) PolygonSimplifier::Triangle (vl)
Effect (vl) ObjMaterial (vl) TriangleStripGenerator (vl)
EnableSet (vl) ObjMesh (vl)
U
Extrusion (vl) ObjTexture (vl) UIEventListener (vl)
F
OpenGLContext (vl) Uniform (vl)
FBOAttachmentAbstract (vl) OpenGLContextFormat (vl) UniformSet (vl)
FBOColorBufferAttachment (vl)
P
V
FBODepthBufferAttachment (vl) PixelLODEvaluator (vl) Vector2 (vl)
FBODepthStencilBufferAttachment (vl) DrawPixels::Pixels (vl) Vector3 (vl)
FBORenderbufferAttachment (vl) PixelTransfer (vl) Vector4 (vl)
FBORenderTarget (vl) Plane (vl) VectorGraphics (vlVG)
FBOStencilBufferAttachment (vl) PlyLoader::PlyElement (vl) PolygonSimplifier::Vertex (vl)
FBOTexture1DAttachment (vl) PlyLoader (vl) VertexAttributeArray (vl)
FBOTexture2DAttachment (vl) PlyLoader::PlyPropertyAbstract (vl) VertexMapper (vl)
FBOTexture3DAttachment (vl) PlyLoader::PlyScalar (vl) Viewport (vl)
FBOTextureAttachment (vl) PlyLoader::PlyScalarList (vl) VirtualDirectory (vl)
FBOTextureLayerAttachment (vl) PointParameter (vl) VirtualFile (vl)
FileSystem (vl) PointSize (vl) Sector::VisibilityCallback (vl)
Fog (vl) PolygonMode (vl) VisualizationLibrary (vl)
Font (vl) PolygonOffset (vl) vlWXGLCanvas (vlWX)
FontManager (vl) PolygonSimplifier (vl) Volume (vlVolume)
FrontFace (vl) PolygonStipple (vl) VolumeInfo (vlVolume)
Frustum (vl) Portal (vl) VolumePlot (vlVolume)
VolumePlot::Function (vlVolume) Primitives (vl)
W
G
Q
Win32Context (vlWin32)
Geometry (vl) PolygonSimplifier::QErr (vl) Win32Window (vlWin32)
GeometryLoadCallback (vl) Qt4Widget (vlQt4) WriteCallback (vl)
GhostCameraManipulator (vl) quat (vl)
Z
GLBufferObject (vl)
R
ZippedDirectory (vl)
GLSLFragmentShader (vl) Ray (vl) ZippedFile (vl)
GLSLGeometryShader (vl) RayIntersection (vl) ZippedFileInfo (vl)
GLSLProgram (vl)

A | B | C | D | E | F | G | H | I | K | L | M | O | P | Q | R | S | T | U | V | W | Z

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Member List

vl::A3DSLoader Member List

This is the complete list of members for vl::A3DSLoader, including all inherited members.

A3DSLoader() | vl::A3DSLoader |
mChunkId | vl::A3DSLoader | [protected]
mChunkLen | vl::A3DSLoader | [protected]
mCorrupted | vl::A3DSLoader | [protected]
mInputFile | vl::A3DSLoader | [protected]
mMaterials | vl::A3DSLoader |
mObjects | vl::A3DSLoader |
parse3DS(VirtualFile *file) | vl::A3DSLoader |
read0x3D3D() | vl::A3DSLoader | [protected]
read0x4000() | vl::A3DSLoader | [protected]
read0x4100() | vl::A3DSLoader | [protected]
read0xAFFF() | vl::A3DSLoader | [protected]
readChunk() | vl::A3DSLoader | [protected]
readColByte3() | vl::A3DSLoader | [protected]
readColChunk() | vl::A3DSLoader | [protected]
readColFloat3() | vl::A3DSLoader | [protected]
readFloatPercent() | vl::A3DSLoader | [protected]
readLine() | vl::A3DSLoader | [protected]
readMapChunk() | vl::A3DSLoader | [protected]
readPercentChunk() | vl::A3DSLoader | [protected]
readVec3() | vl::A3DSLoader | [protected]
readWordPercent() | vl::A3DSLoader | [protected]
skipChunk() | vl::A3DSLoader | [protected]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSMaterial Member List

This is the complete list of members for vl::A3DSMaterial, including all inherited members.

A3DSMaterial() | vl::A3DSMaterial | [inline]
mAmbient | vl::A3DSMaterial |
mDiffuse | vl::A3DSMaterial |
mDoubleSided | vl::A3DSMaterial |
mMaterialName | vl::A3DSMaterial |
mShininess | vl::A3DSMaterial |
mShininessStrength | vl::A3DSMaterial |
mSpecular | vl::A3DSMaterial |
mTexture1 | vl::A3DSMaterial |
mTexture2 | vl::A3DSMaterial |
mTransparency | vl::A3DSMaterial |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSMaterialFaceMapping Member List

This is the complete list of members for vl::A3DSMaterialFaceMapping, including all inherited members.

mMappedFace | vl::A3DSMaterialFaceMapping
mMaterialName | vl::A3DSMaterialFaceMapping

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSObject Member List

This is the complete list of members for vl::A3DSObject, including all inherited members.

mCoordSystem | vl::A3DSObject
mFaceList | vl::A3DSObject
mMaterialName | vl::A3DSObject
mMatFaceMap | vl::A3DSObject
mPivotPoint | vl::A3DSObject
mVertices | vl::A3DSObject

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSTexture Member List

This is the complete list of members for vl::A3DSTexture, including all inherited members.

A3DSTexture() | vl::A3DSTexture | [inline]
mFileName | vl::A3DSTexture |
mOpt_decal | vl::A3DSTexture |
mOpt_ignore_alpha | vl::A3DSTexture |
mOpt_mirror | vl::A3DSTexture |
mOpt_negative | vl::A3DSTexture |
mOpt_one_channel_tint | vl::A3DSTexture |
mOpt_rgb_tint | vl::A3DSTexture |
mOpt_summed_area | vl::A3DSTexture |
mOpt_tile | vl::A3DSTexture |
mOpt_use_alpha | vl::A3DSTexture |
mRotation | vl::A3DSTexture |
mUOffset | vl::A3DSTexture |
mUScale | vl::A3DSTexture |
mVOffset | vl::A3DSTexture |
mVScale | vl::A3DSTexture |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSTriFace Member List

This is the complete list of members for vl::A3DSTriFace, including all inherited members.

A3DSTriFace() | vl::A3DSTriFace | [inline]
mA | vl::A3DSTriFace |
mB | vl::A3DSTriFace |
mC | vl::A3DSTriFace |
mFlags | vl::A3DSTriFace |
mMaterialIndex | vl::A3DSTriFace |
mSmoothingGroup | vl::A3DSTriFace |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::A3DSVertex Member List

This is the complete list of members for vl::A3DSVertex, including all inherited members.

A3DSVertex() | vl::A3DSVertex | [inline]
mIndex | vl::A3DSVertex |
mPos | vl::A3DSVertex |
mSmoothingGroup | vl::A3DSVertex |
mUV | vl::A3DSVertex |
operator<(const A3DSVertex &other) const | vl::A3DSVertex | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::AABB Member List

This is the complete list of members for vl::AABB, including all inherited members.

AABB() | vl::AABB |
AABB(const vec3 &center, Real radius) | vl::AABB |
AABB(const vec3 &pt1, const vec3 &pt2, Real displace=0) | vl::AABB |
addPoint(const vec3 &v, Real radius) | vl::AABB |
addPoint(const vec3 &v) | vl::AABB | [inline]
area() const | vl::AABB | [inline]
center() const | vl::AABB |
clip(const vec3 &v, bool clipx=true, bool clipy=true, bool clipz=true) const | vl::AABB |
depth() const | vl::AABB |
enlarge(Real displace) | vl::AABB |
height() const | vl::AABB |
intersects(const AABB &bb) const | vl::AABB |
isInside(const vec3 &v, bool clipx, bool clipy, bool clipz) const | vl::AABB |
isInside(const vec3 &v) const | vl::AABB |
isNull() const | vl::AABB | [inline]
isPoint() const | vl::AABB | [inline]
longestSideLength() const | vl::AABB | [inline]
maxCorner() const | vl::AABB | [inline]
minCorner() const | vl::AABB | [inline]
mMax | vl::AABB | [protected]
mMin | vl::AABB | [protected]
operator+(const AABB &aabb) const | vl::AABB |
operator+(const vec3 &p) | vl::AABB | [inline]
operator+=(const AABB &other) | vl::AABB | [inline]
operator+=(const vec3 &p) | vl::AABB | [inline]
setMaxCorner(Real x, Real y, Real z) | vl::AABB | [inline]
setMaxCorner(const vec3 &v) | vl::AABB | [inline]
setMinCorner(Real x, Real y, Real z) | vl::AABB | [inline]
setMinCorner(const vec3 &v) | vl::AABB | [inline]
setNull() | vl::AABB | [inline]
transformed(AABB &aabb, const mat4 &mat) const | vl::AABB | [inline]
transformed(const mat4 &mat) const | vl::AABB | [inline]
volume() const | vl::AABB | [inline]
width() const | vl::AABB |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Member List

vl::Actor Member List

This is the complete list of members for vl::Actor, including all inherited members.

Actor(Renderable *renderable=NULL, Effect *effect=NULL, Transform *transform=NULL, int block=0, int rank=0) | vl::Actor | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Actor | [inline]
boundingSphere() const | vl::Actor | [inline]
className() | vl::Actor | [inline, virtual]
computeBounds() | vl::Actor |
createOcclusionQuery() | vl::Actor |
decReference() | vl::Object | [inline]
deleteOcclusionQuery() | vl::Actor |
effect() | vl::Actor | [inline]
effect() const | vl::Actor | [inline]
enableMask() const | vl::Actor | [inline]
eraseAllUniforms() | vl::Actor | [inline]
eraseUniform(const std::string &name) | vl::Actor | [inline]
eraseUniform(const Uniform *uniform) | vl::Actor | [inline]
evaluateLOD(Camera *camera) | vl::Actor |
executeRenderingCallbacks(const Camera *camera, Renderable *renderable, const Shader *shader, int pass) | vl::Actor | [inline]
getUniform(const std::string &name) | vl::Actor | [inline]
getUniform(const std::string &name) const | vl::Actor | [inline]
gocUniform(const std::string &name) | vl::Actor | [inline]
incReference() | vl::Object | [inline]
isOccludee() const | vl::Actor | [inline]
lastUpdateTime() const | vl::Actor | [inline]
lod(int lod_index) | vl::Actor | [inline]
lod(int lod_index) const | vl::Actor | [inline]
lodEvaluator() | vl::Actor | [inline]
lodEvaluator() const | vl::Actor | [inline]
mAABB | vl::Actor | [protected]
mBoundsUpdateTick | vl::Actor | [protected]
mEffect | vl::Actor | [protected]
mEnableMask | vl::Actor | [protected]
mIsOccludee | vl::Actor | [protected]
mLastUpdateTime | vl::Actor | [protected]
mLODEvaluator | vl::Actor | [protected]
mName | vl::Object | [protected]
mOcclusionQuery | vl::Actor | [protected]
mOcclusionQueryTick | vl::Actor | [protected]
mRenderables | vl::Actor | [protected]
mRenderBlock | vl::Actor | [protected]
mRenderingCallbacks | vl::Actor | [protected]
mRenderRank | vl::Actor | [protected]
mScissor | vl::Actor | [protected]
mSphere | vl::Actor | [protected]
mTransform | vl::Actor | [protected]
mTransformUpdateTick | vl::Actor | [protected]
mUniformSet | vl::Actor | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
occlusionQuery() const | vl::Actor | [inline]
occlusionQueryTick() const | vl::Actor | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderBlock() const | vl::Actor | [inline]
renderingCallbacks() const | vl::Actor | [inline]
renderingCallbacks() | vl::Actor | [inline]
renderRank() const | vl::Actor | [inline]
scissor() const | vl::Actor | [inline]
scissor() | vl::Actor | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEffect(Effect *effect) | vl::Actor | [inline]
setEnableMask(unsigned int mask) | vl::Actor | [inline]
setLastUpdateTime(Real time) | vl::Actor | [inline]
setLODEvaluator(LODEvaluator *lod_evaluator) | vl::Actor | [inline]
setLODs(Renderable *lod0, Renderable *lod1=NULL, Renderable *lod2=NULL, Renderable *lod3=NULL, Renderable *lod4=NULL, Renderable *lod5=NULL) | vl::Actor | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOccludee(bool is_occludee) | vl::Actor | [inline]
setOcclusionQueryTick(unsigned tick) | vl::Actor | [inline]
setRenderBlock(int block) | vl::Actor | [inline]
setRenderRank(int rank) | vl::Actor | [inline]
setScissor(Scissor *scissor) | vl::Actor | [inline]
setTransform(Transform *transform) | vl::Actor | [inline]
setUniform(Uniform *uniform) | vl::Actor | [inline]
setUniformSet(UniformSet *uniforms) | vl::Actor | [inline]
transform() | vl::Actor | [inline]
transform() const | vl::Actor | [inline]
uniforms() const | vl::Actor | [inline]
uniformSet() const | vl::Actor | [inline]
update(int, Camera *, Real) | vl::Actor | [inline, virtual]
~Actor() | vl::Actor | [virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ActorKdTree Member List

This is the complete list of members for vl::ActorKdTree, including all inherited members.

aabb() const | vl::ActorTreeAbstract | [inline]
ActorKdTree() | vl::ActorKdTree | [inline]
actors() const | vl::ActorTreeAbstract | [inline]
actors() | vl::ActorTreeAbstract | [inline]
ActorTreeAbstract() | vl::ActorTreeAbstract |
addActor(Renderable *renderable, Effect *eff, Transform *tr=NULL) | vl::ActorTreeAbstract |
addActor(Actor *actor) | vl::ActorTreeAbstract |
appendActors(ActorCollection &list) | vl::ActorTreeAbstract |
appendVisibleActors(ActorCollection &list, const Camera *camera, unsigned enable_mask=0xFFFFFFFF) | vl::ActorTreeAbstract |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
child(int i) | vl::ActorKdTree | [virtual]
child(int i) const | vl::ActorKdTree | [virtual]
childN() | vl::ActorKdTree | [inline]
childN() const | vl::ActorKdTree | [inline]
childP() | vl::ActorKdTree | [inline]
childP() const | vl::ActorKdTree | [inline]
childrenCount() const | vl::ActorKdTree | [virtual]
className() | vl::ActorKdTree | [inline, virtual]
compileKdTree(ActorCollection &actors, int max_depth=100, float minimum_volume=0) | vl::ActorKdTree |
compileKdTree(int max_depth=100, float minimum_volume=0) | vl::ActorKdTree |
computeAABB() | vl::ActorTreeAbstract |
decReference() | vl::Object | [inline]
eraseActor(Actor *actor) | vl::ActorTreeAbstract |
harvestNonLeafActors(ActorCollection &actors) | vl::ActorKdTree |
incReference() | vl::Object | [inline]
insertActor(Actor *actor) | vl::ActorKdTree |
kdtreeFromNonLeafyActors(int max_depth=100, float minimum_volume=0) | vl::ActorKdTree |
mAABB | vl::ActorTreeAbstract | [protected]
mActors | vl::ActorTreeAbstract | [protected]
mChildN | vl::ActorKdTree | [protected]
mChildP | vl::ActorKdTree | [protected]
mName | vl::Object | [protected]
mParent | vl::ActorTreeAbstract | [protected]
mPlane | vl::ActorKdTree | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() const | vl::ActorTreeAbstract | [inline]
parent() | vl::ActorTreeAbstract | [inline]
plane() const | vl::ActorKdTree | [inline]
prepareActors(ActorCollection &actors) | vl::ActorTreeAbstract | [static]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setParent(ActorTreeAbstract *p) | vl::ActorTreeAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ActorRenderingCallback Member List

This is the complete list of members for vl::ActorRenderingCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const Camera *cam, Actor *actor, Renderable *renderable, const Shader *shader, int pass)=0 | vl::ActorRenderingCallback | [pure virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Member List

vl::ActorTree Member List

This is the complete list of members for vl::ActorTree, including all inherited members.

aabb() const | vl::ActorTreeAbstract | [inline]
actors() const | vl::ActorTreeAbstract | [inline]
actors() | vl::ActorTreeAbstract | [inline]
ActorTree() | vl::ActorTree | [inline]
ActorTreeAbstract() | vl::ActorTreeAbstract |
addActor(Renderable *renderable, Effect *eff, Transform *tr=NULL) | vl::ActorTreeAbstract |
addActor(Actor *actor) | vl::ActorTreeAbstract |
addChild(ActorTreeAbstract *node) | vl::ActorTree |
appendActors(ActorCollection &list) | vl::ActorTreeAbstract |
appendVisibleActors(ActorCollection &list, const Camera *camera, unsigned enable_mask=0xFFFFFFFF) | vl::ActorTreeAbstract |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
child(int i) | vl::ActorTree | [inline, virtual]
child(int i) const | vl::ActorTree | [inline, virtual]
childrenCount() const | vl::ActorTree | [inline, virtual]
className() | vl::ActorTree | [inline, virtual]
computeAABB() | vl::ActorTreeAbstract |
decReference() | vl::Object | [inline]
eraseActor(Actor *actor) | vl::ActorTreeAbstract |
eraseAllChildren() | vl::ActorTree |
eraseChild(int i, int count=1) | vl::ActorTree |
incReference() | vl::Object | [inline]
mAABB | vl::ActorTreeAbstract | [protected]
mActors | vl::ActorTreeAbstract | [protected]
mChildren | vl::ActorTree |
mName | vl::Object | [protected]
mParent | vl::ActorTreeAbstract | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() const | vl::ActorTreeAbstract | [inline]
parent() | vl::ActorTreeAbstract | [inline]
prepareActors(ActorCollection &actors) | vl::ActorTreeAbstract | [static]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setChild(int i, ActorTreeAbstract *node) | vl::ActorTree |
setName(const std::string &name) | vl::Object | [inline]
setParent(ActorTreeAbstract *p) | vl::ActorTreeAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ActorTreeAbstract Member List

This is the complete list of members for vl::ActorTreeAbstract, including all inherited members.

aabb() const | vl::ActorTreeAbstract | [inline]
actors() const | vl::ActorTreeAbstract | [inline]
actors() | vl::ActorTreeAbstract | [inline]
ActorTreeAbstract() | vl::ActorTreeAbstract |
addActor(Renderable *renderable, Effect *eff, Transform *tr=NULL) | vl::ActorTreeAbstract |
addActor(Actor *actor) | vl::ActorTreeAbstract |
appendActors(ActorCollection &list) | vl::ActorTreeAbstract |
appendVisibleActors(ActorCollection &list, const Camera *camera, unsigned enable_mask=0xFFFFFFFF) | vl::ActorTreeAbstract |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
child(int i)=0 | vl::ActorTreeAbstract | [pure virtual]
child(int i) const =0 | vl::ActorTreeAbstract | [pure virtual]
childrenCount() const =0 | vl::ActorTreeAbstract | [pure virtual]
className() | vl::ActorTreeAbstract | [inline, virtual]
computeAABB() | vl::ActorTreeAbstract |
decReference() | vl::Object | [inline]
eraseActor(Actor *actor) | vl::ActorTreeAbstract |
incReference() | vl::Object | [inline]
mAABB | vl::ActorTreeAbstract | [protected]
mActors | vl::ActorTreeAbstract | [protected]
mName | vl::Object | [protected]
mParent | vl::ActorTreeAbstract | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() const | vl::ActorTreeAbstract | [inline]
parent() | vl::ActorTreeAbstract | [inline]
prepareActors(ActorCollection &actors) | vl::ActorTreeAbstract | [static]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setParent(ActorTreeAbstract *p) | vl::ActorTreeAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::AlphaFunc Member List

This is the complete list of members for vl::AlphaFunc, including all inherited members.

AlphaFunc(EFunction alphafunc=FU_ALWAYS, float refvalue=0) | vl::AlphaFunc | [inline]
alphaFunc() const | vl::AlphaFunc | [inline]
apply(const Camera *) const | vl::AlphaFunc | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::AlphaFunc | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mAlphaFunc | vl::AlphaFunc | [protected]
mName | vl::Object | [protected]
mRefValue | vl::AlphaFunc | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
refValue() const | vl::AlphaFunc | [inline]
RenderState() | vl::RenderState | [inline]
set(EFunction alphafunc, float ref_value) | vl::AlphaFunc | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::AlphaFunc | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Array< vector_type, scalar_type, gl_size, gl_type > Member List

This is the complete list of members for vl::Array< vector_type, scalar_type, gl_size, gl_type >, including all inherited members.

ArrayAbstract() | vl::ArrayAbstract | [inline]
ArrayAbstract(const ArrayAbstract &other) | vl::ArrayAbstract | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
at(int i) | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
at(int i) const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
automaticDelete() const | vl::Object | [inline]
begin() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
begin() | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
bytesPerVector() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
bytesUsed() const | vl::ArrayAbstract | [inline, virtual]
className() | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
clear() | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
clone() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
compare(int a, int b) const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
computeBoundingBox() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
computeBoundingSphere() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
decReference() | vl::Object | [inline]
end() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
end() | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
glSize() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
glType() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
gpuBuffer() const | vl::ArrayAbstract | [inline]
gpuBuffer() | vl::ArrayAbstract | [inline]
incReference() | vl::Object | [inline]
mBufferGPU | vl::ArrayAbstract | [protected]
mName | vl::Object | [protected]
mVBODirty | vl::ArrayAbstract | [protected]
mVBOUsage | vl::ArrayAbstract | [protected]
name() const | vl::Object | [inline]
normalize() | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const std::vector< vector_type > &vector) | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
vl::ArrayAbstract::operator=(const ArrayAbstract &other) | vl::ArrayAbstract | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
operator[](int i) | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
operator[](int i) const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
ptr() const | vl::ArrayAbstract | [inline]
ptr() | vl::ArrayAbstract | [inline]
referenceCount() const | vl::Object | [inline]
resize(int dim) | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
scalarCount() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
scalarCountGPU() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUsage(EGLBufferUsage usage) | vl::ArrayAbstract | [inline]
setVBODirty(bool dirty) | vl::ArrayAbstract | [inline]
size() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
sizeGPU() const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline]
transform(const mat4 &m) | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
updateVBO(bool discard_local_storage=false) | vl::ArrayAbstract | [inline]
usage() const | vl::ArrayAbstract | [inline]
vboDirty() const | vl::ArrayAbstract | [inline]
vectorAsVec4(int vector_index) const | vl::Array< vector_type, scalar_type, gl_size, gl_type > | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ArrayAbstract Member List

This is the complete list of members for vl::ArrayAbstract, including all inherited members.

ArrayAbstract() | vl::ArrayAbstract | [inline]
ArrayAbstract(const ArrayAbstract &other) | vl::ArrayAbstract | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bytesUsed() const | vl::ArrayAbstract | [inline, virtual]
className() | vl::ArrayAbstract | [inline, virtual]
clear() | vl::ArrayAbstract | [inline]
clone() const =0 | vl::ArrayAbstract | [pure virtual]
compare(int a, int b) const =0 | vl::ArrayAbstract | [pure virtual]
computeBoundingBox() const =0 | vl::ArrayAbstract | [pure virtual]
computeBoundingSphere() const =0 | vl::ArrayAbstract | [pure virtual]
decReference() | vl::Object | [inline]
glSize() const =0 | vl::ArrayAbstract | [pure virtual]
glType() const =0 | vl::ArrayAbstract | [pure virtual]
gpuBuffer() const | vl::ArrayAbstract | [inline]
gpuBuffer() | vl::ArrayAbstract | [inline]
incReference() | vl::Object | [inline]
mBufferGPU | vl::ArrayAbstract | [protected]
mName | vl::Object | [protected]
mVBODirty | vl::ArrayAbstract | [protected]
mVBOUsage | vl::ArrayAbstract | [protected]
name() const | vl::Object | [inline]
normalize()=0 | vl::ArrayAbstract | [pure virtual]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const ArrayAbstract &other) | vl::ArrayAbstract | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
ptr() const | vl::ArrayAbstract | [inline]
ptr() | vl::ArrayAbstract | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUsage(EGLBufferUsage usage) | vl::ArrayAbstract | [inline]
setVBODirty(bool dirty) | vl::ArrayAbstract | [inline]
size() const =0 | vl::ArrayAbstract | [pure virtual]
transform(const mat4 &m)=0 | vl::ArrayAbstract | [pure virtual]
updateVBO(bool discard_local_storage=false) | vl::ArrayAbstract | [inline]
usage() const | vl::ArrayAbstract | [inline]
vboDirty() const | vl::ArrayAbstract | [inline]
vectorAsVec4(int vector_index) const =0 | vl::ArrayAbstract | [pure virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::BezierPatch Member List

This is the complete list of members for vl::BezierPatch, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BezierPatch() | vl::BezierPatch | [inline]
BezierPatch(int x, int y) | vl::BezierPatch | [inline]
className() | vl::BezierPatch | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mControlPoints | vl::BezierPatch | [protected]
mName | vl::Object | [protected]
mX | vl::BezierPatch | [protected]
mY | vl::BezierPatch | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
Points typedef | vl::BezierPatch |
points() | vl::BezierPatch | [inline]
points() const | vl::BezierPatch | [inline]
referenceCount() const | vl::Object | [inline]
resize(int x, int y) | vl::BezierPatch |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
x() const | vl::BezierPatch | [inline]
y() const | vl::BezierPatch | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::BezierSurface Member List

This is the complete list of members for vl::BezierSurface, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BezierSurface() | vl::BezierSurface | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::BezierSurface | [inline, virtual]
clearArrays(bool clear_draw_calls=true) | vl::Geometry | [virtual]
colorArray() const | vl::Geometry | [inline]
colorArray() | vl::Geometry | [inline]
colorizePrimitives() | vl::Geometry |
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation() | vl::Geometry | [virtual]
computeNormals() | vl::Geometry |
convertPrimitivesToDrawArrays() | vl::Geometry |
decReference() | vl::Object | [inline]
deepCopy() const | vl::Geometry |
deleteDisplayList() | vl::Renderable | [inline]
deleteVBOs() | vl::Geometry | [virtual]
detail() const | vl::BezierSurface | [inline]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
eraseVertexAttributeByName(unsigned int name) | vl::Geometry |
findVertexAttribute(unsigned int name) const | vl::Geometry |
findVertexAttribute(unsigned int name) | vl::Geometry |
fogCoordArray() const | vl::Geometry | [inline]
fogCoordArray() | vl::Geometry | [inline]
Geometry() | vl::Geometry |
incReference() | vl::Object | [inline]
lineCount() const | vl::Geometry | [virtual]
mDetail | vl::BezierSurface | [protected]
mergeTriangleStrips() | vl::Geometry |
mName | vl::Object | [protected]
mPatches | vl::BezierSurface | [protected]
name() const | vl::Object | [inline]
normalArray() const | vl::Geometry | [inline]
normalArray() | vl::Geometry | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Geometry &other) | vl::Geometry |
vl::Renderable::operator=(const Object &other) | vl::Object | [inline]
patches() | vl::BezierSurface | [inline]
patches() const | vl::BezierSurface | [inline]
pointCount() const | vl::Geometry | [virtual]
primitives() | vl::Geometry | [inline]
primitives() const | vl::Geometry | [inline]
referenceCount() const | vl::Object | [inline]
regenerateVertices(const std::vector< unsigned int > &map_new_to_old) | vl::Geometry |
render(const Actor *, const OpenGLContext *, const Camera *) const | vl::Geometry | [virtual]
Renderable() | vl::Renderable | [inline]
secondaryColorArray() const | vl::Geometry | [inline]
secondaryColorArray() | vl::Geometry | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setColorArray(const fvec4 &col) | vl::Geometry |
setColorArray(ArrayAbstract *data) | vl::Geometry |
setDetail(unsigned i) | vl::BezierSurface | [inline]
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setFogCoordArray(ArrayAbstract *data) | vl::Geometry |
setName(const std::string &name) | vl::Object | [inline]
setNormalArray(ArrayAbstract *data) | vl::Geometry |
setSecondaryColorArray(ArrayAbstract *data) | vl::Geometry |
setTexCoordArray(int tex_unit, ArrayAbstract *data) | vl::Geometry |
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
setVertexArray(ArrayAbstract *data) | vl::Geometry |
setVertexAttributeArray(unsigned int name, bool normalize, bool pure_integer, ArrayAbstract *data) | vl::Geometry | [inline]
setVertexAttributeArray(const VertexAttributeArray &info) | vl::Geometry |
shallowCopy() | vl::Geometry |
shrinkDrawElements() | vl::Geometry |
sortTriangles() | vl::Geometry |
sortVertices() | vl::Geometry |
texCoordArray(int tex_unit) const | vl::Geometry | [inline]
texCoordArray(int tex_unit) | vl::Geometry | [inline]
transform(const mat4 &matr, bool normalize=true) | vl::Geometry |
triangleCount() const | vl::Geometry | [virtual]
updateBezierSurface(bool gen_tex_coords=true) | vl::BezierSurface |
updateVBOs(bool discard_local_data=false) | vl::Geometry | [virtual]
updateVBOs() | vl::Geometry |
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
vertexArray() const | vl::Geometry | [inline]
vertexArray() | vl::Geometry | [inline]
vertexAttributeArrays() | vl::Geometry | [inline]
vertexAttributeArrays() const | vl::Geometry | [inline]
~Geometry() | vl::Geometry | [virtual]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Billboard Member List

This is the complete list of members for vl::Billboard, including all inherited members.

addChild(Transform *child) | vl::Transform |
alwaysIdentityWorldMatrix() | vl::Transform | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
axis() const | vl::Billboard | [inline]
Billboard() | vl::Billboard |
child(int i) | vl::Transform |
childCount() const | vl::Transform |
className() | vl::Billboard | [inline, virtual]
computeWorldMatrix(Camera *camera=NULL) | vl::Billboard | [virtual]
computeWorldMatrixRecursive(Camera *camera=NULL) | vl::Transform |
decReference() | vl::Object | [inline]
eraseAllChildren() | vl::Transform |
eraseAllChildrenRecursive() | vl::Transform |
eraseChild(Transform *child) | vl::Transform |
eraseChildren(int index, int count) | vl::Transform |
getComputedWorldMatrix() | vl::Transform |
incReference() | vl::Object | [inline]
lastChild() | vl::Transform |
localMatrix() const | vl::Transform |
mAssumeIdentityWorldMatrix | vl::Transform | [protected]
mAxis | vl::Billboard | [protected]
mChildren | vl::Transform | [protected]
mLocalMatrix | vl::Transform | [protected]
mName | vl::Object | [protected]
mNormal | vl::Billboard | [protected]
mParent | vl::Transform | [protected]
mType | vl::Billboard | [protected]
mWorldMatrix | vl::Transform | [protected]
mWorldMatrixUpdateTick | vl::Transform | [protected]
name() const | vl::Object | [inline]
normal() const | vl::Billboard | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() const | vl::Transform | [inline]
parent() | vl::Transform | [inline]
position() | vl::Billboard |
referenceCount() const | vl::Object | [inline]
rotate(Real degrees, Real x, Real y, Real z) | vl::Transform |
rotate(const vec3 &from, const vec3 &to) | vl::Transform |
scale(Real x, Real y, Real z) | vl::Transform |
setAlwaysIdentityWorldMatrix(bool assume_I) | vl::Transform | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setAxis(const vec3 &axis) | vl::Billboard | [inline]
setChild(int index, Transform *child) | vl::Transform |
setLocalMatrix(const mat4 &matrix) | vl::Transform |
setName(const std::string &name) | vl::Object | [inline]
setNormal(const vec3 &normal) | vl::Billboard | [inline]
setPosition(const vec3 &pos) | vl::Billboard |
setPosition(Real x, Real y, Real z) | vl::Billboard | [inline]
setType(EBillboardType type) | vl::Billboard | [inline]
setWorldMatrix(const mat4 &matrix) | vl::Transform | [protected]
Transform() | vl::Transform | [inline]
Transform(const mat4 &matrix) | vl::Transform | [inline]
translate(Real x, Real y, Real z) | vl::Transform |
translate(const vec3 &t) | vl::Transform |
type() const | vl::Billboard | [inline]
worldMatrix() const | vl::Transform |
worldMatrixUpdateTick() const | vl::Transform | [inline]
~Object() | vl::Object | [protected, virtual]
~Transform() | vl::Transform | [virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::BlendColor Member List

This is the complete list of members for vl::BlendColor, including all inherited members.

apply(const Camera *) const | vl::BlendColor | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BlendColor(fvec4 blendcolor=fvec4(0, 0, 0, 0)) | vl::BlendColor | [inline]
blendColor() const | vl::BlendColor | [inline]
className() | vl::BlendColor | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mBlendColor | vl::BlendColor | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(fvec4 blendcolor) | vl::BlendColor | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::BlendColor | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::BlendEquation Member List

This is the complete list of members for vl::BlendEquation, including all inherited members.

apply(const Camera *) const | vl::BlendEquation | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BlendEquation(EBlendEquation mode_rgb=BE_FUNC_ADD, EBlendEquation mode_alpha=BE_FUNC_ADD) | vl::BlendEquation | [inline]
className() | vl::BlendEquation | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mModeAlpha | vl::BlendEquation | [protected]
mModeRGB | vl::BlendEquation | [protected]
mName | vl::Object | [protected]
modeAlpha() const | vl::BlendEquation | [inline]
modeRGB() const | vl::BlendEquation | [inline]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EBlendEquation mode_rgba) | vl::BlendEquation | [inline]
set(EBlendEquation mode_rgb, EBlendEquation mode_alpha) | vl::BlendEquation | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::BlendEquation | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::BlendFunc Member List

This is the complete list of members for vl::BlendFunc, including all inherited members.

apply(const Camera *) const | vl::BlendFunc | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BlendFunc(EBlendFactor src_rgb=BF_SRC_ALPHA, EBlendFactor dst_rgb=BF_ONE_MINUS_SRC_ALPHA, EBlendFactor src_alpha=BF_SRC_ALPHA, EBlendFactor dst_alpha=BF_ONE_MINUS_SRC_ALPHA) | vl::BlendFunc | [inline]
className() | vl::BlendFunc | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
dstAlpha() const | vl::BlendFunc | [inline]
dstRGB() const | vl::BlendFunc | [inline]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mDstAlpha | vl::BlendFunc | [protected]
mDstRGB | vl::BlendFunc | [protected]
mName | vl::Object | [protected]
mSrcAlpha | vl::BlendFunc | [protected]
mSrcRGB | vl::BlendFunc | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EBlendFactor src_rgb, EBlendFactor dst_rgb, EBlendFactor src_alpha, EBlendFactor dst_alpha) | vl::BlendFunc | [inline]
set(EBlendFactor src_rgba, EBlendFactor dst_rgba) | vl::BlendFunc | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDstAlpha(EBlendFactor factor) | vl::BlendFunc | [inline]
setDstRGB(EBlendFactor factor) | vl::BlendFunc | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSrcAlpha(EBlendFactor factor) | vl::BlendFunc | [inline]
setSrcRGB(EBlendFactor factor) | vl::BlendFunc | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
srcAlpha() const | vl::BlendFunc | [inline]
srcRGB() const | vl::BlendFunc | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::BlendFunc | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::BlitFramebuffer Member List

This is the complete list of members for vl::BlitFramebuffer, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BlitFramebuffer() | vl::BlitFramebuffer | [inline]
bufferMask() const | vl::BlitFramebuffer | [inline]
className() | vl::BlitFramebuffer | [inline, virtual]
copyPixels() | vl::BlitFramebuffer | [inline]
decReference() | vl::Object | [inline]
drawFramebuffer() const | vl::BlitFramebuffer | [inline]
dstRect() const | vl::BlitFramebuffer | [inline]
incReference() | vl::Object | [inline]
linearFilteringEnabled() const | vl::BlitFramebuffer | [inline]
mBufferMask | vl::BlitFramebuffer | [protected]
mDrawFramebuffer | vl::BlitFramebuffer | [protected]
mDstRect | vl::BlitFramebuffer | [protected]
mLinearFilteringEnabled | vl::BlitFramebuffer | [protected]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadFramebuffer | vl::BlitFramebuffer | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
mSrcRect | vl::BlitFramebuffer | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readFramebuffer() const | vl::BlitFramebuffer | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
RenderingCallback() | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::BlitFramebuffer | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBufferMask(int buffer_mask) | vl::BlitFramebuffer | [inline]
setDrawFramebuffer(FBORenderTarget *fbo) | vl::BlitFramebuffer | [inline]
setDstRect(int x0, int y0, int x1, int y1) | vl::BlitFramebuffer | [inline]
setLinearFilteringEnabled(bool enable_linear_filtering) | vl::BlitFramebuffer | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadFramebuffer(FBORenderTarget *fbo) | vl::BlitFramebuffer | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
setSrcRect(int x0, int y0, int x1, int y1) | vl::BlitFramebuffer | [inline]
srcRect() const | vl::BlitFramebuffer | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Buffer Member List

This is the complete list of members for vl::Buffer, including all inherited members.

alignedFree(void *ptr) | vl::Buffer | [inline, static]
alignedMalloc(int bytes, int alignment) | vl::Buffer | [inline, static]
alignment() const | vl::Buffer | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
Buffer() | vl::Buffer | [inline]
Buffer(const Buffer &other) | vl::Buffer | [inline]
bytesUsed() const | vl::Buffer | [inline]
className() | vl::Buffer | [inline, virtual]
clear() | vl::Buffer | [inline]
decReference() | vl::Object | [inline]
empty() const | vl::Buffer | [inline]
incReference() | vl::Object | [inline]
mAlignment | vl::Buffer | [protected]
mByteCount | vl::Buffer | [protected]
mName | vl::Object | [protected]
mPtr | vl::Buffer | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Buffer &other) | vl::Buffer | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
ptr() | vl::Buffer | [inline]
ptr() const | vl::Buffer | [inline]
referenceCount() const | vl::Object | [inline]
resize(int byte_count, int alignment=0) | vl::Buffer | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
swap(Buffer &other) | vl::Buffer | [inline]
~Buffer() | vl::Buffer | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::BufferedStream< Element_Type, Chunk_Size > Member List

This is the complete list of members for vl::BufferedStream< Element_Type, Chunk_Size >, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BufferedStream() | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
bufferEmpty() | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
className() | vl::BufferedStream< Element_Type, Chunk_Size > | [inline, virtual]
decReference() | vl::Object | [inline]
fillBuffer() | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
incReference() | vl::Object | [inline]
inputFile() const | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
mBuffer | vl::BufferedStream< Element_Type, Chunk_Size > | [protected]
mInputFile | vl::BufferedStream< Element_Type, Chunk_Size > | [protected]
mName | vl::Object | [protected]
mPtr | vl::BufferedStream< Element_Type, Chunk_Size > | [protected]
mSize | vl::BufferedStream< Element_Type, Chunk_Size > | [protected]
mUngetBuffer | vl::BufferedStream< Element_Type, Chunk_Size > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readToken(Element_Type *token) | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
referenceCount() const | vl::Object | [inline]
seek(long long pos) | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInputFile(VirtualFile *file) | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
setName(const std::string &name) | vl::Object | [inline]
ungetToken(const Element_Type &token) | vl::BufferedStream< Element_Type, Chunk_Size > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CRC32CheckSum Member List

This is the complete list of members for vl::CRC32CheckSum, including all inherited members.

compute(const void *buf, int length) | vl::CRC32CheckSum | [inline]
compute(VirtualFile *stream) | vl::CRC32CheckSum | [inline]
continueCRC32(unsigned char *ptr, int length) | vl::CRC32CheckSum | [inline]
crc32_init() | vl::CRC32CheckSum | [inline, protected]
crc32_table | vl::CRC32CheckSum | [protected]
CRC32CheckSum() | vl::CRC32CheckSum | [inline]
finalizeCRC32() | vl::CRC32CheckSum | [inline]
mCRC32 | vl::CRC32CheckSum | [protected]
reflect(unsigned int val, char ch) | vl::CRC32CheckSum | [inline, protected]
startCRC32() | vl::CRC32CheckSum | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Camera Member List

This is the complete list of members for vl::Camera, including all inherited members.

activate() | vl::Camera |
active() const | vl::Camera | [inline]
adjustView(const AABB &aabb, const vec3 &dir, const vec3 &up, Real bias=1.0f) | vl::Camera |
applyModelViewMatrix(const mat4 &model_matrix) const | vl::Camera |
applyViewMatrix() const | vl::Camera |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
aspectRatio() const | vl::Camera | [inline]
automaticDelete() const | vl::Object | [inline]
Camera(const std::string &name="Camera") | vl::Camera |
className() | vl::Camera | [inline, virtual]
computeFrustumPlanes() | vl::Camera |
computeRay(int winx, int winy) | vl::Camera |
computeRayFrustum(int winx, int winy) | vl::Camera |
decReference() | vl::Object | [inline]
farPlane() const | vl::Camera | [inline]
followedTransform() const | vl::Camera | [inline]
followedTransform() | vl::Camera | [inline]
followTransform(Transform *transform) | vl::Camera | [inline]
fov() const | vl::Camera | [inline]
frustum() const | vl::Camera | [inline]
getViewMatrixAsLookAt(vec3 &eye, vec3 &look, vec3 &up, vec3 &right) const | vl::Camera |
incReference() | vl::Object | [inline]
inverseViewMatrix() const | vl::Camera | [inline]
mActive | vl::Camera | [protected]
mFarPlane | vl::Camera | [protected]
mFollowTransform | vl::Camera | [protected]
mFOV | vl::Camera | [protected]
mFrustum | vl::Camera | [protected]
mInverseViewMatrix | vl::Camera | [protected]
mName | vl::Object | [protected]
mNearFarClippingPlanesOptimized | vl::Camera | [protected]
mNearPlane | vl::Camera | [protected]
mProjectionMatrix | vl::Camera | [protected]
mSceneBoundingSphere | vl::Camera | [protected]
mViewMatrix | vl::Camera | [protected]
mViewport | vl::Camera | [protected]
name() const | vl::Object | [inline]
nearFarClippingPlanesOptimized() const | vl::Camera | [inline]
nearPlane() const | vl::Camera | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
project(const vec4 &in, vec4 &out) const | vl::Camera |
projectionMatrix() const | vl::Camera | [inline]
referenceCount() const | vl::Object | [inline]
sceneBoundingSphere() const | vl::Camera | [inline]
setActive(bool active) | vl::Camera | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFarPlane(Real farplane) | vl::Camera | [inline]
setFOV(Real fov) | vl::Camera | [inline]
setFrustum(const Frustum &frustum) | vl::Camera | [inline]
setInverseViewMatrix(const mat4 &mat) | vl::Camera | [inline]
setName(const std::string &name) | vl::Object | [inline]
setNearFarClippingPlanesOptimized(bool enable) | vl::Camera | [inline]
setNearPlane(Real nearplane) | vl::Camera | [inline]
setProjectionAsFrustum(Real left, Real right, Real bottom, Real top, Real near, Real far) | vl::Camera |
setProjectionAsOrtho(Real offset=-0.5f) | vl::Camera |
setProjectionAsOrtho2D(Real offset=-0.5f) | vl::Camera |
setProjectionAsPerspective() | vl::Camera |
setProjectionAsPerspective(Real fov, Real near, Real far) | vl::Camera |
setProjectionMatrix(const mat4 &mat) | vl::Camera | [inline]
setSceneBoundingSphere(const Sphere &sphere) | vl::Camera | [inline]
setViewMatrix(const mat4 &mat) | vl::Camera | [inline]
setViewMatrixAsLookAt(const vec3 &eye, const vec3 &center, const vec3 &up) | vl::Camera |
setViewport(Viewport *viewport) | vl::Camera | [inline]
unproject(const vec3 &win, vec4 &out) const | vl::Camera |
unproject(std::vector< vec3 > &points) const | vl::Camera |
viewMatrix() const | vl::Camera | [inline]
viewport() | vl::Camera | [inline]
viewport() const | vl::Camera | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolator< T > Member List

This is the complete list of members for vl::CatmullRomInterpolator< T >, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolator() | vl::CatmullRomInterpolator< T > | [inline]
CatmullRomInterpolator(const std::vector< T > &path) | vl::CatmullRomInterpolator< T > | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolator< T > | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mCatmullRomSpline | vl::CatmullRomInterpolator< T > | [protected]
mName | vl::Object | [protected]
mPath | vl::CatmullRomInterpolator< T > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::CatmullRomInterpolator< T > | [inline]
path() | vl::CatmullRomInterpolator< T > | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const std::vector< T > &path) | vl::CatmullRomInterpolator< T > | [inline]
setupEndPoints(bool is_loop) | vl::CatmullRomInterpolator< T > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorDVec2 Member List

This is the complete list of members for vl::CatmullRomInterpolatorDVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorDVec2() | vl::CatmullRomInterpolatorDVec2 | [inline]
CatmullRomInterpolatorDVec2(const std::vector< vl::dvec2 > &path) | vl::CatmullRomInterpolatorDVec2 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorDVec2 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorDVec2 | [inline]
interpolator() const | vl::CatmullRomInterpolatorDVec2 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorDVec2 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorDVec2_T *interpolator) | vl::CatmullRomInterpolatorDVec2 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorDVec3 Member List

This is the complete list of members for vl::CatmullRomInterpolatorDVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorDVec3() | vl::CatmullRomInterpolatorDVec3 | [inline]
CatmullRomInterpolatorDVec3(const std::vector< vl::dvec3 > &path) | vl::CatmullRomInterpolatorDVec3 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorDVec3 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorDVec3 | [inline]
interpolator() const | vl::CatmullRomInterpolatorDVec3 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorDVec3 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorDVec3_T *interpolator) | vl::CatmullRomInterpolatorDVec3 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorDVec4 Member List

This is the complete list of members for vl::CatmullRomInterpolatorDVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorDVec4() | vl::CatmullRomInterpolatorDVec4 | [inline]
CatmullRomInterpolatorDVec4(const std::vector< vl::dvec4 > &path) | vl::CatmullRomInterpolatorDVec4 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorDVec4 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorDVec4 | [inline]
interpolator() const | vl::CatmullRomInterpolatorDVec4 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorDVec4 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorDVec4_T *interpolator) | vl::CatmullRomInterpolatorDVec4 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorDouble Member List

This is the complete list of members for vl::CatmullRomInterpolatorDouble, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorDouble() | vl::CatmullRomInterpolatorDouble | [inline]
CatmullRomInterpolatorDouble(const std::vector< double > &path) | vl::CatmullRomInterpolatorDouble | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorDouble | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorDouble | [inline]
interpolator() const | vl::CatmullRomInterpolatorDouble | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorDouble | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorDouble_T *interpolator) | vl::CatmullRomInterpolatorDouble | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorFVec2 Member List

This is the complete list of members for vl::CatmullRomInterpolatorFVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorFVec2() | vl::CatmullRomInterpolatorFVec2 | [inline]
CatmullRomInterpolatorFVec2(const std::vector< vl::fvec2 > &path) | vl::CatmullRomInterpolatorFVec2 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorFVec2 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorFVec2 | [inline]
interpolator() const | vl::CatmullRomInterpolatorFVec2 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorFVec2 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorFVec2_T *interpolator) | vl::CatmullRomInterpolatorFVec2 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorFVec3 Member List

This is the complete list of members for vl::CatmullRomInterpolatorFVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorFVec3() | vl::CatmullRomInterpolatorFVec3 | [inline]
CatmullRomInterpolatorFVec3(const std::vector< vl::fvec3 > &path) | vl::CatmullRomInterpolatorFVec3 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorFVec3 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorFVec3 | [inline]
interpolator() const | vl::CatmullRomInterpolatorFVec3 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorFVec3 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorFVec3_T *interpolator) | vl::CatmullRomInterpolatorFVec3 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorFVec4 Member List

This is the complete list of members for vl::CatmullRomInterpolatorFVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorFVec4() | vl::CatmullRomInterpolatorFVec4 | [inline]
CatmullRomInterpolatorFVec4(const std::vector< vl::fvec4 > &path) | vl::CatmullRomInterpolatorFVec4 | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorFVec4 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorFVec4 | [inline]
interpolator() const | vl::CatmullRomInterpolatorFVec4 | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorFVec4 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorFVec4_T *interpolator) | vl::CatmullRomInterpolatorFVec4 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CatmullRomInterpolatorFloat Member List

This is the complete list of members for vl::CatmullRomInterpolatorFloat, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CatmullRomInterpolatorFloat() | vl::CatmullRomInterpolatorFloat | [inline]
CatmullRomInterpolatorFloat(const std::vector< float > &path) | vl::CatmullRomInterpolatorFloat | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::CatmullRomInterpolatorFloat | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::CatmullRomInterpolatorFloat | [inline]
interpolator() const | vl::CatmullRomInterpolatorFloat | [inline]
Interpolator() | vl::Interpolator | [inline]
mInterpolator | vl::CatmullRomInterpolatorFloat | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(CatmullRomInterpolatorFloat_T *interpolator) | vl::CatmullRomInterpolatorFloat | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Clear Member List

This is the complete list of members for vl::Clear, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::Clear | [inline, virtual]
Clear() | vl::Clear | [inline]
clearColorMode() const | vl::Clear | [inline]
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation() | vl::Clear | [inline, protected, virtual]
decReference() | vl::Object | [inline]
deleteDisplayList() | vl::Renderable | [inline]
deleteVBOs() | vl::Renderable | [inline, virtual]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
getScissorBox(int &x, int &y, int &w, int &h) | vl::Clear | [inline]
incReference() | vl::Object | [inline]
lineCount() const | vl::Renderable | [inline, virtual]
mClearColorBuffer | vl::Clear | [protected]
mClearColorMode | vl::Clear | [protected]
mClearColorValue | vl::Clear | [protected]
mClearColorValueInt | vl::Clear | [protected]
mClearColorValueUInt | vl::Clear | [protected]
mClearDepthBuffer | vl::Clear | [protected]
mClearDepthValue | vl::Clear | [protected]
mClearStencilBuffer | vl::Clear | [protected]
mClearStencilValue | vl::Clear | [protected]
mName | vl::Object | [protected]
mScissorBox | vl::Clear | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::Renderable | [inline, virtual]
referenceCount() const | vl::Object | [inline]
render(const Actor *, const OpenGLContext *, const Camera *) const | vl::Clear | [inline, virtual]
Renderable() | vl::Renderable | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setClearColorBuffer(bool clear) | vl::Clear | [inline]
setClearColorMode(EClearColorMode mode) | vl::Clear | [inline]
setClearColorValue(const fvec4 &clear_val) | vl::Clear | [inline]
setClearColorValueInt(const ivec4 &clear_val) | vl::Clear | [inline]
setClearColorValueUInt(const uvec4 &clear_val) | vl::Clear | [inline]
setClearDepthBuffer(bool clear) | vl::Clear | [inline]
setClearDepthValue(float clear_val) | vl::Clear | [inline]
setClearStencilBuffer(bool clear) | vl::Clear | [inline]
setClearStencilValue(int clear_val) | vl::Clear | [inline]
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setName(const std::string &name) | vl::Object | [inline]
setScissorBox(int x, int y, int w, int h) | vl::Clear | [inline]
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
triangleCount() const | vl::Renderable | [inline, virtual]
updateVBOs(bool) | vl::Renderable | [inline, virtual]
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ClipPlane Member List

This is the complete list of members for vl::ClipPlane, including all inherited members.

apply(const Camera *camera) const | vl::ClipPlane | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ClipPlane | [inline, virtual]
ClipPlane(int plane_index, Real o=0.0f, vec3 n=vec3(0, 0, 0)) | vl::ClipPlane | [inline]
ClipPlane(int plane_index, const vec3 &o, const vec3 &n) | vl::ClipPlane | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::ClipPlane | [inline, virtual]
enable() const | vl::ClipPlane | [inline, virtual]
followedTransform() | vl::ClipPlane | [inline]
followedTransform() const | vl::ClipPlane | [inline]
followTransform(Transform *transform) | vl::ClipPlane | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mFollowedTransform | vl::ClipPlane | [protected]
mName | vl::Object | [protected]
mPlane | vl::ClipPlane | [protected]
mPlaneIndex | vl::ClipPlane | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
plane() const | vl::ClipPlane | [inline]
planeIndex() const | vl::ClipPlane | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPlane(const Plane &plane) | vl::ClipPlane | [inline]
setPlaneIndex(int plane_index) | vl::ClipPlane | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::ClipPlane | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Collection< T > Member List

This is the complete list of members for vl::Collection< T >, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
at(int i) const | vl::Collection< T > | [inline]
at(int i) | vl::Collection< T > | [inline]
automaticDelete() const | vl::Object | [inline]
back() const | vl::Collection< T > | [inline]
back() | vl::Collection< T > | [inline]
capacity() const | vl::Collection< T > | [inline]
className() | vl::Collection< T > | [inline, virtual]
clear() | vl::Collection< T > | [inline]
Collection(const std::vector< ref< T > > &vector) | vl::Collection< T > | [inline]
Collection() | vl::Collection< T > | [inline]
decReference() | vl::Object | [inline]
empty() const | vl::Collection< T > | [inline]
erase(int start, int count) | vl::Collection< T > | [inline]
erase(const T *data) | vl::Collection< T > | [inline]
eraseAt(int index) | vl::Collection< T > | [inline]
find(T *obj) const | vl::Collection< T > | [inline]
incReference() | vl::Object | [inline]
insert(int start, const Collection< T > &objs) | vl::Collection< T > | [inline]
insert(int index, T *obj) | vl::Collection< T > | [inline]
less(const ref< T > &a, const ref< T > &b) | vl::Collection< T > | [inline, protected, static]
mName | vl::Object | [protected]
mVector | vl::Collection< T > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator std::vector< ref< T > >() const | vl::Collection< T > | [inline]
operator=(const std::vector< ref< T > > &vector) | vl::Collection< T > | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
operator[](int i) const | vl::Collection< T > | [inline]
operator[](int i) | vl::Collection< T > | [inline]
pop_back() | vl::Collection< T > | [inline]
push_back(T *data) | vl::Collection< T > | [inline]
push_back(const Collection< T > &objs) | vl::Collection< T > | [inline]
referenceCount() const | vl::Object | [inline]
reserve(int capacity) | vl::Collection< T > | [inline]
resize(int size) | vl::Collection< T > | [inline]
set(const Collection< T > &objs) | vl::Collection< T > | [inline]
set(int index, T *obj) | vl::Collection< T > | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
shrink() | vl::Collection< T > | [inline]
size() const | vl::Collection< T > | [inline]
sort() | vl::Collection< T > | [inline]
swap(Collection &other) | vl::Collection< T > | [inline]
vector() const | vl::Collection< T > | [inline]
vector() | vl::Collection< T > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::ColorMask Member List

This is the complete list of members for vl::ColorMask, including all inherited members.

alpha() const | vl::ColorMask | [inline]
apply(const Camera *) const | vl::ColorMask | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
blue() const | vl::ColorMask | [inline]
className() | vl::ColorMask | [inline, virtual]
ColorMask(bool red=true, bool green=true, bool blue=true, bool alpha=true) | vl::ColorMask | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
green() const | vl::ColorMask | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mAlpha | vl::ColorMask | [protected]
mBlue | vl::ColorMask | [protected]
mGreen | vl::ColorMask | [protected]
mName | vl::Object | [protected]
mRed | vl::ColorMask | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
red() const | vl::ColorMask | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(bool red, bool green, bool blue, bool alpha) | vl::ColorMask | [inline]
setAlpha(bool alpha) | vl::ColorMask | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBlue(bool blue) | vl::ColorMask | [inline]
setGreen(bool green) | vl::ColorMask | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRed(bool red) | vl::ColorMask | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::ColorMask | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::CopyTexSubImage1D Member List

This is the complete list of members for vl::CopyTexSubImage1D, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::CopyTexSubImage1D | [inline, virtual]
copyPixels() | vl::CopyTexSubImage1D | [inline, virtual]
CopyTexSubImage() | vl::CopyTexSubImage | [inline]
CopyTexSubImage1D(int level, int xoffset, int x, int y, int width, Texture *texture=NULL, EReadDrawBuffer read_buffer=RDB_BACK_LEFT) | vl::CopyTexSubImage1D | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
level() const | vl::CopyTexSubImage1D | [inline]
mLevel | vl::CopyTexSubImage1D | [protected]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadBuffer | vl::CopyTexSubImage | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
mTexture | vl::CopyTexSubImage1D | [protected]
mWidth | vl::CopyTexSubImage1D | [protected]
mX | vl::CopyTexSubImage1D | [protected]
mXOffset | vl::CopyTexSubImage1D | [protected]
mY | vl::CopyTexSubImage1D | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readBuffer() const | vl::CopyTexSubImage | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::CopyTexSubImage | [inline, virtual]
RenderingCallback() | vl::RenderingCallback | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLevel(int level) | vl::CopyTexSubImage1D | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadBuffer(EReadDrawBuffer render_buffer) | vl::CopyTexSubImage | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
setTexture(Texture *tex) | vl::CopyTexSubImage1D | [inline]
setWidth(int width) | vl::CopyTexSubImage1D | [inline]
setX(int x) | vl::CopyTexSubImage1D | [inline]
setXOffset(int xoffset) | vl::CopyTexSubImage1D | [inline]
setY(int y) | vl::CopyTexSubImage1D | [inline]
texture() | vl::CopyTexSubImage1D | [inline]
texture() const | vl::CopyTexSubImage1D | [inline]
width() const | vl::CopyTexSubImage1D | [inline]
x() const | vl::CopyTexSubImage1D | [inline]
xoffset() const | vl::CopyTexSubImage1D | [inline]
y() const | vl::CopyTexSubImage1D | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CopyTexSubImage2D Member List

This is the complete list of members for vl::CopyTexSubImage2D, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::CopyTexSubImage2D | [inline, virtual]
copyPixels() | vl::CopyTexSubImage2D | [inline, virtual]
CopyTexSubImage() | vl::CopyTexSubImage | [inline]
CopyTexSubImage2D(int level, int xoffset, int yoffset, int x, int y, int width, int height, Texture *texture=NULL, ETex2DTarget target=T2DT_TEXTURE_2D, EReadDrawBuffer read_buffer=RDB_BACK_LEFT) | vl::CopyTexSubImage2D | [inline]
decReference() | vl::Object | [inline]
height() const | vl::CopyTexSubImage2D | [inline]
incReference() | vl::Object | [inline]
level() const | vl::CopyTexSubImage2D | [inline]
mHeight | vl::CopyTexSubImage2D | [protected]
mLevel | vl::CopyTexSubImage2D | [protected]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadBuffer | vl::CopyTexSubImage | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
mTarget | vl::CopyTexSubImage2D | [protected]
mTexture | vl::CopyTexSubImage2D | [protected]
mWidth | vl::CopyTexSubImage2D | [protected]
mX | vl::CopyTexSubImage2D | [protected]
mXOffset | vl::CopyTexSubImage2D | [protected]
mY | vl::CopyTexSubImage2D | [protected]
mYOffset | vl::CopyTexSubImage2D | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readBuffer() const | vl::CopyTexSubImage | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::CopyTexSubImage | [inline, virtual]
RenderingCallback() | vl::RenderingCallback | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int height) | vl::CopyTexSubImage2D | [inline]
setLevel(int level) | vl::CopyTexSubImage2D | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadBuffer(EReadDrawBuffer render_buffer) | vl::CopyTexSubImage | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
setTarget(ETex2DTarget target) | vl::CopyTexSubImage2D | [inline]
setTexture(Texture *tex) | vl::CopyTexSubImage2D | [inline]
setWidth(int width) | vl::CopyTexSubImage2D | [inline]
setX(int x) | vl::CopyTexSubImage2D | [inline]
setXOffset(int xoffset) | vl::CopyTexSubImage2D | [inline]
setY(int y) | vl::CopyTexSubImage2D | [inline]
setYOffset(int yoffset) | vl::CopyTexSubImage2D | [inline]
target() const | vl::CopyTexSubImage2D | [inline]
texture() | vl::CopyTexSubImage2D | [inline]
texture() const | vl::CopyTexSubImage2D | [inline]
width() const | vl::CopyTexSubImage2D | [inline]
x() const | vl::CopyTexSubImage2D | [inline]
xoffset() const | vl::CopyTexSubImage2D | [inline]
y() const | vl::CopyTexSubImage2D | [inline]
yoffset() const | vl::CopyTexSubImage2D | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CopyTexSubImage3D Member List

This is the complete list of members for vl::CopyTexSubImage3D, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::CopyTexSubImage3D | [inline, virtual]
copyPixels() | vl::CopyTexSubImage3D | [inline, virtual]
CopyTexSubImage() | vl::CopyTexSubImage | [inline]
CopyTexSubImage3D(int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height, Texture *texture, EReadDrawBuffer read_buffer=RDB_BACK_LEFT) | vl::CopyTexSubImage3D | [inline]
decReference() | vl::Object | [inline]
height() const | vl::CopyTexSubImage3D | [inline]
incReference() | vl::Object | [inline]
level() const | vl::CopyTexSubImage3D | [inline]
mHeight | vl::CopyTexSubImage3D | [protected]
mLevel | vl::CopyTexSubImage3D | [protected]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadBuffer | vl::CopyTexSubImage | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
mTexture | vl::CopyTexSubImage3D | [protected]
mWidth | vl::CopyTexSubImage3D | [protected]
mX | vl::CopyTexSubImage3D | [protected]
mXOffset | vl::CopyTexSubImage3D | [protected]
mY | vl::CopyTexSubImage3D | [protected]
mYOffset | vl::CopyTexSubImage3D | [protected]
mZOffset | vl::CopyTexSubImage3D | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readBuffer() const | vl::CopyTexSubImage | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::CopyTexSubImage | [inline, virtual]
RenderingCallback() | vl::RenderingCallback | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int height) | vl::CopyTexSubImage3D | [inline]
setLevel(int level) | vl::CopyTexSubImage3D | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadBuffer(EReadDrawBuffer render_buffer) | vl::CopyTexSubImage | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
setTexture(Texture *tex) | vl::CopyTexSubImage3D | [inline]
setWidth(int width) | vl::CopyTexSubImage3D | [inline]
setX(int x) | vl::CopyTexSubImage3D | [inline]
setXOffset(int xoffset) | vl::CopyTexSubImage3D | [inline]
setY(int y) | vl::CopyTexSubImage3D | [inline]
setYOffset(int yoffset) | vl::CopyTexSubImage3D | [inline]
setZOffset(int zoffset) | vl::CopyTexSubImage3D | [inline]
texture() | vl::CopyTexSubImage3D | [inline]
texture() const | vl::CopyTexSubImage3D | [inline]
width() const | vl::CopyTexSubImage3D | [inline]
x() const | vl::CopyTexSubImage3D | [inline]
xoffset() const | vl::CopyTexSubImage3D | [inline]
y() const | vl::CopyTexSubImage3D | [inline]
yoffset() const | vl::CopyTexSubImage3D | [inline]
zoffset() const | vl::CopyTexSubImage3D | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CopyTexSubImage Member List

This is the complete list of members for vl::CopyTexSubImage, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderingCallback | [inline, virtual]
copyPixels()=0 | vl::CopyTexSubImage | [pure virtual]
CopyTexSubImage() | vl::CopyTexSubImage | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadBuffer | vl::CopyTexSubImage | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readBuffer() const | vl::CopyTexSubImage | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
RenderingCallback() | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::CopyTexSubImage | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadBuffer(EReadDrawBuffer render_buffer) | vl::CopyTexSubImage | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::CullFace Member List

This is the complete list of members for vl::CullFace, including all inherited members.

apply(const Camera *) const | vl::CullFace | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::CullFace | [inline, virtual]
CullFace(EPolygonFace cullface=PF_BACK) | vl::CullFace | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
faceMode() const | vl::CullFace | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mFaceMode | vl::CullFace | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EPolygonFace facemode) | vl::CullFace | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::CullFace | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::DepthFunc Member List

This is the complete list of members for vl::DepthFunc, including all inherited members.

apply(const Camera *) const | vl::DepthFunc | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DepthFunc | [inline, virtual]
decReference() | vl::Object | [inline]
DepthFunc(EFunction depthfunc=FU_LESS) | vl::DepthFunc | [inline]
depthFunc() const | vl::DepthFunc | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mDepthFunc | vl::DepthFunc | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EFunction depthfunc) | vl::DepthFunc | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::DepthFunc | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::DepthMask Member List

This is the complete list of members for vl::DepthMask, including all inherited members.

apply(const Camera *) const | vl::DepthMask | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DepthMask | [inline, virtual]
decReference() | vl::Object | [inline]
DepthMask(bool depthmask=true) | vl::DepthMask | [inline]
depthMask() const | vl::DepthMask | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mDepthMask | vl::DepthMask | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(bool depthmask) | vl::DepthMask | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::DepthMask | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::DepthRange Member List

This is the complete list of members for vl::DepthRange, including all inherited members.

apply(const Camera *) const | vl::DepthRange | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DepthRange | [inline, virtual]
decReference() | vl::Object | [inline]
DepthRange() | vl::DepthRange | [inline]
DepthRange(float znear, float zfar) | vl::DepthRange | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
mZFar | vl::DepthRange | [protected]
mZNear | vl::DepthRange | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(float znear, float zfar) | vl::DepthRange | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
setZFar(float zfar) | vl::DepthRange | [inline]
setZNear(float znear) | vl::DepthRange | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::DepthRange | [inline, virtual]
zFar() const | vl::DepthRange | [inline]
zNear() const | vl::DepthRange | [inline]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::DepthSortCallback Member List

This is the complete list of members for vl::DepthSortCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DepthSortCallback | [inline, virtual]
decReference() | vl::Object | [inline]
DepthSortCallback() | vl::DepthSortCallback | [inline]
incReference() | vl::Object | [inline]
invalidateCache() | vl::DepthSortCallback | [inline]
mCacheMatrix | vl::DepthSortCallback | [protected]
mEyeSpaceVerts | vl::DepthSortCallback | [protected]
mName | vl::Object | [protected]
mPrimitiveZ | vl::DepthSortCallback | [protected]
mSortedLinesUByte | vl::DepthSortCallback | [protected]
mSortedLinesUInt | vl::DepthSortCallback | [protected]
mSortedLinesUShort | vl::DepthSortCallback | [protected]
mSortedPointsUByte | vl::DepthSortCallback | [protected]
mSortedPointsUInt | vl::DepthSortCallback | [protected]
mSortedPointsUShort | vl::DepthSortCallback | [protected]
mSortedQuadsUByte | vl::DepthSortCallback | [protected]
mSortedQuadsUInt | vl::DepthSortCallback | [protected]
mSortedQuadsUShort | vl::DepthSortCallback | [protected]
mSortedTrianglesUByte | vl::DepthSortCallback | [protected]
mSortedTrianglesUInt | vl::DepthSortCallback | [protected]
mSortedTrianglesUShort | vl::DepthSortCallback | [protected]
mSortMode | vl::DepthSortCallback | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const Camera *cam, Actor *actor, Renderable *renderable, const Shader *, int pass) | vl::DepthSortCallback | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSortMode(ESortMode sort_mode) | vl::DepthSortCallback | [inline]
sort(deT *polys, std::vector< Point< T > > &sorted_points, std::vector< Line< T > > &sorted_lines, std::vector< Triangle< T > > &sorted_triangles, std::vector< Quad< T > > &sorted_quads) | vl::DepthSortCallback | [inline]
sortMode() const | vl::DepthSortCallback | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DiskDirectory Member List

This is the complete list of members for vl::DiskDirectory, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DiskDirectory | [inline, virtual]
decReference() | vl::Object | [inline]
DiskDirectory() | vl::DiskDirectory |
DiskDirectory(const String &path) | vl::DiskDirectory |
diskFile(const String &name) const | vl::DiskDirectory | [virtual]
diskSubDir(const String &subdir_name) const | vl::DiskDirectory |
exists() const | vl::DiskDirectory |
file(const String &name) const | vl::DiskDirectory | [virtual]
fileExists(const String &name) const | vl::VirtualDirectory | [inline]
incReference() | vl::Object | [inline]
listFiles(std::vector< String > &file_list, bool append=false) const | vl::DiskDirectory | [virtual]
listFiles(std::vector< ref< DiskFile > > &file_list, bool append=false) const | vl::DiskDirectory |
listFilesRecursive(std::vector< String > &file_list) const | vl::DiskDirectory | [virtual]
vl::VirtualDirectory::listFilesRecursive(std::vector< String > &file_list, const String &match) const | vl::VirtualDirectory | [inline, virtual]
listFilesRecursive_internal(std::vector< String > &file_list) const | vl::DiskDirectory | [protected]
listSubDirs(std::vector< String > &dirs, bool append=false) const | vl::DiskDirectory | [virtual]
mName | vl::Object | [protected]
mPath | vl::VirtualDirectory | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualDirectory | [inline, virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &path) | vl::VirtualDirectory | [virtual]
subDir(const String &subdir_name) const | vl::DiskDirectory | [inline, virtual]
translatePath(const String &p) const | vl::VirtualDirectory | [protected]
VirtualDirectory(const String &path="/") | vl::VirtualDirectory | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DiskFile Member List

This is the complete list of members for vl::DiskFile, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DiskFile | [inline, virtual]
clone() const | vl::DiskFile | [virtual]
close() | vl::DiskFile | [virtual]
crc32() | vl::VirtualFile |
decReference() | vl::Object | [inline]
DiskDirectory class | vl::DiskFile | [friend]
DiskFile(const DiskFile &other) | vl::DiskFile | [inline, protected]
DiskFile(const String &path=String()) | vl::DiskFile |
endOfFile() const | vl::VirtualFile | [inline]
exists() const | vl::DiskFile | [virtual]
incReference() | vl::Object | [inline]
isOpen() const | vl::DiskFile | [virtual]
load(std::vector< unsigned char > &data) | vl::VirtualFile |
load(void *buffer, long long max=-1) | vl::VirtualFile |
md5() | vl::VirtualFile |
mHandle | vl::DiskFile | [protected]
mName | vl::Object | [protected]
mPath | vl::VirtualFile | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
open(const String &path, EOpenMode mode) | vl::DiskFile |
open(EOpenMode mode) | vl::DiskFile | [virtual]
operator=(const DiskFile &other) | vl::DiskFile | [inline]
vl::VirtualFile::operator=(const VirtualFile &other) | vl::VirtualFile | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
parentDir() const | vl::DiskFile | [protected]
path() const | vl::VirtualFile | [inline]
peek(void *buffer, long long byte_count) | vl::VirtualFile |
position() const | vl::VirtualFile |
position_Implementation() const | vl::DiskFile | [protected, virtual]
read(void *buffer, long long byte_count) | vl::VirtualFile |
read_Implementation(void *buffer, long long byte_count) | vl::DiskFile | [protected, virtual]
readDouble(bool little_endian_data=true) | vl::VirtualFile |
readDouble(void *buffer, long long count) | vl::VirtualFile |
readFloat(bool little_endian_data=true) | vl::VirtualFile |
readFloat(void *buffer, long long count) | vl::VirtualFile |
readSByte() | vl::VirtualFile |
readSByte(void *buffer, long long count) | vl::VirtualFile |
readSInt16(bool little_endian_data=true) | vl::VirtualFile |
readSInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt32(bool little_endian_data=true) | vl::VirtualFile |
readSInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt64(bool little_endian_data=true) | vl::VirtualFile |
readSInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUByte() | vl::VirtualFile |
readUByte(void *buffer, long long count) | vl::VirtualFile |
readUInt16(bool little_endian_data=true) | vl::VirtualFile |
readUInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt32(bool little_endian_data=true) | vl::VirtualFile |
readUInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt64(bool little_endian_data=true) | vl::VirtualFile |
readUInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
referenceCount() const | vl::Object | [inline]
seekCur(long long offset) | vl::VirtualFile |
seekEnd(long long offset) | vl::VirtualFile |
seekSet(long long offset) | vl::VirtualFile |
seekSet_Implementation(long long offset) | vl::DiskFile | [protected, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::VirtualFile | [inline]
size() const | vl::DiskFile | [virtual]
VirtualFile(const VirtualFile &other) | vl::VirtualFile | [inline, protected]
VirtualFile() | vl::VirtualFile | [inline]
write(const void *buffer, long long byte_count) | vl::VirtualFile |
write_Implementation(const void *buffer, long long byte_count) | vl::DiskFile | [protected, virtual]
writeSInt16(short data, bool little_endian=true) | vl::VirtualFile |
writeSInt32(long data, bool little_endian=true) | vl::VirtualFile |
writeSInt8(char data) | vl::VirtualFile |
writeUInt16(unsigned short data, bool little_endian=true) | vl::VirtualFile |
writeUInt32(unsigned long data, bool little_endian=true) | vl::VirtualFile |
writeUInt8(unsigned char data) | vl::VirtualFile |
~DiskFile() | vl::DiskFile |
~Object() | vl::Object | [protected, virtual]
~VirtualFile() | vl::VirtualFile | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DistanceLODEvaluator Member List

This is the complete list of members for vl::DistanceLODEvaluator, including all inherited members.

addDistanceRange(double distance) | vl::DistanceLODEvaluator | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DistanceLODEvaluator | [inline, virtual]
clearDistanceRangeSet() | vl::DistanceLODEvaluator | [inline]
decReference() | vl::Object | [inline]
DistanceLODEvaluator() | vl::DistanceLODEvaluator | [inline]
distanceRange(int index) const | vl::DistanceLODEvaluator | [inline]
distanceRangeCount() const | vl::DistanceLODEvaluator | [inline]
distanceRangeSet() | vl::DistanceLODEvaluator | [inline]
evaluate(Actor *actor, Camera *camera) | vl::DistanceLODEvaluator | [inline, virtual]
incReference() | vl::Object | [inline]
LODEvaluator() | vl::LODEvaluator | [inline]
mDistanceRangeSet | vl::DistanceLODEvaluator | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDistanceRange(int index, double distance) | vl::DistanceLODEvaluator | [inline]
setDistanceRangeSet(const std::vector< double > &distance_set) | vl::DistanceLODEvaluator | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DoubleVertexRemover Member List

This is the complete list of members for vl::DoubleVertexRemover, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DoubleVertexRemover | [inline, virtual]
decReference() | vl::Object | [inline]
DoubleVertexRemover() | vl::DoubleVertexRemover | [inline]
incReference() | vl::Object | [inline]
mapNewToOld() const | vl::DoubleVertexRemover | [inline]
mapOldToNew() const | vl::DoubleVertexRemover | [inline]
mMapNewToOld | vl::DoubleVertexRemover | [protected]
mMapOldToNew | vl::DoubleVertexRemover | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
regenerate(ArrayAbstract *data, const std::vector< unsigned int > &map_new_to_old) const | vl::VertexMapper |
removeDoubles(Geometry *geom) | vl::DoubleVertexRemover |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DrawArrays Member List

This is the complete list of members for vl::DrawArrays, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DrawArrays | [inline, virtual]
clone() const | vl::DrawArrays | [inline, virtual]
count() const | vl::DrawArrays | [inline]
decReference() | vl::Object | [inline]
deleteVBOs() | vl::DrawArrays | [inline, virtual]
DrawArrays() | vl::DrawArrays | [inline]
DrawArrays(EPrimitiveType primitive, int start, int count, int instances=1) | vl::DrawArrays | [inline]
handle() const | vl::DrawArrays | [inline, virtual]
incReference() | vl::Object | [inline]
index(int i) const | vl::DrawArrays | [inline, virtual]
indexCount() const | vl::DrawArrays | [inline, virtual]
instances() const | vl::Primitives | [inline]
isEnabled() const | vl::Primitives | [inline]
lineCount() const | vl::DrawArrays | [inline, virtual]
mCount | vl::DrawArrays | [protected]
mEnabled | vl::Primitives | [protected]
mInstances | vl::Primitives | [protected]
mName | vl::Object | [protected]
mStart | vl::DrawArrays | [protected]
mType | vl::Primitives | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::DrawArrays | [inline, virtual]
Primitives() | vl::Primitives | [inline]
primitiveType() const | vl::Primitives | [inline]
referenceCount() const | vl::Object | [inline]
render(bool) const | vl::DrawArrays | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCount(int count) | vl::DrawArrays | [inline]
setEnabled(bool enable) | vl::Primitives | [inline]
setInstances(int instances) | vl::Primitives | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPrimitiveType(EPrimitiveType type) | vl::Primitives | [inline]
setStart(int start) | vl::DrawArrays | [inline]
sortTriangles() | vl::Primitives | [inline, virtual]
start() const | vl::DrawArrays | [inline]
triangleCount() const | vl::DrawArrays | [inline, virtual]
updateVBOs(bool) | vl::DrawArrays | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~Primitives() | vl::Primitives | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DrawElements< index_type, Tgltype, arr_type > Member List

This is the complete list of members for vl::DrawElements< index_type, Tgltype, arr_type >, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
clearLocalBuffer() | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
clone() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
decReference() | vl::Object | [inline]
deleteVBOs() | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
DrawElements(EPrimitiveType primitive=PT_TRIANGLES, int instances=1) | vl::DrawElements< index_type, Tgltype, arr_type > | [inline]
handle() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
incReference() | vl::Object | [inline]
index(int i) const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
indexCount() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
indexCountGPU() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
indices() | vl::DrawElements< index_type, Tgltype, arr_type > | [inline]
indices() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline]
instances() const | vl::Primitives | [inline]
isEnabled() const | vl::Primitives | [inline]
lineCount() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
mEnabled | vl::Primitives | [protected]
mIndexBuffer | vl::DrawElements< index_type, Tgltype, arr_type > | [protected]
mInstances | vl::Primitives | [protected]
mName | vl::Object | [protected]
mType | vl::Primitives | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
Primitives() | vl::Primitives | [inline]
primitiveType() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline]
referenceCount() const | vl::Object | [inline]
render(bool use_vbo) const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnabled(bool enable) | vl::Primitives | [inline]
setInstances(int instances) | vl::Primitives | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPrimitiveType(EPrimitiveType type) | vl::DrawElements< index_type, Tgltype, arr_type > | [inline]
sortTriangles() | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
triangleCount() const | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
updateVBOs(bool discard_local_data=false) | vl::DrawElements< index_type, Tgltype, arr_type > | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~Primitives() | vl::Primitives | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::DrawPixels Member List

This is the complete list of members for vl::DrawPixels, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::DrawPixels | [inline, virtual]
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation() | vl::DrawPixels | [inline, virtual]
decReference() | vl::Object | [inline]
deleteDisplayList() | vl::Renderable | [inline]
deletePixelBufferObjects() | vl::DrawPixels |
deleteVBOs() | vl::Renderable | [inline, virtual]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
DrawPixels() | vl::DrawPixels |
draws() const | vl::DrawPixels | [inline]
draws() | vl::DrawPixels | [inline]
generatePixelBufferObjects(EGLBufferUsage usage, bool discard_local_storage) | vl::DrawPixels |
incReference() | vl::Object | [inline]
lineCount() const | vl::Renderable | [inline, virtual]
mDraws | vl::DrawPixels | [protected]
mName | vl::Object | [protected]
mUsePixelBufferObject | vl::DrawPixels | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::Renderable | [inline, virtual]
referenceCount() const | vl::Object | [inline]
releaseImages() | vl::DrawPixels |
render(const Actor *actor, const OpenGLContext *, const Camera *camera) const | vl::DrawPixels | [virtual]
Renderable() | vl::Renderable | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUsePixelBufferObject(bool use_pbo) | vl::DrawPixels |
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
triangleCount() const | vl::Renderable | [inline, virtual]
updateVBOs(bool) | vl::Renderable | [inline, virtual]
usePixelBufferObject() const | vl::DrawPixels | [inline]
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::DrawPixels::Pixels Member List

This is the complete list of members for vl::DrawPixels::Pixels, including all inherited members.

align() const | vl::DrawPixels::Pixels | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
deletePixelBufferObject() | vl::DrawPixels::Pixels |
DrawPixels class | vl::DrawPixels::Pixels | [friend]
generatePixelBufferObject(EGLBufferUsage usage, bool discard_local_storage) | vl::DrawPixels::Pixels |
hasPixelBufferObject() const | vl::DrawPixels::Pixels |
image() | vl::DrawPixels::Pixels | [inline]
image() const | vl::DrawPixels::Pixels | [inline]
incReference() | vl::Object | [inline]
mAlign | vl::DrawPixels::Pixels | [protected]
mImage | vl::DrawPixels::Pixels | [protected]
mName | vl::Object | [protected]
mPosition | vl::DrawPixels::Pixels | [protected]
mSize | vl::DrawPixels::Pixels | [protected]
mStart | vl::DrawPixels::Pixels | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Pixels &other) | vl::DrawPixels::Pixels |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
Pixels() | vl::DrawPixels::Pixels |
Pixels(Image *img, int scrx, int scry, int startx=0, int starty=0, int width=-1, int height=-1, int alignment=AlignBottom|AlignLeft) | vl::DrawPixels::Pixels |
Pixels(const Pixels &other) | vl::DrawPixels::Pixels |
position() const | vl::DrawPixels::Pixels | [inline]
referenceCount() const | vl::Object | [inline]
setAlign(int align) | vl::DrawPixels::Pixels | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPosition(const ivec2 &position) | vl::DrawPixels::Pixels | [inline]
setSize(const ivec2 &size) | vl::DrawPixels::Pixels | [inline]
setStart(const ivec2 &start) | vl::DrawPixels::Pixels | [inline]
size() const | vl::DrawPixels::Pixels | [inline]
start() const | vl::DrawPixels::Pixels | [inline]
~Object() | vl::Object | [protected, virtual]
~Pixels() | vl::DrawPixels::Pixels |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::EdgeExtractor Member List

This is the complete list of members for vl::EdgeExtractor, including all inherited members.

addEdge(std::set< EdgeExtractor::Edge > &edges, const EdgeExtractor::Edge &e, const fvec3 &n) | vl::EdgeExtractor | [protected]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::EdgeExtractor | [inline, virtual]
creaseAngle() const | vl::EdgeExtractor | [inline]
decReference() | vl::Object | [inline]
EdgeExtractor() | vl::EdgeExtractor | [inline]
edges() const | vl::EdgeExtractor | [inline]
edges() | vl::EdgeExtractor | [inline]
extractEdges(Geometry *geom) | vl::EdgeExtractor |
extractEdges(Actor *actor) | vl::EdgeExtractor |
extractEdges(ActorCollection *actors) | vl::EdgeExtractor |
extractEdges(SceneManager *scenemanager) | vl::EdgeExtractor |
extractEdges(Rendering *rendering) | vl::EdgeExtractor |
generateEdgeGeometry() const | vl::EdgeExtractor |
incReference() | vl::Object | [inline]
mCreaseAngle | vl::EdgeExtractor | [protected]
mEdges | vl::EdgeExtractor | [protected]
mName | vl::Object | [protected]
mWarnNonManifold | vl::EdgeExtractor | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
reset() | vl::EdgeExtractor | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCreaseAngle(float a) | vl::EdgeExtractor | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWarnNonManifold(bool warn_on) | vl::EdgeExtractor | [inline]
warnNonManifold() const | vl::EdgeExtractor | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::EdgeExtractor::Edge Member List

This is the complete list of members for vl::EdgeExtractor::Edge, including all inherited members.

Edge() | vl::EdgeExtractor::Edge | [inline]
Edge(const fvec3 &v1, const fvec3 &v2) | vl::EdgeExtractor::Edge | [inline]
isCrease() const | vl::EdgeExtractor::Edge | [inline]
mIsCrease | vl::EdgeExtractor::Edge | [protected]
mNormal1 | vl::EdgeExtractor::Edge | [protected]
mNormal2 | vl::EdgeExtractor::Edge | [protected]
mVertex1 | vl::EdgeExtractor::Edge | [protected]
mVertex2 | vl::EdgeExtractor::Edge | [protected]
normal1() const | vl::EdgeExtractor::Edge | [inline]
normal2() const | vl::EdgeExtractor::Edge | [inline]
operator<(const Edge &other) const | vl::EdgeExtractor::Edge | [inline]
operator==(const Edge &other) const | vl::EdgeExtractor::Edge | [inline]
setIsCrease(bool iscrease) | vl::EdgeExtractor::Edge | [inline]
setNormal1(const fvec3 &v) | vl::EdgeExtractor::Edge | [inline]
setNormal2(const fvec3 &v) | vl::EdgeExtractor::Edge | [inline]
setVertex1(const fvec3 &v) | vl::EdgeExtractor::Edge | [inline]
setVertex2(const fvec3 &v) | vl::EdgeExtractor::Edge | [inline]
vertex1() const | vl::EdgeExtractor::Edge | [inline]
vertex2() const | vl::EdgeExtractor::Edge | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::EdgeRenderer Member List

This is the complete list of members for vl::EdgeRenderer, including all inherited members.

applyEnables(const EnableSet *prev, const EnableSet *cur) | vl::Renderer |
applyRenderStates(const RenderStateSet *prev, const RenderStateSet *cur, const Camera *camera) | vl::Renderer |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::EdgeRenderer | [inline, virtual]
clearCache() | vl::EdgeRenderer | [inline]
collectStatistics() const | vl::Renderer | [inline]
creaseAngle() const | vl::EdgeRenderer | [inline]
declareActor(Actor *act, const fvec4 &color) | vl::EdgeRenderer |
declareActor(Actor *act) | vl::EdgeRenderer |
decReference() | vl::Object | [inline]
defaultLineColor() const | vl::EdgeRenderer | [inline]
EdgeRenderer() | vl::EdgeRenderer | [inline]
incReference() | vl::Object | [inline]
lineWidth() const | vl::EdgeRenderer | [inline]
mActorCache | vl::EdgeRenderer | [protected]
mCollectStatistics | vl::Renderer | [protected]
mCreaseAngle | vl::EdgeRenderer | [protected]
mCurrentEnable | vl::Renderer | [protected]
mCurrentRenderState | vl::Renderer | [protected]
mCurrentUniform | vl::Renderer | [protected]
mDefaultLineColor | vl::EdgeRenderer | [protected]
mDefaultRenderStates | vl::Renderer | [protected]
mEnableTable | vl::Renderer | [protected]
mLineWidth | vl::EdgeRenderer | [protected]
mName | vl::Object | [protected]
mOcclusionCullingEnabled | vl::Renderer | [protected]
mOcclusionQueryTick | vl::Renderer | [protected]
mOcclusionQueryTickPrev | vl::Renderer | [protected]
mOcclusionShader | vl::Renderer | [protected]
mOcclusionThreshold | vl::Renderer | [protected]
mOpenGLContext | vl::Renderer | [protected]
mPolygonOffsetFactor | vl::EdgeRenderer | [protected]
mPolygonOffsetUnits | vl::EdgeRenderer | [protected]
mRenderedLineCount | vl::Renderer | [protected]
mRenderedPointCount | vl::Renderer | [protected]
mRenderedRenderableCount | vl::Renderer | [protected]
mRenderedTriangleCount | vl::Renderer | [protected]
mRenderStateTable | vl::Renderer | [protected]
mShowCreases | vl::EdgeRenderer | [protected]
mShowHiddenLines | vl::EdgeRenderer | [protected]
mSmoothLines | vl::EdgeRenderer | [protected]
mVisibleActors | vl::EdgeRenderer | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
occlusionCullingEnabled() const | vl::Renderer | [inline]
occlusionThreshold() const | vl::Renderer | [inline]
openglContext() const | vl::Renderer | [inline]
operator=(const Object &other) | vl::Object | [inline]
polygonOffsetFactor() const | vl::EdgeRenderer | [inline]
polygonOffsetUnits() const | vl::EdgeRenderer | [inline]
referenceCount() const | vl::Object | [inline]
render(const RenderQueue *render_queue, Camera *camera) | vl::EdgeRenderer | [virtual]
renderedLinesCount() const | vl::Renderer | [inline]
renderedPointsCount() const | vl::Renderer | [inline]
renderedRenderablesCount() const | vl::Renderer | [inline]
renderedTrianglesCount() const | vl::Renderer | [inline]
Renderer() | vl::Renderer |
renderLines(Camera *camera) | vl::EdgeRenderer | [protected]
renderSolids(Camera *camera) | vl::EdgeRenderer | [protected]
resetEnables() | vl::Renderer |
resetRenderStates() | vl::Renderer |
setActorDirty(Actor *actor) | vl::EdgeRenderer | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCollectStatistics(bool on) | vl::Renderer | [inline]
setCreaseAngle(float degrees) | vl::EdgeRenderer | [inline]
setDefaultLineColor(const fvec4 &c) | vl::EdgeRenderer | [inline]
setLineWidth(float width) | vl::EdgeRenderer | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOcclusionCullingEnabled(bool enabled) | vl::Renderer | [inline]
setOcclusionThreshold(int threshold) | vl::Renderer | [inline]
setOpenGLContext(const OpenGLContext *ogl_context) | vl::Renderer | [inline]
setPolygonOffsetFactor(float factor) | vl::EdgeRenderer | [inline]
setPolygonOffsetUnits(float units) | vl::EdgeRenderer | [inline]
setShowCreases(bool show) | vl::EdgeRenderer | [inline]
setShowHiddenLines(bool show) | vl::EdgeRenderer | [inline]
setSmoothLines(bool smooth) | vl::EdgeRenderer | [inline]
setupDefaultRenderStates() | vl::Renderer | [protected]
showCreases() const | vl::EdgeRenderer | [inline]
showHiddenLines() const | vl::EdgeRenderer | [inline]
smoothLines() const | vl::EdgeRenderer | [inline]
updateActorCache(const RenderQueue *render_queue) | vl::EdgeRenderer | [protected]
~Object() | vl::Object | [protected, virtual]
~Renderer() | vl::Renderer | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::EdgeUpdateCallback Member List

This is the complete list of members for vl::EdgeUpdateCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::EdgeUpdateCallback | [inline, virtual]
decReference() | vl::Object | [inline]
edges() const | vl::EdgeUpdateCallback | [inline]
edges() | vl::EdgeUpdateCallback | [inline]
EdgeUpdateCallback() | vl::EdgeUpdateCallback | [inline]
EdgeUpdateCallback(const std::vector< EdgeExtractor::Edge > &edge) | vl::EdgeUpdateCallback | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const Camera *cam, Actor *act, Renderable *renderable, const Shader *, int pass) | vl::EdgeUpdateCallback | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setShowCreases(bool sonly) | vl::EdgeUpdateCallback | [inline]
showCreases() const | vl::EdgeUpdateCallback | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::Effect Member List

This is the complete list of members for vl::Effect, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Effect | [inline, virtual]
decReference() | vl::Object | [inline]
Effect() | vl::Effect | [inline]
enableMask() const | vl::Effect | [inline]
evaluateLOD(Actor *actor, Camera *camera) | vl::Effect |
incReference() | vl::Object | [inline]
lod(int lod_level) const | vl::Effect | [inline]
lod(int lod_level) | vl::Effect | [inline]
lodEvaluator() | vl::Effect | [inline]
lodEvaluator() const | vl::Effect | [inline]
mEnableMask | vl::Effect | [protected]
mLODEvaluator | vl::Effect | [protected]
mLODShaders | vl::Effect | [protected]
mName | vl::Object | [protected]
mRenderRank | vl::Effect | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderRank() const | vl::Effect | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnableMask(unsigned int mask) | vl::Effect | [inline]
setLOD(int lodi, Shader *shader1, Shader *shader2=NULL, Shader *shader3=NULL, Shader *shader4=NULL) | vl::Effect | [inline]
setLODEvaluator(LODEvaluator *lod_evaluator) | vl::Effect | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRenderRank(int rank) | vl::Effect | [inline]
shader(int lodi=0, int pass=0) | vl::Effect | [inline]
shader(int lodi=0, int pass=0) const | vl::Effect | [inline]
~Effect() | vl::Effect | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::EnableSet Member List

This is the complete list of members for vl::EnableSet, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
blendingEnabled() const | vl::EnableSet | [inline]
className() | vl::EnableSet | [inline, virtual]
decReference() | vl::Object | [inline]
disable(EEnable capability) | vl::EnableSet | [inline]
disableAll() | vl::EnableSet | [inline]
enable(EEnable capability) | vl::EnableSet | [inline]
enables() const | vl::EnableSet | [inline]
EnableSet() | vl::EnableSet | [inline]
incReference() | vl::Object | [inline]
isEnabled(EEnable capability) const | vl::EnableSet | [inline]
mBlendingEnabled | vl::EnableSet | [protected]
mEnables | vl::EnableSet | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::Extrusion Member List

This is the complete list of members for vl::Extrusion, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
colorPath() const | vl::Extrusion | [inline]
colorPath() | vl::Extrusion | [inline]
decReference() | vl::Object | [inline]
extrude() | vl::Extrusion |
Extrusion() | vl::Extrusion | [inline]
fillBottom() const | vl::Extrusion | [inline]
fillTop() const | vl::Extrusion | [inline]
incReference() | vl::Object | [inline]
mColorPath | vl::Extrusion | [protected]
mFillBottom | vl::Extrusion | [protected]
mFillTop | vl::Extrusion | [protected]
mName | vl::Object | [protected]
mPositionPath | vl::Extrusion | [protected]
mRotationPath | vl::Extrusion | [protected]
mScalingPath | vl::Extrusion | [protected]
mSilhouette | vl::Extrusion | [protected]
mSilhouetteMode | vl::Extrusion | [protected]
mSmooth | vl::Extrusion | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
positionPath() const | vl::Extrusion | [inline]
positionPath() | vl::Extrusion | [inline]
referenceCount() const | vl::Object | [inline]
rotationPath() const | vl::Extrusion | [inline]
rotationPath() | vl::Extrusion | [inline]
scalingPath() const | vl::Extrusion | [inline]
scalingPath() | vl::Extrusion | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFillBottom(bool fill) | vl::Extrusion | [inline]
setFillTop(bool fill) | vl::Extrusion | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSilhouette(const std::vector< vl::fvec2 > &silhouette) | vl::Extrusion | [inline]
setSilhouetteMode(ESilhouetteMode mode) | vl::Extrusion | [inline]
setSmooth(bool smooth) | vl::Extrusion | [inline]
silhouette() const | vl::Extrusion | [inline]
silhouette() | vl::Extrusion | [inline]
silhouetteMode() const | vl::Extrusion | [inline]
smooth() const | vl::Extrusion | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOAttachmentAbstract Member List

This is the complete list of members for vl::FBOAttachmentAbstract, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point)=0 | vl::FBOAttachmentAbstract | [pure virtual]
className() | vl::FBOAttachmentAbstract | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBORenderTarget class | vl::FBOAttachmentAbstract | [friend]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
incReference() | vl::Object | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOColorBufferAttachment Member List

This is the complete list of members for vl::FBOColorBufferAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOColorBufferAttachment | [inline, virtual]
className() | vl::FBOColorBufferAttachment | [inline, virtual]
create() | vl::FBORenderbufferAttachment |
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderbufferAttachment | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBOColorBufferAttachment(EColorBufferFormat type) | vl::FBOColorBufferAttachment | [inline]
FBORenderbufferAttachment() | vl::FBORenderbufferAttachment | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
handle() const | vl::FBORenderbufferAttachment | [inline]
height() const | vl::FBORenderbufferAttachment | [inline]
incReference() | vl::Object | [inline]
initStorage(int w, int h) | vl::FBORenderbufferAttachment |
initStorage() | vl::FBORenderbufferAttachment | [inline]
internalBindAttachment(int w, int h, int attach_point) | vl::FBORenderbufferAttachment | [protected]
internalType() | vl::FBOColorBufferAttachment | [inline, protected, virtual]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mHandle | vl::FBORenderbufferAttachment | [protected]
mHeight | vl::FBORenderbufferAttachment | [protected]
mName | vl::Object | [protected]
mReallocateRenderbuffer | vl::FBORenderbufferAttachment | [protected]
mSamples | vl::FBORenderbufferAttachment | [protected]
mType | vl::FBOColorBufferAttachment | [protected]
mWidth | vl::FBORenderbufferAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderbufferStorageReady() const | vl::FBORenderbufferAttachment | [inline]
samples() const | vl::FBORenderbufferAttachment | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int h) | vl::FBORenderbufferAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSamples(int samples) | vl::FBORenderbufferAttachment | [inline]
setType(EColorBufferFormat type) | vl::FBOColorBufferAttachment | [inline]
setWidth(int w) | vl::FBORenderbufferAttachment | [inline]
type() const | vl::FBOColorBufferAttachment | [inline]
width() const | vl::FBORenderbufferAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBODepthBufferAttachment Member List

This is the complete list of members for vl::FBODepthBufferAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBODepthBufferAttachment | [inline, virtual]
className() | vl::FBODepthBufferAttachment | [inline, virtual]
create() | vl::FBORenderbufferAttachment |
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderbufferAttachment | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBODepthBufferAttachment(EDepthType type) | vl::FBODepthBufferAttachment | [inline]
FBORenderbufferAttachment() | vl::FBORenderbufferAttachment | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
handle() const | vl::FBORenderbufferAttachment | [inline]
height() const | vl::FBORenderbufferAttachment | [inline]
incReference() | vl::Object | [inline]
initStorage(int w, int h) | vl::FBORenderbufferAttachment |
initStorage() | vl::FBORenderbufferAttachment | [inline]
internalBindAttachment(int w, int h, int attach_point) | vl::FBORenderbufferAttachment | [protected]
internalType() | vl::FBODepthBufferAttachment | [inline, protected, virtual]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mHandle | vl::FBORenderbufferAttachment | [protected]
mHeight | vl::FBORenderbufferAttachment | [protected]
mName | vl::Object | [protected]
mReallocateRenderbuffer | vl::FBORenderbufferAttachment | [protected]
mSamples | vl::FBORenderbufferAttachment | [protected]
mType | vl::FBODepthBufferAttachment | [protected]
mWidth | vl::FBORenderbufferAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderbufferStorageReady() const | vl::FBORenderbufferAttachment | [inline]
samples() const | vl::FBORenderbufferAttachment | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int h) | vl::FBORenderbufferAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSamples(int samples) | vl::FBORenderbufferAttachment | [inline]
setType(EDepthType type) | vl::FBODepthBufferAttachment | [inline]
setWidth(int w) | vl::FBORenderbufferAttachment | [inline]
type() const | vl::FBODepthBufferAttachment | [inline]
width() const | vl::FBORenderbufferAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBODepthStencilBufferAttachment Member List

This is the complete list of members for vl::FBODepthStencilBufferAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBODepthStencilBufferAttachment | [inline, virtual]
className() | vl::FBODepthStencilBufferAttachment | [inline, virtual]
create() | vl::FBORenderbufferAttachment |
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderbufferAttachment | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBODepthStencilBufferAttachment(EDepthStencilType type) | vl::FBODepthStencilBufferAttachment | [inline]
FBORenderbufferAttachment() | vl::FBORenderbufferAttachment | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
handle() const | vl::FBORenderbufferAttachment | [inline]
height() const | vl::FBORenderbufferAttachment | [inline]
incReference() | vl::Object | [inline]
initStorage(int w, int h) | vl::FBORenderbufferAttachment |
initStorage() | vl::FBORenderbufferAttachment | [inline]
internalBindAttachment(int w, int h, int attach_point) | vl::FBORenderbufferAttachment | [protected]
internalType() | vl::FBODepthStencilBufferAttachment | [inline, protected, virtual]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mHandle | vl::FBORenderbufferAttachment | [protected]
mHeight | vl::FBORenderbufferAttachment | [protected]
mName | vl::Object | [protected]
mReallocateRenderbuffer | vl::FBORenderbufferAttachment | [protected]
mSamples | vl::FBORenderbufferAttachment | [protected]
mType | vl::FBODepthStencilBufferAttachment | [protected]
mWidth | vl::FBORenderbufferAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderbufferStorageReady() const | vl::FBORenderbufferAttachment | [inline]
samples() const | vl::FBORenderbufferAttachment | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int h) | vl::FBORenderbufferAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSamples(int samples) | vl::FBORenderbufferAttachment | [inline]
setType(EDepthStencilType type) | vl::FBODepthStencilBufferAttachment | [inline]
setWidth(int w) | vl::FBORenderbufferAttachment | [inline]
type() const | vl::FBODepthStencilBufferAttachment | [inline]
width() const | vl::FBORenderbufferAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBORenderTarget Member List

This is the complete list of members for vl::FBORenderTarget, including all inherited members.

activate() | vl::RenderTarget | [inline]
addColorAttachment(EAttachmentPoint color_attachment, FBOAttachmentAbstract *attachment) | vl::FBORenderTarget |
addDepthAttachment(FBOAttachmentAbstract *attachment) | vl::FBORenderTarget |
addStencilAttachment(FBOAttachmentAbstract *attachment) | vl::FBORenderTarget |
addTextureAttachment(EAttachmentPoint color_attachment, FBOAttachmentAbstract *attachment) | vl::FBORenderTarget |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindDrawBuffers() const | vl::RenderTarget |
bindFramebuffer() | vl::FBORenderTarget | [virtual]
checkDrawBuffers() const | vl::RenderTarget |
checkFramebufferStatus() | vl::FBORenderTarget |
className() | vl::FBORenderTarget | [inline, virtual]
create() | vl::FBORenderTarget | [inline]
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderTarget | [inline]
fboAttachments() const | vl::FBORenderTarget | [inline]
handle() const | vl::FBORenderTarget | [inline]
height() const | vl::RenderTarget | [inline]
incReference() | vl::Object | [inline]
mDrawBuffers | vl::RenderTarget | [protected]
mFBOAttachments | vl::FBORenderTarget |
mHandle | vl::FBORenderTarget |
mHeight | vl::RenderTarget | [protected]
mName | vl::Object | [protected]
mOpenGLContext | vl::RenderTarget | [protected]
mWidth | vl::RenderTarget | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext class | vl::FBORenderTarget | [friend]
openglContext() | vl::RenderTarget | [inline]
openglContext() const | vl::RenderTarget | [inline]
vl::RenderTarget::operator=(const Object &other) | vl::Object | [inline]
printFramebufferError(GLenum status) const | vl::FBORenderTarget |
referenceCount() const | vl::Object | [inline]
removeAllAttachments() | vl::FBORenderTarget |
removeAttachment(FBOAttachmentAbstract *attachment) | vl::FBORenderTarget |
removeAttachment(EAttachmentPoint attach_point) | vl::FBORenderTarget |
renderBuffers() | vl::RenderTarget | [inline]
RenderTarget(OpenGLContext *ctx, int w, int h) | vl::RenderTarget | [inline, protected]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3, EReadDrawBuffer render_buffer4) | vl::RenderTarget | [inline]
setDrawBuffers(const std::vector< EReadDrawBuffer > &render_buffers) | vl::RenderTarget | [inline]
setHeight(int height) | vl::RenderTarget | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWidth(int width) | vl::RenderTarget | [inline]
width() const | vl::RenderTarget | [inline]
~FBORenderTarget() | vl::FBORenderTarget | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBORenderbufferAttachment Member List

This is the complete list of members for vl::FBORenderbufferAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point)=0 | vl::FBOAttachmentAbstract | [pure virtual]
className() | vl::FBORenderbufferAttachment | [inline, virtual]
create() | vl::FBORenderbufferAttachment |
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderbufferAttachment | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBORenderbufferAttachment() | vl::FBORenderbufferAttachment | [inline]
FBORenderTarget class | vl::FBORenderbufferAttachment | [friend]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
handle() const | vl::FBORenderbufferAttachment | [inline]
height() const | vl::FBORenderbufferAttachment | [inline]
incReference() | vl::Object | [inline]
initStorage(int w, int h) | vl::FBORenderbufferAttachment |
initStorage() | vl::FBORenderbufferAttachment | [inline]
internalBindAttachment(int w, int h, int attach_point) | vl::FBORenderbufferAttachment | [protected]
internalType()=0 | vl::FBORenderbufferAttachment | [protected, pure virtual]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mHandle | vl::FBORenderbufferAttachment | [protected]
mHeight | vl::FBORenderbufferAttachment | [protected]
mName | vl::Object | [protected]
mReallocateRenderbuffer | vl::FBORenderbufferAttachment | [protected]
mSamples | vl::FBORenderbufferAttachment | [protected]
mWidth | vl::FBORenderbufferAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderbufferStorageReady() const | vl::FBORenderbufferAttachment | [inline]
samples() const | vl::FBORenderbufferAttachment | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int h) | vl::FBORenderbufferAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSamples(int samples) | vl::FBORenderbufferAttachment | [inline]
setWidth(int w) | vl::FBORenderbufferAttachment | [inline]
width() const | vl::FBORenderbufferAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOStencilBufferAttachment Member List

This is the complete list of members for vl::FBOStencilBufferAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOStencilBufferAttachment | [inline, virtual]
className() | vl::FBOStencilBufferAttachment | [inline, virtual]
create() | vl::FBORenderbufferAttachment |
decReference() | vl::Object | [inline]
destroy() | vl::FBORenderbufferAttachment | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
FBORenderbufferAttachment() | vl::FBORenderbufferAttachment | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOStencilBufferAttachment(EStencilType type) | vl::FBOStencilBufferAttachment | [inline]
handle() const | vl::FBORenderbufferAttachment | [inline]
height() const | vl::FBORenderbufferAttachment | [inline]
incReference() | vl::Object | [inline]
initStorage(int w, int h) | vl::FBORenderbufferAttachment |
initStorage() | vl::FBORenderbufferAttachment | [inline]
internalBindAttachment(int w, int h, int attach_point) | vl::FBORenderbufferAttachment | [protected]
internalType() | vl::FBOStencilBufferAttachment | [inline, protected, virtual]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mHandle | vl::FBORenderbufferAttachment | [protected]
mHeight | vl::FBORenderbufferAttachment | [protected]
mName | vl::Object | [protected]
mReallocateRenderbuffer | vl::FBORenderbufferAttachment | [protected]
mSamples | vl::FBORenderbufferAttachment | [protected]
mType | vl::FBOStencilBufferAttachment | [protected]
mWidth | vl::FBORenderbufferAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderbufferStorageReady() const | vl::FBORenderbufferAttachment | [inline]
samples() const | vl::FBORenderbufferAttachment | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int h) | vl::FBORenderbufferAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSamples(int samples) | vl::FBORenderbufferAttachment | [inline]
setType(EStencilType type) | vl::FBOStencilBufferAttachment | [inline]
setWidth(int w) | vl::FBORenderbufferAttachment | [inline]
type() const | vl::FBOStencilBufferAttachment | [inline]
width() const | vl::FBORenderbufferAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOTexture1DAttachment Member List

This is the complete list of members for vl::FBOTexture1DAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOTexture1DAttachment | [virtual]
className() | vl::FBOTexture1DAttachment | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOTexture1DAttachment(Texture *texture, int level) | vl::FBOTexture1DAttachment | [inline]
incReference() | vl::Object | [inline]
level() const | vl::FBOTexture1DAttachment | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mLevel | vl::FBOTexture1DAttachment | [protected]
mName | vl::Object | [protected]
mTexture | vl::FBOTexture1DAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
texture() | vl::FBOTexture1DAttachment | [inline]
texture() const | vl::FBOTexture1DAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOTexture2DAttachment Member List

This is the complete list of members for vl::FBOTexture2DAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOTexture2DAttachment | [virtual]
className() | vl::FBOTexture2DAttachment | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOTexture2DAttachment(Texture *texture, int level, ETex2DTarget target) | vl::FBOTexture2DAttachment | [inline]
incReference() | vl::Object | [inline]
level() const | vl::FBOTexture2DAttachment | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mLevel | vl::FBOTexture2DAttachment | [protected]
mName | vl::Object | [protected]
mTexture | vl::FBOTexture2DAttachment | [protected]
mTextureTarget | vl::FBOTexture2DAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTexture(Texture *texture) | vl::FBOTexture2DAttachment | [inline]
setTextureTarget(ETex2DTarget target) | vl::FBOTexture2DAttachment | [inline]
texture() | vl::FBOTexture2DAttachment | [inline]
texture() const | vl::FBOTexture2DAttachment | [inline]
textureTarget() const | vl::FBOTexture2DAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOTexture3DAttachment Member List

This is the complete list of members for vl::FBOTexture3DAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOTexture3DAttachment | [virtual]
className() | vl::FBOTexture3DAttachment | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOTexture3DAttachment(Texture *texture, int mipmap_level, int layer) | vl::FBOTexture3DAttachment | [inline]
incReference() | vl::Object | [inline]
layer() const | vl::FBOTexture3DAttachment | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mipmapLevel() const | vl::FBOTexture3DAttachment | [inline]
mLayer | vl::FBOTexture3DAttachment | [protected]
mMipmapLevel | vl::FBOTexture3DAttachment | [protected]
mName | vl::Object | [protected]
mTexture | vl::FBOTexture3DAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLayer(int layer) | vl::FBOTexture3DAttachment | [inline]
setMipmapLevel(int level) | vl::FBOTexture3DAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
texture() | vl::FBOTexture3DAttachment | [inline]
texture() const | vl::FBOTexture3DAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOTextureAttachment Member List

This is the complete list of members for vl::FBOTextureAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOTextureAttachment | [virtual]
className() | vl::FBOTextureAttachment | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOTextureAttachment(Texture *texture, int level) | vl::FBOTextureAttachment | [inline]
incReference() | vl::Object | [inline]
level() const | vl::FBOTextureAttachment | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mLevel | vl::FBOTextureAttachment | [protected]
mName | vl::Object | [protected]
mTexture | vl::FBOTextureAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
texture() | vl::FBOTextureAttachment | [inline]
texture() const | vl::FBOTextureAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FBOTextureLayerAttachment Member List

This is the complete list of members for vl::FBOTextureLayerAttachment, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindAttachment(int w, int h, EAttachmentPoint attach_point) | vl::FBOTextureLayerAttachment | [virtual]
className() | vl::FBOTextureLayerAttachment | [inline, virtual]
decReference() | vl::Object | [inline]
destroy() | vl::FBOAttachmentAbstract | [virtual]
FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline]
fboRenderTargets() const | vl::FBOAttachmentAbstract | [inline]
FBOTextureLayerAttachment(Texture *texture, int mipmap_level, int layer) | vl::FBOTextureLayerAttachment | [inline]
incReference() | vl::Object | [inline]
layer() const | vl::FBOTextureLayerAttachment | [inline]
mFBORenderTargets | vl::FBOAttachmentAbstract | [protected]
mipmapLevel() const | vl::FBOTextureLayerAttachment | [inline]
mLayer | vl::FBOTextureLayerAttachment | [protected]
mMipmapLevel | vl::FBOTextureLayerAttachment | [protected]
mName | vl::Object | [protected]
mTexture | vl::FBOTextureLayerAttachment | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLayer(int layer) | vl::FBOTextureLayerAttachment | [inline]
setMipmapLevel(int level) | vl::FBOTextureLayerAttachment | [inline]
setName(const std::string &name) | vl::Object | [inline]
texture() | vl::FBOTextureLayerAttachment | [inline]
texture() const | vl::FBOTextureLayerAttachment | [inline]
~FBOAttachmentAbstract() | vl::FBOAttachmentAbstract | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FileSystem Member List

This is the complete list of members for vl::FileSystem, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::FileSystem | [inline, virtual]
decReference() | vl::Object | [inline]
directories() | vl::FileSystem | [inline]
directories() const | vl::FileSystem | [inline]
FileSystem() | vl::FileSystem | [inline]
incReference() | vl::Object | [inline]
listFilesRecursive(std::vector< String > &file_list) const | vl::FileSystem | [virtual]
listFilesRecursive(std::vector< String > &file_list, const String &match) const | vl::FileSystem | [virtual]
locateDirectory(const String &name) const | vl::FileSystem | [virtual]
locateFile(const String &full_path, const String &alternate_path=String()) const | vl::FileSystem | [virtual]
mDirectories | vl::FileSystem | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::Fog Member List

This is the complete list of members for vl::Fog, including all inherited members.

apply(const Camera *) const | vl::Fog | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Fog | [inline, virtual]
color() const | vl::Fog | [inline]
decReference() | vl::Object | [inline]
density() const | vl::Fog | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
end() const | vl::Fog | [inline]
Fog(EFogMode mode=FM_LINEAR, fvec4 color=fvec4(0, 0, 0, 0), float density=1, float start=0, float end=1) | vl::Fog | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mColor | vl::Fog | [protected]
mDensity | vl::Fog | [protected]
mEnd | vl::Fog | [protected]
mMode | vl::Fog | [protected]
mName | vl::Object | [protected]
mode() const | vl::Fog | [inline]
mStart | vl::Fog | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EFogMode mode, fvec4 color, float density, float start, float end) | vl::Fog | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setColor(fvec4 color) | vl::Fog | [inline]
setDensity(float density) | vl::Fog | [inline]
setEnd(float end) | vl::Fog | [inline]
setMode(EFogMode mode) | vl::Fog | [inline]
setName(const std::string &name) | vl::Object | [inline]
setStart(float start) | vl::Fog | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
start() const | vl::Fog | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::Fog | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Font Member List

This is the complete list of members for vl::Font, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Font | [inline, virtual]
decReference() | vl::Object | [inline]
filePath() const | vl::Font | [inline]
FontManager class | vl::Font | [friend]
glyph(int character) | vl::Font |
incReference() | vl::Object | [inline]
loadFont(const String &path) | vl::Font |
mFilePath | vl::Font | [protected]
mFT_Face | vl::Font | [protected]
mGlyphMap | vl::Font | [protected]
mHeight | vl::Font | [protected]
mMemoryFile | vl::Font | [protected]
mName | vl::Object | [protected]
mSize | vl::Font | [protected]
mSmooth | vl::Font | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator<(const Font &other) const | vl::Font | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
releaseFreeTypeData() | vl::Font |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSize(int size) | vl::Font |
setSmooth(bool smooth) | vl::Font |
size() const | vl::Font | [inline]
smooth() const | vl::Font | [inline]
Text class | vl::Font | [friend]
~Font() | vl::Font |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FontManager Member List

This is the complete list of members for vl::FontManager, including all inherited members.

acquireFont(const String &font, int size, bool smooth=false) | vl::FontManager |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::FontManager | [inline, virtual]
decReference() | vl::Object | [inline]
fonts() const | vl::FontManager | [inline]
incReference() | vl::Object | [inline]
mFonts | vl::FontManager | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
releaseAllFonts() | vl::FontManager |
releaseFont(Font *font) | vl::FontManager |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::FrontFace Member List

This is the complete list of members for vl::FrontFace, including all inherited members.

apply(const Camera *) const | vl::FrontFace | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::FrontFace | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
FrontFace(EFrontFace frontface=FF_CCW) | vl::FrontFace | [inline]
frontFace() const | vl::FrontFace | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mFrontFace | vl::FrontFace | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EFrontFace frontface) | vl::FrontFace | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::FrontFace | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Frustum Member List

This is the complete list of members for vl::Frustum, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Frustum | [inline, virtual]
cull(const Sphere &sphere) const | vl::Frustum | [inline]
cull(const AABB &aabb) const | vl::Frustum | [inline]
cull(const std::vector< fvec3 > &points) const | vl::Frustum | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mPlanes | vl::Frustum | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
plane(unsigned i) const | vl::Frustum | [inline]
planes() | vl::Frustum | [inline]
planes() const | vl::Frustum | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPlane(unsigned i, const Plane &plane) | vl::Frustum | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::GLBufferObject Member List

This is the complete list of members for vl::GLBufferObject, including all inherited members.

alignedFree(void *ptr) | vl::Buffer | [inline, static]
alignedMalloc(int bytes, int alignment) | vl::Buffer | [inline, static]
alignment() const | vl::Buffer | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
Buffer() | vl::Buffer | [inline]
Buffer(const Buffer &other) | vl::Buffer | [inline]
byteCountGPU() const | vl::GLBufferObject | [inline]
bytesUsed() const | vl::Buffer | [inline]
className() | vl::GLBufferObject | [inline, virtual]
clear() | vl::Buffer | [inline]
createGLBufferObject() | vl::GLBufferObject | [inline]
decReference() | vl::Object | [inline]
deleteGLBufferObject() | vl::GLBufferObject | [inline]
downloadGLBufferObject() | vl::GLBufferObject | [inline]
empty() const | vl::Buffer | [inline]
GLBufferObject() | vl::GLBufferObject | [inline]
GLBufferObject(const GLBufferObject &other) | vl::GLBufferObject | [inline]
handle() const | vl::GLBufferObject | [inline]
incReference() | vl::Object | [inline]
mAlignment | vl::Buffer | [protected]
mapGPUBuffer(EGLBufferAccess access) | vl::GLBufferObject | [inline]
mByteCount | vl::Buffer | [protected]
mByteCountGPU | vl::GLBufferObject | [protected]
mHandle | vl::GLBufferObject | [protected]
mName | vl::Object | [protected]
mPtr | vl::Buffer | [protected]
mUsage | vl::GLBufferObject | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const GLBufferObject &other) | vl::GLBufferObject | [inline]
vl::Buffer::operator=(const Buffer &other) | vl::Buffer | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
ptr() | vl::Buffer | [inline]
ptr() const | vl::Buffer | [inline]
referenceCount() const | vl::Object | [inline]
resize(int byte_count, int alignment=0) | vl::Buffer | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBufferData(EGLBufferUsage usage, bool discard_local_storage=false) | vl::GLBufferObject | [inline]
setBufferData(int byte_count, const GLvoid *data, EGLBufferUsage usage) | vl::GLBufferObject | [inline]
setBufferSubData(GLintptr offset=0, int byte_count=-1, bool discard_local_storage=false) | vl::GLBufferObject | [inline]
setBufferSubData(GLintptr offset, int byte_count, const GLvoid *data) | vl::GLBufferObject | [inline]
setName(const std::string &name) | vl::Object | [inline]
swap(GLBufferObject &other) | vl::GLBufferObject | [inline]
vl::Buffer::swap(Buffer &other) | vl::Buffer | [inline]
unmapGPUBuffer() | vl::GLBufferObject | [inline]
usage() const | vl::GLBufferObject | [inline]
~Buffer() | vl::Buffer | [inline]
~GLBufferObject() | vl::GLBufferObject | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GLSLFragmentShader Member List

This is the complete list of members for vl::GLSLFragmentShader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::GLSLFragmentShader | [inline, virtual]
compile() | vl::GLSLShader |
compileStatus() const | vl::GLSLShader |
createShader() | vl::GLSLShader |
decReference() | vl::Object | [inline]
deleteShader() | vl::GLSLShader |
GLSLFragmentShader(const String &source=String()) | vl::GLSLFragmentShader | [inline]
GLSLShader(EShaderType type, const String &source=String()) | vl::GLSLShader |
handle() const | vl::GLSLShader | [inline]
incReference() | vl::Object | [inline]
infoLog() const | vl::GLSLShader |
mCompiled | vl::GLSLShader | [protected]
mHandle | vl::GLSLShader | [protected]
mName | vl::Object | [protected]
mSource | vl::GLSLShader | [protected]
mType | vl::GLSLShader | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSource(const std::string &source) | vl::GLSLShader |
setSource(const String &source) | vl::GLSLShader |
source() const | vl::GLSLShader | [inline]
type() const | vl::GLSLShader | [inline]
~GLSLShader() | vl::GLSLShader |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GLSLGeometryShader Member List

This is the complete list of members for vl::GLSLGeometryShader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::GLSLGeometryShader | [inline, virtual]
compile() | vl::GLSLShader |
compileStatus() const | vl::GLSLShader |
createShader() | vl::GLSLShader |
decReference() | vl::Object | [inline]
deleteShader() | vl::GLSLShader |
GLSLGeometryShader(const String &source=String()) | vl::GLSLGeometryShader | [inline]
GLSLShader(EShaderType type, const String &source=String()) | vl::GLSLShader |
handle() const | vl::GLSLShader | [inline]
incReference() | vl::Object | [inline]
infoLog() const | vl::GLSLShader |
mCompiled | vl::GLSLShader | [protected]
mHandle | vl::GLSLShader | [protected]
mName | vl::Object | [protected]
mSource | vl::GLSLShader | [protected]
mType | vl::GLSLShader | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSource(const std::string &source) | vl::GLSLShader |
setSource(const String &source) | vl::GLSLShader |
source() const | vl::GLSLShader | [inline]
type() const | vl::GLSLShader | [inline]
~GLSLShader() | vl::GLSLShader |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GLSLProgram Member List

This is the complete list of members for vl::GLSLProgram, including all inherited members.

apply(const Camera *) const | vl::GLSLProgram | [virtual]
applyUniformSet(const UniformSet *uniforms) const | vl::GLSLProgram |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
attachShader(GLSLShader *shader) | vl::GLSLProgram |
automaticDelete() const | vl::Object | [inline]
bindAttribLocation(unsigned int index, const std::string &name) | vl::GLSLProgram |
bindFragDataLocation(int color_number, const std::string &name) | vl::GLSLProgram |
className() | vl::GLSLProgram | [inline, virtual]
createProgram() | vl::GLSLProgram |
decReference() | vl::Object | [inline]
deleteProgram() | vl::GLSLProgram |
detachAllShaders() | vl::GLSLProgram |
detachShader(GLSLShader *shader) | vl::GLSLProgram |
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
fragDataLocationBinding(const std::string &name) const | vl::GLSLProgram |
geometryInputType() const | vl::GLSLProgram | [inline]
geometryOutputType() const | vl::GLSLProgram | [inline]
geometryVerticesOut() const | vl::GLSLProgram | [inline]
getAttribLocation(const char *name) const | vl::GLSLProgram | [inline]
getUniform(int location, fvec2 &vec) const | vl::GLSLProgram | [inline]
getUniform(int location, fvec3 &vec) const | vl::GLSLProgram | [inline]
getUniform(int location, fvec4 &vec) const | vl::GLSLProgram | [inline]
getUniform(int location, fmat2 &mat) const | vl::GLSLProgram | [inline]
getUniform(int location, fmat3 &mat) const | vl::GLSLProgram | [inline]
getUniform(int location, fmat4 &mat) const | vl::GLSLProgram | [inline]
getUniform(int location, ivec2 &vec) const | vl::GLSLProgram | [inline]
getUniform(int location, ivec3 &vec) const | vl::GLSLProgram | [inline]
getUniform(int location, ivec4 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fvec2 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fvec3 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fvec4 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fmat2 &mat) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fmat3 &mat) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, fmat4 &mat) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, ivec2 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, ivec3 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name, ivec4 &vec) const | vl::GLSLProgram | [inline]
getUniform(const std::string &name) | vl::GLSLProgram | [inline]
getUniformfv(int location, float *params) const | vl::GLSLProgram | [inline]
getUniformfv(const std::string &name, float *params) const | vl::GLSLProgram | [inline]
getUniformiv(int location, int *params) const | vl::GLSLProgram | [inline]
getUniformiv(const std::string &name, int *params) const | vl::GLSLProgram | [inline]
getUniformLocation(const std::string &name) const | vl::GLSLProgram | [inline]
GLSLProgram() | vl::GLSLProgram |
gocUniform(const std::string &name) | vl::GLSLProgram | [inline]
handle() const | vl::GLSLProgram | [inline]
incReference() | vl::Object | [inline]
infoLog() const | vl::GLSLProgram |
initResources() | vl::GLSLProgram | [virtual]
linked() const | vl::GLSLProgram | [inline]
linkProgram(bool force_relink=false) | vl::GLSLProgram |
linkStatus() const | vl::GLSLProgram |
maxVertexAttributes() | vl::GLSLProgram | [static]
mFragDataLocation | vl::GLSLProgram | [protected]
mGeometryInputType | vl::GLSLProgram | [protected]
mGeometryOutputType | vl::GLSLProgram | [protected]
mGeometryVerticesOut | vl::GLSLProgram | [protected]
mHandle | vl::GLSLProgram | [protected]
mName | vl::Object | [protected]
mScheduleLink | vl::GLSLProgram | [protected]
mShaders | vl::GLSLProgram | [protected]
mTextureUnit | vl::RenderState | [protected]
mUniformLocation | vl::GLSLProgram | [protected]
mUniformSet | vl::GLSLProgram | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
Renderer class | vl::GLSLProgram | [friend]
RenderState() | vl::RenderState | [inline]
scheduleRelinking() | vl::GLSLProgram |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setGeometryInputType(EGeometryInputType type) | vl::GLSLProgram | [inline]
setGeometryOutputType(EGeometryOutputType type) | vl::GLSLProgram | [inline]
setGeometryVerticesOut(int vertex_count) | vl::GLSLProgram | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUniform(Uniform *uniform) | vl::GLSLProgram | [inline]
setUniformSet(UniformSet *uniforms) | vl::GLSLProgram | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
shader(int i) const | vl::GLSLProgram | [inline]
shader(int i) | vl::GLSLProgram | [inline]
shaderCount() const | vl::GLSLProgram | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::GLSLProgram | [inline, virtual]
unbindFragDataLocation(const std::string &name) | vl::GLSLProgram |
uniformSet() | vl::GLSLProgram | [inline]
uniformSet() const | vl::GLSLProgram | [inline]
useProgram() const | vl::GLSLProgram |
validateProgram() const | vl::GLSLProgram |
~GLSLProgram() | vl::GLSLProgram |
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GLSLShader Member List

This is the complete list of members for vl::GLSLShader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::GLSLShader | [inline, virtual]
compile() | vl::GLSLShader |
compileStatus() const | vl::GLSLShader |
createShader() | vl::GLSLShader |
decReference() | vl::Object | [inline]
deleteShader() | vl::GLSLShader |
GLSLShader(EShaderType type, const String &source=String()) | vl::GLSLShader |
handle() const | vl::GLSLShader | [inline]
incReference() | vl::Object | [inline]
infoLog() const | vl::GLSLShader |
mCompiled | vl::GLSLShader | [protected]
mHandle | vl::GLSLShader | [protected]
mName | vl::Object | [protected]
mSource | vl::GLSLShader | [protected]
mType | vl::GLSLShader | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSource(const std::string &source) | vl::GLSLShader |
setSource(const String &source) | vl::GLSLShader |
source() const | vl::GLSLShader | [inline]
type() const | vl::GLSLShader | [inline]
~GLSLShader() | vl::GLSLShader |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GLSLVertexShader Member List

This is the complete list of members for vl::GLSLVertexShader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::GLSLVertexShader | [inline, virtual]
compile() | vl::GLSLShader |
compileStatus() const | vl::GLSLShader |
createShader() | vl::GLSLShader |
decReference() | vl::Object | [inline]
deleteShader() | vl::GLSLShader |
GLSLShader(EShaderType type, const String &source=String()) | vl::GLSLShader |
GLSLVertexShader(const String &source=String()) | vl::GLSLVertexShader | [inline]
handle() const | vl::GLSLShader | [inline]
incReference() | vl::Object | [inline]
infoLog() const | vl::GLSLShader |
mCompiled | vl::GLSLShader | [protected]
mHandle | vl::GLSLShader | [protected]
mName | vl::Object | [protected]
mSource | vl::GLSLShader | [protected]
mType | vl::GLSLShader | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSource(const std::string &source) | vl::GLSLShader |
setSource(const String &source) | vl::GLSLShader |
source() const | vl::GLSLShader | [inline]
type() const | vl::GLSLShader | [inline]
~GLSLShader() | vl::GLSLShader |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::GZipCodec Member List

This is the complete list of members for vl::GZipCodec, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CHUNK_SIZE | vl::GZipCodec | [protected, static]
className() | vl::GZipCodec | [inline, virtual]
clone() const | vl::GZipCodec | [virtual]
close() | vl::GZipCodec | [virtual]
compressedSize() const | vl::GZipCodec | [inline]
compressionLevel() const | vl::GZipCodec | [inline]
compressionRatio() const | vl::GZipCodec |
crc32() | vl::VirtualFile |
decReference() | vl::Object | [inline]
endOfFile() const | vl::VirtualFile | [inline]
exists() const | vl::GZipCodec | [inline, virtual]
fillUncompressedBuffer() | vl::GZipCodec | [protected]
GZipCodec(VirtualFile *stream=NULL) | vl::GZipCodec |
GZipCodec(const String &gz_path) | vl::GZipCodec |
incReference() | vl::Object | [inline]
isOpen() const | vl::GZipCodec | [inline, virtual]
load(std::vector< unsigned char > &data) | vl::VirtualFile |
load(void *buffer, long long max=-1) | vl::VirtualFile |
mCompressionLevel | vl::GZipCodec | [protected]
md5() | vl::VirtualFile |
mMode | vl::GZipCodec | [protected]
mName | vl::Object | [protected]
mPath | vl::VirtualFile | [protected]
mReadBytes | vl::GZipCodec | [protected]
mStream | vl::GZipCodec | [protected]
mStreamSize | vl::GZipCodec | [protected]
mUncompressedBuffer | vl::GZipCodec | [protected]
mUncompressedBufferPtr | vl::GZipCodec | [protected]
mUncompressedSize | vl::GZipCodec | [protected]
mWarnOnSeek | vl::GZipCodec | [protected]
mWrittenBytes | vl::GZipCodec | [protected]
mZipBufferIn | vl::GZipCodec | [protected]
mZipBufferOut | vl::GZipCodec | [protected]
mZStream | vl::GZipCodec | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
open(EOpenMode mode) | vl::GZipCodec | [virtual]
operator=(const GZipCodec &other) | vl::GZipCodec |
vl::VirtualFile::operator=(const VirtualFile &other) | vl::VirtualFile | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualFile | [inline]
peek(void *buffer, long long byte_count) | vl::VirtualFile |
position() const | vl::VirtualFile |
position_Implementation() const | vl::GZipCodec | [protected, virtual]
read(void *buffer, long long byte_count) | vl::VirtualFile |
read_Implementation(void *buffer, long long bytes_to_read) | vl::GZipCodec | [protected, virtual]
readDouble(bool little_endian_data=true) | vl::VirtualFile |
readDouble(void *buffer, long long count) | vl::VirtualFile |
readFloat(bool little_endian_data=true) | vl::VirtualFile |
readFloat(void *buffer, long long count) | vl::VirtualFile |
readSByte() | vl::VirtualFile |
readSByte(void *buffer, long long count) | vl::VirtualFile |
readSInt16(bool little_endian_data=true) | vl::VirtualFile |
readSInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt32(bool little_endian_data=true) | vl::VirtualFile |
readSInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt64(bool little_endian_data=true) | vl::VirtualFile |
readSInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUByte() | vl::VirtualFile |
readUByte(void *buffer, long long count) | vl::VirtualFile |
readUInt16(bool little_endian_data=true) | vl::VirtualFile |
readUInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt32(bool little_endian_data=true) | vl::VirtualFile |
readUInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt64(bool little_endian_data=true) | vl::VirtualFile |
readUInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
referenceCount() const | vl::Object | [inline]
resetStream() | vl::GZipCodec | [protected]
seekCur(long long offset) | vl::VirtualFile |
seekEnd(long long offset) | vl::VirtualFile |
seekSet(long long offset) | vl::VirtualFile |
seekSet_Implementation(long long pos) | vl::GZipCodec | [protected, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCompressionLevel(int level) | vl::GZipCodec | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::VirtualFile | [inline]
setStream(VirtualFile *stream) | vl::GZipCodec |
setWarnOnSeek(bool warn_on) | vl::GZipCodec | [inline]
size() const | vl::GZipCodec | [virtual]
stream() const | vl::GZipCodec | [inline]
stream() | vl::GZipCodec | [inline]
uncompressedSize() | vl::GZipCodec |
VirtualFile(const VirtualFile &other) | vl::VirtualFile | [inline, protected]
VirtualFile() | vl::VirtualFile | [inline]
warnOnSeek() const | vl::GZipCodec | [inline]
write(const void *buffer, long long byte_count) | vl::VirtualFile |
write_Implementation(const void *buffer, long long byte_count) | vl::GZipCodec | [protected, virtual]
writeSInt16(short data, bool little_endian=true) | vl::VirtualFile |
writeSInt32(long data, bool little_endian=true) | vl::VirtualFile |
writeSInt8(char data) | vl::VirtualFile |
writeUInt16(unsigned short data, bool little_endian=true) | vl::VirtualFile |
writeUInt32(unsigned long data, bool little_endian=true) | vl::VirtualFile |
writeUInt8(unsigned char data) | vl::VirtualFile |
ZCompress enum value | vl::GZipCodec | [protected]
ZDecompress enum value | vl::GZipCodec | [protected]
ZNone enum value | vl::GZipCodec | [protected]
~GZipCodec() | vl::GZipCodec |
~Object() | vl::Object | [protected, virtual]
~VirtualFile() | vl::VirtualFile | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::Geometry Member List

This is the complete list of members for vl::Geometry, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::Geometry | [inline, virtual]
clearArrays(bool clear_draw_calls=true) | vl::Geometry | [virtual]
colorArray() const | vl::Geometry | [inline]
colorArray() | vl::Geometry | [inline]
colorizePrimitives() | vl::Geometry |
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation() | vl::Geometry | [virtual]
computeNormals() | vl::Geometry |
convertPrimitivesToDrawArrays() | vl::Geometry |
decReference() | vl::Object | [inline]
deepCopy() const | vl::Geometry |
deleteDisplayList() | vl::Renderable | [inline]
deleteVBOs() | vl::Geometry | [virtual]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
eraseVertexAttributeByName(unsigned int name) | vl::Geometry |
findVertexAttribute(unsigned int name) const | vl::Geometry |
findVertexAttribute(unsigned int name) | vl::Geometry |
fogCoordArray() const | vl::Geometry | [inline]
fogCoordArray() | vl::Geometry | [inline]
Geometry() | vl::Geometry |
incReference() | vl::Object | [inline]
lineCount() const | vl::Geometry | [virtual]
mergeTriangleStrips() | vl::Geometry |
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
normalArray() const | vl::Geometry | [inline]
normalArray() | vl::Geometry | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Geometry &other) | vl::Geometry |
vl::Renderable::operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::Geometry | [virtual]
primitives() | vl::Geometry | [inline]
primitives() const | vl::Geometry | [inline]
referenceCount() const | vl::Object | [inline]
regenerateVertices(const std::vector< unsigned int > &map_new_to_old) | vl::Geometry |
render(const Actor *, const OpenGLContext *, const Camera *) const | vl::Geometry | [virtual]
Renderable() | vl::Renderable | [inline]
secondaryColorArray() const | vl::Geometry | [inline]
secondaryColorArray() | vl::Geometry | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setColorArray(const fvec4 &col) | vl::Geometry |
setColorArray(ArrayAbstract *data) | vl::Geometry |
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setFogCoordArray(ArrayAbstract *data) | vl::Geometry |
setName(const std::string &name) | vl::Object | [inline]
setNormalArray(ArrayAbstract *data) | vl::Geometry |
setSecondaryColorArray(ArrayAbstract *data) | vl::Geometry |
setTexCoordArray(int tex_unit, ArrayAbstract *data) | vl::Geometry |
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
setVertexArray(ArrayAbstract *data) | vl::Geometry |
setVertexAttributeArray(unsigned int name, bool normalize, bool pure_integer, ArrayAbstract *data) | vl::Geometry | [inline]
setVertexAttributeArray(const VertexAttributeArray &info) | vl::Geometry |
shallowCopy() | vl::Geometry |
shrinkDrawElements() | vl::Geometry |
sortTriangles() | vl::Geometry |
sortVertices() | vl::Geometry |
texCoordArray(int tex_unit) const | vl::Geometry | [inline]
texCoordArray(int tex_unit) | vl::Geometry | [inline]
transform(const mat4 &matr, bool normalize=true) | vl::Geometry |
triangleCount() const | vl::Geometry | [virtual]
updateVBOs(bool discard_local_data=false) | vl::Geometry | [virtual]
updateVBOs() | vl::Geometry |
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
vertexArray() const | vl::Geometry | [inline]
vertexArray() | vl::Geometry | [inline]
vertexAttributeArrays() | vl::Geometry | [inline]
vertexAttributeArrays() const | vl::Geometry | [inline]
~Geometry() | vl::Geometry | [virtual]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::GeometryLoadCallback Member List

This is the complete list of members for vl::GeometryLoadCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::GeometryLoadCallback | [inline, virtual]
computeNormals() const | vl::GeometryLoadCallback | [inline]
convertToDrawArrays() const | vl::GeometryLoadCallback | [inline]
decReference() | vl::Object | [inline]
discardOriginalNormals() const | vl::GeometryLoadCallback | [inline]
GeometryLoadCallback() | vl::GeometryLoadCallback | [inline]
incReference() | vl::Object | [inline]
mComputeNormals | vl::GeometryLoadCallback | [protected]
mConvertToDrawArrays | vl::GeometryLoadCallback | [protected]
mDiscardOriginalNormals | vl::GeometryLoadCallback | [protected]
mMatrix | vl::GeometryLoadCallback | [protected]
mName | vl::Object | [protected]
mRemoveDoubles | vl::GeometryLoadCallback | [protected]
mSortTriangles | vl::GeometryLoadCallback | [protected]
mSortVertices | vl::GeometryLoadCallback | [protected]
mStripfy | vl::GeometryLoadCallback | [protected]
mTransformGeometry | vl::GeometryLoadCallback | [protected]
mUseDisplayLists | vl::GeometryLoadCallback | [protected]
mUseVBOs | vl::GeometryLoadCallback | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(ResourceDatabase *db) | vl::GeometryLoadCallback | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
removeDoubles() const | vl::GeometryLoadCallback | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setComputeNormals(bool cn) | vl::GeometryLoadCallback | [inline]
setConvertToDrawArrays(bool on) | vl::GeometryLoadCallback | [inline]
setDiscardOriginalNormals(bool on) | vl::GeometryLoadCallback | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRemoveDoubles(bool rd) | vl::GeometryLoadCallback | [inline]
setSortTriangles(bool on) | vl::GeometryLoadCallback | [inline]
setSortVertices(bool on) | vl::GeometryLoadCallback | [inline]
setStripfy(bool on) | vl::GeometryLoadCallback | [inline]
setTransformGeometry(bool on) | vl::GeometryLoadCallback | [inline]
setTransformMatrix(const mat4 &m) | vl::GeometryLoadCallback | [inline]
setUseDisplayLists(bool on) | vl::GeometryLoadCallback | [inline]
setUseVBOs(bool on) | vl::GeometryLoadCallback | [inline]
sortTriangles() const | vl::GeometryLoadCallback | [inline]
sortVertices() const | vl::GeometryLoadCallback | [inline]
stripfy() const | vl::GeometryLoadCallback | [inline]
transformGeometry() const | vl::GeometryLoadCallback | [inline]
transformMatrix() const | vl::GeometryLoadCallback | [inline]
useDisplayLists() const | vl::GeometryLoadCallback | [inline]
useVBOs() const | vl::GeometryLoadCallback | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::GhostCameraManipulator Member List

This is the complete list of members for vl::GhostCameraManipulator, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
camera() | vl::GhostCameraManipulator |
camera() const | vl::GhostCameraManipulator |
className() | vl::GhostCameraManipulator | [inline, virtual]
decReference() | vl::Object | [inline]
destroyEvent() | vl::UIEventListener | [inline, virtual]
fileDroppedEvent(const std::vector< String > &) | vl::UIEventListener | [inline, virtual]
GhostCameraManipulator() | vl::GhostCameraManipulator |
incReference() | vl::Object | [inline]
initEvent() | vl::UIEventListener | [inline, virtual]
isEnabled() const | vl::UIEventListener | [inline]
keyPressEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
keyReleaseEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
mCamera | vl::GhostCameraManipulator | [protected]
mEnabled | vl::UIEventListener | [protected]
mKeysBackward | vl::GhostCameraManipulator | [protected]
mKeysDown | vl::GhostCameraManipulator | [protected]
mKeysForward | vl::GhostCameraManipulator | [protected]
mKeysLeft | vl::GhostCameraManipulator | [protected]
mKeysRight | vl::GhostCameraManipulator | [protected]
mKeysUp | vl::GhostCameraManipulator | [protected]
mLastTime | vl::GhostCameraManipulator | [protected]
mMovementSpeed | vl::GhostCameraManipulator | [protected]
mName | vl::Object | [protected]
mOpenGLContext | vl::UIEventListener | [protected]
mouseDownEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseMoveEvent(int x, int y) | vl::GhostCameraManipulator | [virtual]
mouseUpEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseWheelEvent(int) | vl::UIEventListener | [inline, virtual]
movementSpeed() const | vl::GhostCameraManipulator | [inline]
mPosition | vl::GhostCameraManipulator | [protected]
mRank | vl::UIEventListener | [protected]
mRotationSpeed | vl::GhostCameraManipulator | [protected]
mXDegrees | vl::GhostCameraManipulator | [protected]
mYDegrees | vl::GhostCameraManipulator | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
openglContext() | vl::UIEventListener |
openglContextBoundEvent(OpenGLContext *) | vl::UIEventListener | [inline, virtual]
operator<(const UIEventListener &other) const | vl::UIEventListener | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vl::GhostCameraManipulator | [inline]
prepareToReconnect() | vl::GhostCameraManipulator | [virtual]
rank() const | vl::UIEventListener |
referenceCount() const | vl::Object | [inline]
resizeEvent(int, int) | vl::UIEventListener | [inline, virtual]
rotationSpeed() const | vl::GhostCameraManipulator | [inline]
runEvent() | vl::GhostCameraManipulator | [virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCamera(Camera *camera) | vl::GhostCameraManipulator |
setEnabled(bool enabled) | vl::UIEventListener | [inline, virtual]
setKeysBackward(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setKeysDown(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setKeysForward(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setKeysLeft(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setKeysRight(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setKeysUp(EKey key, EKey modifier=Key_None) | vl::GhostCameraManipulator | [inline]
setMovementSpeed(Real speed) | vl::GhostCameraManipulator | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPosition(vec3 position) | vl::GhostCameraManipulator | [inline]
setRank(int rank) | vl::UIEventListener |
setRotationSpeed(Real speed) | vl::GhostCameraManipulator | [inline]
setXDegrees(Real degree) | vl::GhostCameraManipulator | [inline]
setYDegrees(Real degree) | vl::GhostCameraManipulator | [inline]
UIEventListener() | vl::UIEventListener | [inline]
visibilityEvent(bool) | vl::UIEventListener | [inline, virtual]
xDegrees() | vl::GhostCameraManipulator | [inline]
yDegrees() | vl::GhostCameraManipulator | [inline]
~Object() | vl::Object | [protected, virtual]
~UIEventListener() | vl::UIEventListener | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::Glyph Member List

This is the complete list of members for vl::Glyph, including all inherited members.

advance() const | vl::Glyph | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Glyph | [inline, virtual]
decReference() | vl::Object | [inline]
font() const | vl::Glyph | [inline]
Glyph() | vl::Glyph | [inline]
glyphIndex() const | vl::Glyph | [inline]
height() const | vl::Glyph | [inline]
incReference() | vl::Object | [inline]
left() const | vl::Glyph | [inline]
mAdvance | vl::Glyph | [protected]
mFont | vl::Glyph | [protected]
mGlyphIndex | vl::Glyph | [protected]
mHeight | vl::Glyph | [protected]
mLeft | vl::Glyph | [protected]
mName | vl::Object | [protected]
mS0 | vl::Glyph | [protected]
mS1 | vl::Glyph | [protected]
mT0 | vl::Glyph | [protected]
mT1 | vl::Glyph | [protected]
mTextureHandle | vl::Glyph | [protected]
mTop | vl::Glyph | [protected]
mWidth | vl::Glyph | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
s0() const | vl::Glyph | [inline]
s1() const | vl::Glyph | [inline]
setAdvance(const fvec2 &advance) | vl::Glyph | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFont(Font *font) | vl::Glyph | [inline]
setGlyphIndex(unsigned int glyph_index) | vl::Glyph | [inline]
setHeight(int height) | vl::Glyph | [inline]
setLeft(int left) | vl::Glyph | [inline]
setName(const std::string &name) | vl::Object | [inline]
setS0(float s0) | vl::Glyph | [inline]
setS1(float s1) | vl::Glyph | [inline]
setT0(float t0) | vl::Glyph | [inline]
setT1(float t1) | vl::Glyph | [inline]
setTextureHandle(unsigned int handle) | vl::Glyph | [inline]
setTop(int top) | vl::Glyph | [inline]
setWidth(int width) | vl::Glyph | [inline]
t0() const | vl::Glyph | [inline]
t1() const | vl::Glyph | [inline]
textureHandle() const | vl::Glyph | [inline]
top() const | vl::Glyph | [inline]
width() const | vl::Glyph | [inline]
~Glyph() | vl::Glyph |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::Hint Member List

This is the complete list of members for vl::Hint, including all inherited members.

apply(const Camera *) const | vl::Hint | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Hint | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
fogHint() const | vl::Hint | [inline]
generateMipmapHint() const | vl::Hint | [inline]
Hint() | vl::Hint | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
lineSmoothHint() const | vl::Hint | [inline]
mFogHint | vl::Hint | [protected]
mGenerateMipmapHint | vl::Hint | [protected]
mLineSmoothHint | vl::Hint | [protected]
mName | vl::Object | [protected]
mPerspectiveCorrectionHint | vl::Hint | [protected]
mPointSmoothHint | vl::Hint | [protected]
mPolygonSmoothHint | vl::Hint | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
perspectiveCorrectionHint() const | vl::Hint | [inline]
pointSmoothHint() const | vl::Hint | [inline]
polygonSmoohtHint() const | vl::Hint | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFogHint(EHintMode mode) | vl::Hint | [inline]
setGenerateMipmapHint(EHintMode mode) | vl::Hint | [inline]
setLineSmoothHint(EHintMode mode) | vl::Hint | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPerspectiveCorrectionHint(EHintMode mode) | vl::Hint | [inline]
setPointSmoothHint(EHintMode mode) | vl::Hint | [inline]
setPolygonSmoohtHint(EHintMode mode) | vl::Hint | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::Hint | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Image Member List

This is the complete list of members for vl::Image, including all inherited members.

allocate() | vl::Image |
allocate1D(int x, EImageFormat format, EImageType type) | vl::Image |
allocate2D(int x, int y, int bytealign, EImageFormat format, EImageType type) | vl::Image |
allocate3D(int x, int y, int z, int bytealign, EImageFormat format, EImageType type) | vl::Image |
allocateCubemap(int x, int y, int bytealign, EImageFormat format, EImageType type) | vl::Image |
alphaBits() const | vl::Image |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bitsPerPixel(EImageType type, EImageFormat format) | vl::Image | [static]
bitsPerPixel() const | vl::Image | [inline]
byteAlignment() const | vl::Image |
className() | vl::Image | [inline, virtual]
clear() | vl::Image |
clearMipmaps() | vl::Image | [inline]
contrast(float black, float white) | vl::Image |
contrastHounsfield(float center, float width, float intercept, float range) | vl::Image |
contrastHounsfieldAuto() | vl::Image |
convertFormat(EImageFormat new_format) const | vl::Image |
convertType(EImageType new_type) const | vl::Image |
copySubImage(Image *img_src, RectI src, ivec2 dst) | vl::Image |
createCubemap(const Image *xp, const Image *xn, const Image *yp, const Image *yn, const Image *zp, const Image *zn) | vl::Image | [static]
decReference() | vl::Object | [inline]
depth() const | vl::Image | [inline]
dimension() const | vl::Image |
empty() | vl::Image | [inline]
equalize() | vl::Image |
flipVertically() | vl::Image |
format() const | vl::Image | [inline]
height() const | vl::Image | [inline]
Image() | vl::Image |
Image(const String &path) | vl::Image |
Image(int x, int y, int z, int bytealign, EImageFormat format, EImageType type) | vl::Image |
imageBuffer() | vl::Image | [inline]
imageBuffer() const | vl::Image | [inline]
incReference() | vl::Object | [inline]
isCompressedFormat(EImageFormat fmt) | vl::Image | [static]
isCubemap() const | vl::Image | [inline]
isValid() const | vl::Image |
makeColorSpectrum(int width, const std::vector< fvec4 > &colors) | vl::Image | [static]
makeColorSpectrum(int width, const fvec4 &c0, const fvec4 &c1) | vl::Image | [static]
makeColorSpectrum(int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2) | vl::Image | [static]
makeColorSpectrum(int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2, const fvec4 &c3) | vl::Image | [static]
makeColorSpectrum(int width, const fvec4 &c0, const fvec4 &c1, const fvec4 &c2, const fvec4 &c3, const fvec4 &c4) | vl::Image | [static]
makeNonUniformColorSpectrum(int width, const std::vector< fvec4 > &colors, const std::vector< float > &col_pos) | vl::Image | [inline, static]
makeNonUniformColorSpectrum(int width, int col_count, const fvec4 *colors, const float *col_pos) | vl::Image | [static]
mByteAlign | vl::Image | [protected]
mDepth | vl::Image | [protected]
mFormat | vl::Image | [protected]
mHeight | vl::Image | [protected]
mipmaps() const | vl::Image | [inline]
mIsCubemap | vl::Image | [protected]
mMipmaps | vl::Image | [protected]
mName | vl::Object | [protected]
mPitch | vl::Image | [protected]
mPixels | vl::Image | [protected]
mTags | vl::Image | [protected]
mType | vl::Image | [protected]
mWidth | vl::Image | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Image &other) | vl::Image |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
pitch() const | vl::Image | [inline]
pixels() const | vl::Image | [inline]
pixels() | vl::Image | [inline]
pixelsXN() | vl::Image |
pixelsXP() | vl::Image |
pixelsYN() | vl::Image |
pixelsYP() | vl::Image |
pixelsZN() | vl::Image |
pixelsZP() | vl::Image |
pixelsZSlice(int slice) | vl::Image |
print() const | vl::Image |
printFormat() const | vl::Image |
printType() const | vl::Image |
readPixels(int x, int y, int width, int height, EReadDrawBuffer read_buffer, bool store_in_pixel_buffer_object) | vl::Image |
referenceCount() const | vl::Object | [inline]
requiredMemory() const | vl::Image |
requiredMemory(int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap) | vl::Image | [static]
requiredMemory1D(int x, EImageFormat format, EImageType type) | vl::Image | [inline, static]
requiredMemory2D(int x, int y, int bytealign, EImageFormat format, EImageType type) | vl::Image | [inline, static]
requiredMemory3D(int x, int y, int z, int bytealign, EImageFormat format, EImageType type) | vl::Image | [inline, static]
requiredMemoryCubemap(int x, int y, int bytealign, EImageFormat format, EImageType type) | vl::Image | [inline, static]
reset(int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap) | vl::Image |
sample(int x, int y=0, int z=0) | vl::Image |
sampleLinear(double x) | vl::Image |
sampleLinear(double x, double y) | vl::Image |
sampleLinear(double x, double y, double z) | vl::Image |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setByteAlignment(int bytealign) | vl::Image |
setDepth(int z) | vl::Image | [inline]
setFormat(EImageFormat format) | vl::Image | [inline]
setHeight(int y) | vl::Image | [inline]
setImageBuffer(GLBufferObject *gpu_buffer) | vl::Image | [inline]
setMipmaps(const std::vector< ref< Image > > &mipmaps) | vl::Image | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTags(KeyValues *tags) | vl::Image | [inline]
setType(EImageType type) | vl::Image | [inline]
setWidth(int x) | vl::Image | [inline]
subImage(int xstart, int ystart, int width, int height) | vl::Image |
substituteColorGreenKey(unsigned int col0, unsigned int col1) | vl::Image |
substituteColorRGB_RGB(unsigned int before, unsigned int after) | vl::Image |
substituteColorRGB_RGBA(unsigned int before, unsigned int after) | vl::Image |
tags() const | vl::Image | [inline]
type() const | vl::Image | [inline]
updatePitch() | vl::Image | [protected]
width() const | vl::Image | [inline]
~Image() | vl::Image | [virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::Interpolator Member List

This is the complete list of members for vl::Interpolator, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorDVec2 Member List

This is the complete list of members for vl::InterpolatorDVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorDVec2 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorDVec3 Member List

This is the complete list of members for vl::InterpolatorDVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorDVec3 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorDVec4 Member List

This is the complete list of members for vl::InterpolatorDVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorDVec4 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorDouble Member List

This is the complete list of members for vl::InterpolatorDouble, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorDouble | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorFVec2 Member List

This is the complete list of members for vl::InterpolatorFVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorFVec2 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorFVec3 Member List

This is the complete list of members for vl::InterpolatorFVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorFVec3 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorFVec4 Member List

This is the complete list of members for vl::InterpolatorFVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorFVec4 | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::InterpolatorFloat Member List

This is the complete list of members for vl::InterpolatorFloat, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const =0 | vl::InterpolatorFloat | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
Interpolator() | vl::Interpolator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::KeyValues Member List

This is the complete list of members for vl::KeyValues, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
clear() | vl::KeyValues | [inline]
decReference() | vl::Object | [inline]
erase(const String &key) | vl::KeyValues | [inline]
getKeys(std::vector< String > &keys) const | vl::KeyValues |
has(const String &key) const | vl::KeyValues | [inline]
incReference() | vl::Object | [inline]
keyValueMap() const | vl::KeyValues | [inline]
keyValueMap() | vl::KeyValues | [inline]
mKeyValues | vl::KeyValues | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
print() | vl::KeyValues |
referenceCount() const | vl::Object | [inline]
set(const String &key) | vl::KeyValues | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
value(const String &key) const | vl::KeyValues |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LODEvaluator Member List

This is the complete list of members for vl::LODEvaluator, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::LODEvaluator | [inline, virtual]
decReference() | vl::Object | [inline]
evaluate(Actor *actor, Camera *camera)=0 | vl::LODEvaluator | [pure virtual]
incReference() | vl::Object | [inline]
LODEvaluator() | vl::LODEvaluator | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::Light Member List

This is the complete list of members for vl::Light, including all inherited members.

ambient() const | vl::Light | [inline]
apply(const Camera *) const | vl::Light | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Light | [inline, virtual]
constantAttenuation() const | vl::Light | [inline]
decReference() | vl::Object | [inline]
diffuse() const | vl::Light | [inline]
disable() const | vl::Light | [inline, virtual]
enable() const | vl::Light | [inline, virtual]
followedTransform() | vl::Light |
followedTransform() const | vl::Light |
followTransform(Transform *transform) | vl::Light |
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
Light(int light_index) | vl::Light |
lightIndex() const | vl::Light | [inline]
linearAttenuation() const | vl::Light | [inline]
mAmbient | vl::Light | [protected]
mConstantAttenuation | vl::Light | [protected]
mDiffuse | vl::Light | [protected]
mFollowedTransform | vl::Light | [protected]
mLightIndex | vl::Light | [protected]
mLinearAttenuation | vl::Light | [protected]
mName | vl::Object | [protected]
mPosition | vl::Light | [protected]
mQuadraticAttenuation | vl::Light | [protected]
mSpecular | vl::Light | [protected]
mSpotCutoff | vl::Light | [protected]
mSpotDirection | vl::Light | [protected]
mSpotExponent | vl::Light | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vl::Light | [inline]
quadraticAttenuation() const | vl::Light | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAmbient(const fvec4 &ambientcolor) | vl::Light | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setConstantAttenuation(float constantattenuation) | vl::Light | [inline]
setDiffuse(const fvec4 &diffusecolor) | vl::Light | [inline]
setLightIndex(int light_index) | vl::Light |
setLinearAttenuation(float linearattenuation) | vl::Light | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPosition(const fvec4 &position) | vl::Light | [inline]
setQuadraticAttenuation(float quadraticattenuation) | vl::Light | [inline]
setSpecular(const fvec4 &specularcolor) | vl::Light | [inline]
setSpotCutoff(float spotcutoff) | vl::Light | [inline]
setSpotDirection(const fvec3 &spotdirection) | vl::Light | [inline]
setSpotExponent(float spotexponent) | vl::Light | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
specular() const | vl::Light | [inline]
spotCutoff() const | vl::Light | [inline]
spotDirection() const | vl::Light | [inline]
spotExponent() const | vl::Light | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::Light | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LightModel Member List

This is the complete list of members for vl::LightModel, including all inherited members.

ambientColor() const | vl::LightModel | [inline]
apply(const Camera *) const | vl::LightModel | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::LightModel | [inline, virtual]
colorControl() const | vl::LightModel | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
LightModel() | vl::LightModel | [inline]
localViewer() const | vl::LightModel | [inline]
mAmbientColor | vl::LightModel | [protected]
mColorControl | vl::LightModel | [protected]
mLocalViewer | vl::LightModel | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
mTwoSide | vl::LightModel | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAmbientColor(fvec4 ambientcolor) | vl::LightModel | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setColorControl(EColorControl colorcontrol) | vl::LightModel | [inline]
setLocalViewer(bool localviewer) | vl::LightModel | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTwoSide(bool twoside) | vl::LightModel | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
twoSide() const | vl::LightModel | [inline]
type() const | vl::LightModel | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::LineStipple Member List

This is the complete list of members for vl::LineStipple, including all inherited members.

apply(const Camera *) const | vl::LineStipple | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::LineStipple | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
factor() const | vl::LineStipple | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
LineStipple(int factor=1, GLushort pattern=~(GLushort) 0) | vl::LineStipple | [inline]
mFactor | vl::LineStipple | [protected]
mName | vl::Object | [protected]
mPattern | vl::LineStipple | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pattern() const | vl::LineStipple | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(int factor, GLushort pattern) | vl::LineStipple | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFactor(int factor) | vl::LineStipple | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPattern(GLushort pattern) | vl::LineStipple | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::LineStipple | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::LineWidth Member List

This is the complete list of members for vl::LineWidth, including all inherited members.

apply(const Camera *) const | vl::LineWidth | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::LineWidth | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
LineWidth(float linewidth=1.0f) | vl::LineWidth | [inline]
lineWidth() const | vl::LineWidth | [inline]
mLineWidth | vl::LineWidth | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(float linewidth) | vl::LineWidth | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::LineWidth | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::LinearInterpolator< T > Member List

This is the complete list of members for vl::LinearInterpolator< T >, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolator< T > | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
LinearInterpolator() | vl::LinearInterpolator< T > | [inline]
LinearInterpolator(const std::vector< T > &path) | vl::LinearInterpolator< T > | [inline]
mLinearSpline | vl::LinearInterpolator< T > | [protected]
mName | vl::Object | [protected]
mPath | vl::LinearInterpolator< T > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::LinearInterpolator< T > | [inline]
path() | vl::LinearInterpolator< T > | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const std::vector< T > &path) | vl::LinearInterpolator< T > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorDVec2 Member List

This is the complete list of members for vl::LinearInterpolatorDVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorDVec2 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorDVec2 | [inline]
interpolator() const | vl::LinearInterpolatorDVec2 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorDVec2() | vl::LinearInterpolatorDVec2 | [inline]
LinearInterpolatorDVec2(const std::vector< vl::dvec2 > &path) | vl::LinearInterpolatorDVec2 | [inline]
mInterpolator | vl::LinearInterpolatorDVec2 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorDVec2_T *interpolator) | vl::LinearInterpolatorDVec2 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorDVec3 Member List

This is the complete list of members for vl::LinearInterpolatorDVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorDVec3 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorDVec3 | [inline]
interpolator() const | vl::LinearInterpolatorDVec3 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorDVec3() | vl::LinearInterpolatorDVec3 | [inline]
LinearInterpolatorDVec3(const std::vector< vl::dvec3 > &path) | vl::LinearInterpolatorDVec3 | [inline]
mInterpolator | vl::LinearInterpolatorDVec3 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorDVec3_T *interpolator) | vl::LinearInterpolatorDVec3 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorDVec4 Member List

This is the complete list of members for vl::LinearInterpolatorDVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorDVec4 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorDVec4 | [inline]
interpolator() const | vl::LinearInterpolatorDVec4 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorDVec4() | vl::LinearInterpolatorDVec4 | [inline]
LinearInterpolatorDVec4(const std::vector< vl::dvec4 > &path) | vl::LinearInterpolatorDVec4 | [inline]
mInterpolator | vl::LinearInterpolatorDVec4 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorDVec4_T *interpolator) | vl::LinearInterpolatorDVec4 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorDouble Member List

This is the complete list of members for vl::LinearInterpolatorDouble, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorDouble | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorDouble | [inline]
interpolator() const | vl::LinearInterpolatorDouble | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorDouble() | vl::LinearInterpolatorDouble | [inline]
LinearInterpolatorDouble(const std::vector< double > &path) | vl::LinearInterpolatorDouble | [inline]
mInterpolator | vl::LinearInterpolatorDouble | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorDouble_T *interpolator) | vl::LinearInterpolatorDouble | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorFVec2 Member List

This is the complete list of members for vl::LinearInterpolatorFVec2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorFVec2 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorFVec2 | [inline]
interpolator() const | vl::LinearInterpolatorFVec2 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorFVec2() | vl::LinearInterpolatorFVec2 | [inline]
LinearInterpolatorFVec2(const std::vector< vl::fvec2 > &path) | vl::LinearInterpolatorFVec2 | [inline]
mInterpolator | vl::LinearInterpolatorFVec2 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorFVec2_T *interpolator) | vl::LinearInterpolatorFVec2 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorFVec3 Member List

This is the complete list of members for vl::LinearInterpolatorFVec3, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorFVec3 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorFVec3 | [inline]
interpolator() const | vl::LinearInterpolatorFVec3 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorFVec3() | vl::LinearInterpolatorFVec3 | [inline]
LinearInterpolatorFVec3(const std::vector< vl::fvec3 > &path) | vl::LinearInterpolatorFVec3 | [inline]
mInterpolator | vl::LinearInterpolatorFVec3 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorFVec3_T *interpolator) | vl::LinearInterpolatorFVec3 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorFVec4 Member List

This is the complete list of members for vl::LinearInterpolatorFVec4, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorFVec4 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorFVec4 | [inline]
interpolator() const | vl::LinearInterpolatorFVec4 | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorFVec4() | vl::LinearInterpolatorFVec4 | [inline]
LinearInterpolatorFVec4(const std::vector< vl::fvec4 > &path) | vl::LinearInterpolatorFVec4 | [inline]
mInterpolator | vl::LinearInterpolatorFVec4 | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorFVec4_T *interpolator) | vl::LinearInterpolatorFVec4 | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LinearInterpolatorFloat Member List

This is the complete list of members for vl::LinearInterpolatorFloat, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computePoint(float t) const | vl::LinearInterpolatorFloat | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
interpolator() | vl::LinearInterpolatorFloat | [inline]
interpolator() const | vl::LinearInterpolatorFloat | [inline]
Interpolator() | vl::Interpolator | [inline]
LinearInterpolatorFloat() | vl::LinearInterpolatorFloat | [inline]
LinearInterpolatorFloat(const std::vector< float > &path) | vl::LinearInterpolatorFloat | [inline]
mInterpolator | vl::LinearInterpolatorFloat | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInterpolator(LinearInterpolatorFloat_T *interpolator) | vl::LinearInterpolatorFloat | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LoadCallback Member List

This is the complete list of members for vl::LoadCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(ResourceDatabase *db)=0 | vl::LoadCallback | [pure virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LoadWriter3DS Member List

This is the complete list of members for vl::LoadWriter3DS, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriter3DS | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriter3DS | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriter3DS | [inline, virtual]
LoadWriter3DS() | vl::LoadWriter3DS | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriter3DS | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriter3DS | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterAC3D Member List

This is the complete list of members for vl::LoadWriterAC3D, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterAC3D | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterAC3D | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterAC3D | [inline, virtual]
LoadWriterAC3D() | vl::LoadWriterAC3D | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterAC3D | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterAC3D | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterBMP Member List

This is the complete list of members for vl::LoadWriterBMP, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterBMP | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterBMP | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterBMP | [inline, virtual]
LoadWriterBMP() | vl::LoadWriterBMP | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterBMP | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterBMP | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterDAT Member List

This is the complete list of members for vl::LoadWriterDAT, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterDAT | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterDAT | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterDAT | [inline, virtual]
LoadWriterDAT() | vl::LoadWriterDAT | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterDAT | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterDAT | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterDDS Member List

This is the complete list of members for vl::LoadWriterDDS, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterDDS | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterDDS | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterDDS | [inline, virtual]
LoadWriterDDS() | vl::LoadWriterDDS | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterDDS | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterDDS | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterDICOM Member List

This is the complete list of members for vl::LoadWriterDICOM, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterDICOM | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterDICOM | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterDICOM | [inline, virtual]
LoadWriterDICOM() | vl::LoadWriterDICOM | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterDICOM | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterDICOM | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterJPG Member List

This is the complete list of members for vl::LoadWriterJPG, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterJPG | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterJPG | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterJPG | [inline, virtual]
LoadWriterJPG() | vl::LoadWriterJPG | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mQuality | vl::LoadWriterJPG | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
quality() const | vl::LoadWriterJPG | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setQuality(int quality) | vl::LoadWriterJPG | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &path, ResourceDatabase *resource) const | vl::LoadWriterJPG | [inline, virtual]
writeResource(VirtualFile *file, ResourceDatabase *resource) const | vl::LoadWriterJPG | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterMD2 Member List

This is the complete list of members for vl::LoadWriterMD2, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterMD2 | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterMD2 | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterMD2 | [inline, virtual]
LoadWriterMD2() | vl::LoadWriterMD2 | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterMD2 | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterMD2 | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterManager Member List

This is the complete list of members for vl::LoadWriterManager, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &path) const | vl::LoadWriterManager | [inline]
canLoad(VirtualFile *file) const | vl::LoadWriterManager | [inline]
canWrite(const String &path) const | vl::LoadWriterManager | [inline]
canWrite(VirtualFile *file) const | vl::LoadWriterManager | [inline]
className() | vl::LoadWriterManager | [inline, virtual]
decReference() | vl::Object | [inline]
findLoader(const String &path) const | vl::LoadWriterManager |
findLoader(VirtualFile *file) const | vl::LoadWriterManager |
findWriter(const String &path) const | vl::LoadWriterManager |
findWriter(VirtualFile *file) const | vl::LoadWriterManager |
incReference() | vl::Object | [inline]
loadCallbacks() const | vl::LoadWriterManager | [inline]
loadCallbacks() | vl::LoadWriterManager | [inline]
loadResource(const String &path, bool quick=true) const | vl::LoadWriterManager |
loadResource(VirtualFile *file, bool quick=true) const | vl::LoadWriterManager |
loadWriter() | vl::LoadWriterManager | [inline]
LoadWriterManager() | vl::LoadWriterManager | [inline]
LoadWriterManager(const LoadWriterManager &other) | vl::LoadWriterManager | [inline]
loadWriters() | vl::LoadWriterManager | [inline]
loadWriters() const | vl::LoadWriterManager | [inline]
mLoadCallbacks | vl::LoadWriterManager | [protected]
mLoadWriters | vl::LoadWriterManager | [protected]
mName | vl::Object | [protected]
mWriteCallbacks | vl::LoadWriterManager | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
registerLoadWriter(ResourceLoadWriter *) | vl::LoadWriterManager |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
writeCallbacks() const | vl::LoadWriterManager | [inline]
writeCallbacks() | vl::LoadWriterManager | [inline]
writeResource(const String &path, ResourceDatabase *resource) const | vl::LoadWriterManager |
writeResource(VirtualFile *file, ResourceDatabase *resource) const | vl::LoadWriterManager |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LoadWriterOBJ Member List

This is the complete list of members for vl::LoadWriterOBJ, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterOBJ | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterOBJ | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterOBJ | [inline, virtual]
LoadWriterOBJ() | vl::LoadWriterOBJ | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
registerLoadWriter() | vl::LoadWriterOBJ |
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterOBJ | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterOBJ | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::LoadWriterPLY Member List

This is the complete list of members for vl::LoadWriterPLY, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterPLY | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterPLY | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterPLY | [inline, virtual]
LoadWriterPLY() | vl::LoadWriterPLY | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterPLY | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterPLY | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::LoadWriterPNG Member List

This is the complete list of members for vl::LoadWriterPNG, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterPNG | [inline, virtual]
compression() const | vl::LoadWriterPNG | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterPNG | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterPNG | [inline, virtual]
LoadWriterPNG() | vl::LoadWriterPNG | [inline]
mCompression | vl::LoadWriterPNG | [protected]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCompression(int compression) | vl::LoadWriterPNG | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &path, ResourceDatabase *resource) const | vl::LoadWriterPNG | [inline, virtual]
writeResource(VirtualFile *file, ResourceDatabase *resource) const | vl::LoadWriterPNG | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::LoadWriterSTL Member List

This is the complete list of members for vl::LoadWriterSTL, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterSTL | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterSTL | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterSTL | [inline, virtual]
LoadWriterSTL() | vl::LoadWriterSTL | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &, ResourceDatabase *) const | vl::LoadWriterSTL | [inline, virtual]
writeResource(VirtualFile *, ResourceDatabase *) const | vl::LoadWriterSTL | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::LoadWriterTGA Member List

This is the complete list of members for vl::LoadWriterTGA, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterTGA | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterTGA | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterTGA | [inline, virtual]
LoadWriterTGA() | vl::LoadWriterTGA | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &path, ResourceDatabase *resource) const | vl::LoadWriterTGA | [inline, virtual]
writeResource(VirtualFile *file, ResourceDatabase *resource) const | vl::LoadWriterTGA | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::LoadWriterTIFF Member List

This is the complete list of members for vl::LoadWriterTIFF, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::LoadWriterTIFF | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const | vl::LoadWriterTIFF | [inline, virtual]
loadResource(VirtualFile *file) const | vl::LoadWriterTIFF | [inline, virtual]
LoadWriterTIFF() | vl::LoadWriterTIFF | [inline]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &path, ResourceDatabase *resource) const | vl::LoadWriterTIFF | [inline, virtual]
writeResource(VirtualFile *file, ResourceDatabase *resource) const | vl::LoadWriterTIFF | [inline, virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::Log Member List

This is the complete list of members for vl::Log, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bug(const String &log) | vl::Log | [static]
className() | vl::Log | [inline, virtual]
debug(const String &log) | vl::Log | [static]
decReference() | vl::Object | [inline]
error(const String &log) | vl::Log | [static]
incReference() | vl::Object | [inline]
info(const String &log) | vl::Log | [static]
Log() | vl::Log | [inline]
logger() | vl::Log | [inline, static]
mLogger | vl::Log | [protected, static]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
print(ELogLevel level, const String &log) | vl::Log | [static]
print(const String &log) | vl::Log | [static]
printImplementation(ELogLevel level, const String &log)=0 | vl::Log | [protected, pure virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLogger(Log *logger) | vl::Log | [inline, static]
setName(const std::string &name) | vl::Object | [inline]
warning(const String &log) | vl::Log | [static]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::LogicOp Member List

This is the complete list of members for vl::LogicOp, including all inherited members.

apply(const Camera *) const | vl::LogicOp | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::LogicOp | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
LogicOp(ELogicOp logicop=LO_COPY) | vl::LogicOp | [inline]
logicOp() const | vl::LogicOp | [inline]
mLogicOp | vl::LogicOp | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(ELogicOp logicop) | vl::LogicOp | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::LogicOp | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::MD5CheckSum Member List

This is the complete list of members for vl::MD5CheckSum, including all inherited members.

className() | vl::MD5CheckSum | [inline, virtual]
compute(void *buffer, int len) | vl::MD5CheckSum |
compute(VirtualFile *file) | vl::MD5CheckSum |
md5() const | vl::MD5CheckSum | [inline]
MD5CheckSum() | vl::MD5CheckSum | [inline]
mMD5 | vl::MD5CheckSum | [protected]
operator!=(const MD5CheckSum &other) const | vl::MD5CheckSum | [inline]
operator<(const MD5CheckSum &other) const | vl::MD5CheckSum | [inline]
operator==(const MD5CheckSum &other) const | vl::MD5CheckSum | [inline]
toStdString() const | vl::MD5CheckSum |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::Material Member List

This is the complete list of members for vl::Material, including all inherited members.

apply(const Camera *) const | vl::Material | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
backAmbient() const | vl::Material | [inline]
backDiffuse() const | vl::Material | [inline]
backEmission() const | vl::Material | [inline]
backShininess() const | vl::Material | [inline]
backSpecular() const | vl::Material | [inline]
className() | vl::Material | [inline, virtual]
colorMaterial() const | vl::Material | [inline]
colorMaterialEnabled() const | vl::Material | [inline]
colorMaterialFace() const | vl::Material | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
frontAmbient() const | vl::Material | [inline]
frontDiffuse() const | vl::Material | [inline]
frontEmission() const | vl::Material | [inline]
frontShininess() const | vl::Material | [inline]
frontSpecular() const | vl::Material | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
Material() | vl::Material |
mBackAmbient | vl::Material | [protected]
mBackDiffuse | vl::Material | [protected]
mBackEmission | vl::Material | [protected]
mBackShininess | vl::Material | [protected]
mBackSpecular | vl::Material | [protected]
mColorMaterial | vl::Material | [protected]
mColorMaterialEnabled | vl::Material | [protected]
mColorMaterialFace | vl::Material | [protected]
mFrontAmbient | vl::Material | [protected]
mFrontDiffuse | vl::Material | [protected]
mFrontEmission | vl::Material | [protected]
mFrontShininess | vl::Material | [protected]
mFrontSpecular | vl::Material | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAmbient(fvec4 color) | vl::Material | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBackAmbient(fvec4 color) | vl::Material | [inline]
setBackDiffuse(fvec4 color) | vl::Material | [inline]
setBackEmission(fvec4 color) | vl::Material | [inline]
setBackFlatColor(const fvec4 &color) | vl::Material |
setBackShininess(float shininess) | vl::Material | [inline]
setBackSpecular(fvec4 color) | vl::Material | [inline]
setBackTransparency(float alpha) | vl::Material |
setColorMaterial(EPolygonFace face, EColorMaterial color) | vl::Material | [inline]
setColorMaterialEnabled(bool enabled) | vl::Material | [inline]
setDiffuse(fvec4 color) | vl::Material | [inline]
setEmission(fvec4 color) | vl::Material | [inline]
setFlatColor(const fvec4 &color) | vl::Material |
setFrontAmbient(fvec4 color) | vl::Material | [inline]
setFrontDiffuse(fvec4 color) | vl::Material | [inline]
setFrontEmission(fvec4 color) | vl::Material | [inline]
setFrontFlatColor(const fvec4 &color) | vl::Material |
setFrontShininess(float shininess) | vl::Material | [inline]
setFrontSpecular(fvec4 color) | vl::Material | [inline]
setFrontTransparency(float alpha) | vl::Material |
setName(const std::string &name) | vl::Object | [inline]
setShininess(float shininess) | vl::Material | [inline]
setSpecular(fvec4 color) | vl::Material | [inline]
setTransparency(float alpha) | vl::Material |
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::Material | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Matrix2< scalar_type > Member List

This is the complete list of members for vl::Matrix2< scalar_type >, including all inherited members.

e(int i, int j) const | vl::Matrix2< scalar_type > | [inline]
e(int i, int j) | vl::Matrix2< scalar_type > | [inline]
inverse(bool *invertible=NULL) const | vl::Matrix2< scalar_type > | [inline]
invert(bool *invertible=NULL) | vl::Matrix2< scalar_type > | [inline]
isIdentity() const | vl::Matrix2< scalar_type > | [inline]
isNull() const | vl::Matrix2< scalar_type > | [inline]
Matrix2(const T &m) | vl::Matrix2< scalar_type > | [inline, explicit]
Matrix2() | vl::Matrix2< scalar_type > | [inline]
Matrix2(scalar_type n) | vl::Matrix2< scalar_type > | [inline]
Matrix2(scalar_type e00, scalar_type e01, scalar_type e10, scalar_type e11) | vl::Matrix2< scalar_type > | [inline, explicit]
mVec | vl::Matrix2< scalar_type > | [protected]
operator!=(const Matrix2 &m) const | vl::Matrix2< scalar_type > | [inline]
operator*(scalar_type d) const | vl::Matrix2< scalar_type > | [inline]
operator*=(const Matrix2 &m) | vl::Matrix2< scalar_type > | [inline]
operator*=(scalar_type d) | vl::Matrix2< scalar_type > | [inline]
operator+(const Matrix2 &m) const | vl::Matrix2< scalar_type > | [inline]
operator+(scalar_type d) const | vl::Matrix2< scalar_type > | [inline]
operator+=(const Matrix2 &m) | vl::Matrix2< scalar_type > | [inline]
operator+=(scalar_type d) | vl::Matrix2< scalar_type > | [inline]
operator-(const Matrix2 &m) const | vl::Matrix2< scalar_type > | [inline]
operator-() const | vl::Matrix2< scalar_type > | [inline]
operator-(scalar_type d) const | vl::Matrix2< scalar_type > | [inline]
operator-=(const Matrix2 &m) | vl::Matrix2< scalar_type > | [inline]
operator-=(scalar_type d) | vl::Matrix2< scalar_type > | [inline]
operator/(scalar_type d) const | vl::Matrix2< scalar_type > | [inline]
operator/=(scalar_type d) | vl::Matrix2< scalar_type > | [inline]
operator=(const Matrix2 &m) | vl::Matrix2< scalar_type > | [inline]
operator==(const Matrix2 &m) const | vl::Matrix2< scalar_type > | [inline]
operator[](unsigned int i) const | vl::Matrix2< scalar_type > | [inline]
operator[](unsigned int i) | vl::Matrix2< scalar_type > | [inline]
ptr() | vl::Matrix2< scalar_type > | [inline]
ptr() const | vl::Matrix2< scalar_type > | [inline]
setIdentity() | vl::Matrix2< scalar_type > | [inline]
transpose() | vl::Matrix2< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::Matrix3< scalar_type > Member List

This is the complete list of members for vl::Matrix3< scalar_type >, including all inherited members.

e(int i, int j) const | vl::Matrix3< scalar_type > | [inline]
e(int i, int j) | vl::Matrix3< scalar_type > | [inline]
get2x2() const | vl::Matrix3< scalar_type > | [inline]
getT() const | vl::Matrix3< scalar_type > | [inline]
getX() const | vl::Matrix3< scalar_type > | [inline]
getY() const | vl::Matrix3< scalar_type > | [inline]
inverse(bool *invertible=NULL) const | vl::Matrix3< scalar_type > | [inline]
invert(bool *invertible=NULL) | vl::Matrix3< scalar_type > | [inline]
isIdentity() const | vl::Matrix3< scalar_type > | [inline]
isNull() const | vl::Matrix3< scalar_type > | [inline]
Matrix3(const T &m) | vl::Matrix3< scalar_type > | [inline, explicit]
Matrix3() | vl::Matrix3< scalar_type > | [inline]
Matrix3(scalar_type n) | vl::Matrix3< scalar_type > | [inline]
Matrix3(scalar_type e00, scalar_type e01, scalar_type e02, scalar_type e10, scalar_type e11, scalar_type e12, scalar_type e20, scalar_type e21, scalar_type e22) | vl::Matrix3< scalar_type > | [inline, explicit]
mVec | vl::Matrix3< scalar_type > | [protected]
operator!=(const Matrix3 &m) const | vl::Matrix3< scalar_type > | [inline]
operator*(scalar_type d) const | vl::Matrix3< scalar_type > | [inline]
operator*=(const Matrix3 &m) | vl::Matrix3< scalar_type > | [inline]
operator*=(scalar_type d) | vl::Matrix3< scalar_type > | [inline]
operator+(const Matrix3 &m) const | vl::Matrix3< scalar_type > | [inline]
operator+(scalar_type d) const | vl::Matrix3< scalar_type > | [inline]
operator+=(const Matrix3 &m) | vl::Matrix3< scalar_type > | [inline]
operator+=(scalar_type d) | vl::Matrix3< scalar_type > | [inline]
operator-(const Matrix3 &m) const | vl::Matrix3< scalar_type > | [inline]
operator-() const | vl::Matrix3< scalar_type > | [inline]
operator-(scalar_type d) const | vl::Matrix3< scalar_type > | [inline]
operator-=(const Matrix3 &m) | vl::Matrix3< scalar_type > | [inline]
operator-=(scalar_type d) | vl::Matrix3< scalar_type > | [inline]
operator/(scalar_type d) const | vl::Matrix3< scalar_type > | [inline]
operator/=(scalar_type d) | vl::Matrix3< scalar_type > | [inline]
operator=(const Matrix3 &m) | vl::Matrix3< scalar_type > | [inline]
operator==(const Matrix3 &m) const | vl::Matrix3< scalar_type > | [inline]
operator[](unsigned int i) const | vl::Matrix3< scalar_type > | [inline]
operator[](unsigned int i) | vl::Matrix3< scalar_type > | [inline]
ptr() | vl::Matrix3< scalar_type > | [inline]
ptr() const | vl::Matrix3< scalar_type > | [inline]
rotate(scalar_type degrees) | vl::Matrix3< scalar_type > | [inline]
rotation(scalar_type degrees) | vl::Matrix3< scalar_type > | [inline, static]
scale(scalar_type x, scalar_type y) | vl::Matrix3< scalar_type > | [inline]
scaling(scalar_type x, scalar_type y) | vl::Matrix3< scalar_type > | [inline, static]
set2x2(const Matrix2< scalar_type > &m) | vl::Matrix3< scalar_type > | [inline]
setIdentity() | vl::Matrix3< scalar_type > | [inline]
setT(const Vector2< scalar_type > &v) | vl::Matrix3< scalar_type > | [inline]
setX(const Vector2< scalar_type > &v) | vl::Matrix3< scalar_type > | [inline]
setY(const Vector2< scalar_type > &v) | vl::Matrix3< scalar_type > | [inline]
translate(scalar_type x, scalar_type y) | vl::Matrix3< scalar_type > | [inline]
translate(const Vector2< scalar_type > &v) | vl::Matrix3< scalar_type > | [inline]
translation(const Vector2< scalar_type > &v) | vl::Matrix3< scalar_type > | [inline, static]
translation(scalar_type x, scalar_type y) | vl::Matrix3< scalar_type > | [inline, static]
transpose() | vl::Matrix3< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::Matrix4< scalar_type > Member List

This is the complete list of members for vl::Matrix4< scalar_type >, including all inherited members.

as3x3() const | vl::Matrix4< scalar_type > | [inline]
e(unsigned i, unsigned j) const | vl::Matrix4< scalar_type > | [inline]
e(unsigned i, unsigned j) | vl::Matrix4< scalar_type > | [inline]
e(int i, int j) const | vl::Matrix4< scalar_type > | [inline]
e(int i, int j) | vl::Matrix4< scalar_type > | [inline]
frustum(scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop, scalar_type pnear, scalar_type pfar) | vl::Matrix4< scalar_type > | [inline, static]
get3x3() const | vl::Matrix4< scalar_type > | [inline]
getAsLookAt(Vector3< scalar_type > &eye, Vector3< scalar_type > &look, Vector3< scalar_type > &up, Vector3< scalar_type > &right) const | vl::Matrix4< scalar_type > | [inline]
getT() const | vl::Matrix4< scalar_type > | [inline]
getX() const | vl::Matrix4< scalar_type > | [inline]
getY() const | vl::Matrix4< scalar_type > | [inline]
getYXRotationAngles(scalar_type &degrees_y, scalar_type &degrees_x) const | vl::Matrix4< scalar_type > | [inline]
getZ() const | vl::Matrix4< scalar_type > | [inline]
inverse(bool *invertible=NULL) const | vl::Matrix4< scalar_type > | [inline]
invert(bool *invertible=NULL) | vl::Matrix4< scalar_type > | [inline]
isIdentity() const | vl::Matrix4< scalar_type > | [inline]
isNull() const | vl::Matrix4< scalar_type > | [inline]
lookAt(const Vector3< scalar_type > &eye, const Vector3< scalar_type > &look, const Vector3< scalar_type > &up) | vl::Matrix4< scalar_type > | [inline, static]
Matrix4(const T &m) | vl::Matrix4< scalar_type > | [inline, explicit]
Matrix4() | vl::Matrix4< scalar_type > | [inline]
Matrix4(scalar_type n) | vl::Matrix4< scalar_type > | [inline]
Matrix4(scalar_type e00, scalar_type e01, scalar_type e02, scalar_type e03, scalar_type e10, scalar_type e11, scalar_type e12, scalar_type e13, scalar_type e20, scalar_type e21, scalar_type e22, scalar_type e23, scalar_type e30, scalar_type e31, scalar_type e32, scalar_type e33) | vl::Matrix4< scalar_type > | [inline, explicit]
mVec | vl::Matrix4< scalar_type > | [protected]
operator!=(const Matrix4 &m) const | vl::Matrix4< scalar_type > | [inline]
operator*(scalar_type d) const | vl::Matrix4< scalar_type > | [inline]
operator*=(const Matrix4 &m) | vl::Matrix4< scalar_type > | [inline]
operator*=(scalar_type d) | vl::Matrix4< scalar_type > | [inline]
operator+(const Matrix4 &m) const | vl::Matrix4< scalar_type > | [inline]
operator+(scalar_type d) const | vl::Matrix4< scalar_type > | [inline]
operator+=(const Matrix4 &m) | vl::Matrix4< scalar_type > | [inline]
operator+=(scalar_type d) | vl::Matrix4< scalar_type > | [inline]
operator-(const Matrix4 &m) const | vl::Matrix4< scalar_type > | [inline]
operator-() const | vl::Matrix4< scalar_type > | [inline]
operator-(scalar_type d) const | vl::Matrix4< scalar_type > | [inline]
operator-=(const Matrix4 &m) | vl::Matrix4< scalar_type > | [inline]
operator-=(scalar_type d) | vl::Matrix4< scalar_type > | [inline]
operator/(scalar_type d) const | vl::Matrix4< scalar_type > | [inline]
operator/=(scalar_type d) | vl::Matrix4< scalar_type > | [inline]
operator=(const Matrix4 &m) | vl::Matrix4< scalar_type > | [inline]
operator==(const Matrix4 &m) const | vl::Matrix4< scalar_type > | [inline]
operator[](unsigned int i) const | vl::Matrix4< scalar_type > | [inline]
operator[](unsigned int i) | vl::Matrix4< scalar_type > | [inline]
ortho(scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop, scalar_type pnear, scalar_type pfar) | vl::Matrix4< scalar_type > | [inline, static]
ortho2D(scalar_type pleft, scalar_type pright, scalar_type pbottom, scalar_type ptop) | vl::Matrix4< scalar_type > | [inline, static]
perspective(scalar_type fovy, scalar_type aspect_ratio, scalar_type znear, scalar_type zfar) | vl::Matrix4< scalar_type > | [inline, static]
ptr() | vl::Matrix4< scalar_type > | [inline]
ptr() const | vl::Matrix4< scalar_type > | [inline]
rotate(scalar_type degrees, const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
rotate(scalar_type degrees, scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline]
rotate(scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2) | vl::Matrix4< scalar_type > | [inline]
rotate(scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2, scalar_type degrees3, const Vector3< scalar_type > &v3) | vl::Matrix4< scalar_type > | [inline]
rotate(const Vector4< scalar_type > &from, const Vector4< scalar_type > &to) | vl::Matrix4< scalar_type > | [inline]
rotate(const Vector3< scalar_type > &from, const Vector3< scalar_type > &to) | vl::Matrix4< scalar_type > | [inline]
rotateXYZ(scalar_type degX, scalar_type degY, scalar_type degZ) | vl::Matrix4< scalar_type > | [inline]
rotateZYX(scalar_type degZ, scalar_type degY, scalar_type degX) | vl::Matrix4< scalar_type > | [inline]
rotation(scalar_type degrees, scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline, static]
rotation(scalar_type degrees, const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline, static]
rotation(scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2) | vl::Matrix4< scalar_type > | [inline, static]
rotation(scalar_type degrees1, const Vector3< scalar_type > &v1, scalar_type degrees2, const Vector3< scalar_type > &v2, scalar_type degrees3, const Vector3< scalar_type > &v3) | vl::Matrix4< scalar_type > | [inline, static]
rotation(const Vector4< scalar_type > &from, const Vector4< scalar_type > &to) | vl::Matrix4< scalar_type > | [inline, static]
rotation(const Vector3< scalar_type > &from, const Vector3< scalar_type > &to) | vl::Matrix4< scalar_type > | [inline, static]
rotationXYZ(scalar_type degX, scalar_type degY, scalar_type degZ) | vl::Matrix4< scalar_type > | [inline, static]
rotationZYX(scalar_type degZ, scalar_type degY, scalar_type degX) | vl::Matrix4< scalar_type > | [inline, static]
scale(scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline]
scaling(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline, static]
scaling(scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline, static]
set3x3(const Matrix3< scalar_type > &m) | vl::Matrix4< scalar_type > | [inline]
setIdentity() | vl::Matrix4< scalar_type > | [inline]
setT(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
setX(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
setY(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
setZ(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
translate(scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline]
translate(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline]
translation(const Vector3< scalar_type > &v) | vl::Matrix4< scalar_type > | [inline, static]
translation(scalar_type x, scalar_type y, scalar_type z) | vl::Matrix4< scalar_type > | [inline, static]
transpose() | vl::Matrix4< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::MemoryDirectory Member List

This is the complete list of members for vl::MemoryDirectory, including all inherited members.

addFile(MemoryFile *file) | vl::MemoryDirectory |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::MemoryDirectory | [inline, virtual]
clone(VirtualDirectory *directory, const String &match="*") | vl::MemoryDirectory |
decReference() | vl::Object | [inline]
eraseAllFiles() | vl::MemoryDirectory | [inline]
file(const String &name) const | vl::MemoryDirectory | [inline, virtual]
fileExists(const String &name) const | vl::VirtualDirectory | [inline]
incReference() | vl::Object | [inline]
listFiles(std::vector< String > &file_list, bool append=false) const | vl::MemoryDirectory | [virtual]
listFilesRecursive(std::vector< String > &file_list) const | vl::MemoryDirectory | [virtual]
vl::VirtualDirectory::listFilesRecursive(std::vector< String > &file_list, const String &match) const | vl::VirtualDirectory | [inline, virtual]
listSubDirs(std::vector< String > &dirs, bool append=false) const | vl::MemoryDirectory | [virtual]
MemoryDirectory(const String &path=".") | vl::MemoryDirectory | [inline]
memoryFile(const String &name) const | vl::MemoryDirectory |
memorySubDir(const String &subdir_name) const | vl::MemoryDirectory |
mFiles | vl::MemoryDirectory | [protected]
mName | vl::Object | [protected]
mPath | vl::VirtualDirectory | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualDirectory | [inline, virtual]
referenceCount() const | vl::Object | [inline]
removeFile(MemoryFile *file) | vl::MemoryDirectory |
removeFile(const String &name) | vl::MemoryDirectory |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::MemoryDirectory | [virtual]
subDir(const String &subdir_name) const | vl::MemoryDirectory | [inline, virtual]
translatePath(const String &p) const | vl::VirtualDirectory | [protected]
VirtualDirectory(const String &path="/") | vl::VirtualDirectory | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::MemoryFile Member List

This is the complete list of members for vl::MemoryFile, including all inherited members.

allocateBuffer(long long byte_count) | vl::MemoryFile | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
buffer() const | vl::MemoryFile | [inline]
buffer() | vl::MemoryFile | [inline]
className() | vl::MemoryFile | [inline, virtual]
clone() const | vl::MemoryFile | [virtual]
close() | vl::MemoryFile | [inline, virtual]
copy(VirtualFile *file) | vl::MemoryFile |
crc32() | vl::VirtualFile |
decReference() | vl::Object | [inline]
endOfFile() const | vl::VirtualFile | [inline]
exists() const | vl::MemoryFile | [inline, virtual]
incReference() | vl::Object | [inline]
isOpen() const | vl::MemoryFile | [inline, virtual]
load(std::vector< unsigned char > &data) | vl::VirtualFile |
load(void *buffer, long long max=-1) | vl::VirtualFile |
mBuffer | vl::MemoryFile | [protected]
md5() | vl::VirtualFile |
MemoryFile() | vl::MemoryFile |
mIsOpen | vl::MemoryFile | [protected]
mName | vl::Object | [protected]
mPath | vl::VirtualFile | [protected]
mPtr | vl::MemoryFile | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
open(EOpenMode mode) | vl::MemoryFile | [virtual]
operator=(const MemoryFile &other) | vl::MemoryFile | [inline]
vl::VirtualFile::operator=(const VirtualFile &other) | vl::VirtualFile | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualFile | [inline]
peek(void *buffer, long long byte_count) | vl::VirtualFile |
position() const | vl::VirtualFile |
position_Implementation() const | vl::MemoryFile | [protected, virtual]
ptr() | vl::MemoryFile | [inline]
read(void *buffer, long long byte_count) | vl::VirtualFile |
read_Implementation(void *buffer, long long byte_count) | vl::MemoryFile | [protected, virtual]
readDouble(bool little_endian_data=true) | vl::VirtualFile |
readDouble(void *buffer, long long count) | vl::VirtualFile |
readFloat(bool little_endian_data=true) | vl::VirtualFile |
readFloat(void *buffer, long long count) | vl::VirtualFile |
readSByte() | vl::VirtualFile |
readSByte(void *buffer, long long count) | vl::VirtualFile |
readSInt16(bool little_endian_data=true) | vl::VirtualFile |
readSInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt32(bool little_endian_data=true) | vl::VirtualFile |
readSInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt64(bool little_endian_data=true) | vl::VirtualFile |
readSInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUByte() | vl::VirtualFile |
readUByte(void *buffer, long long count) | vl::VirtualFile |
readUInt16(bool little_endian_data=true) | vl::VirtualFile |
readUInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt32(bool little_endian_data=true) | vl::VirtualFile |
readUInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt64(bool little_endian_data=true) | vl::VirtualFile |
readUInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
referenceCount() const | vl::Object | [inline]
seekCur(long long offset) | vl::VirtualFile |
seekEnd(long long offset) | vl::VirtualFile |
seekSet(long long offset) | vl::VirtualFile |
seekSet_Implementation(long long offset) | vl::MemoryFile | [protected, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBuffer(Buffer *buffer) | vl::MemoryFile | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::VirtualFile | [inline]
size() const | vl::MemoryFile | [inline, virtual]
VirtualFile(const VirtualFile &other) | vl::VirtualFile | [inline, protected]
VirtualFile() | vl::VirtualFile | [inline]
write(const void *buffer, long long byte_count) | vl::VirtualFile |
write_Implementation(const void *, long long) | vl::MemoryFile | [inline, protected, virtual]
writeSInt16(short data, bool little_endian=true) | vl::VirtualFile |
writeSInt32(long data, bool little_endian=true) | vl::VirtualFile |
writeSInt8(char data) | vl::VirtualFile |
writeUInt16(unsigned short data, bool little_endian=true) | vl::VirtualFile |
writeUInt32(unsigned long data, bool little_endian=true) | vl::VirtualFile |
writeUInt8(unsigned char data) | vl::VirtualFile |
~Object() | vl::Object | [protected, virtual]
~VirtualFile() | vl::VirtualFile | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::MorphingActor Member List

This is the complete list of members for vl::MorphingActor, including all inherited members.

Actor(Renderable *renderable=NULL, Effect *effect=NULL, Transform *transform=NULL, int block=0, int rank=0) | vl::Actor | [inline]
animationStarted() const | vl::MorphingActor | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
blendFrames(int a, int b, float t) | vl::MorphingActor |
boundingBox() const | vl::Actor | [inline]
boundingSphere() const | vl::Actor | [inline]
className() | vl::MorphingActor | [inline, virtual]
computeBounds() | vl::Actor |
createOcclusionQuery() | vl::Actor |
decReference() | vl::Object | [inline]
deleteOcclusionQuery() | vl::Actor |
effect() | vl::Actor | [inline]
effect() const | vl::Actor | [inline]
enableMask() const | vl::Actor | [inline]
eraseAllUniforms() | vl::Actor | [inline]
eraseUniform(const std::string &name) | vl::Actor | [inline]
eraseUniform(const Uniform *uniform) | vl::Actor | [inline]
evaluateLOD(Camera *camera) | vl::Actor |
executeRenderingCallbacks(const Camera *camera, Renderable *renderable, const Shader *shader, int pass) | vl::Actor | [inline]
geometry() | vl::MorphingActor | [inline]
geometry() const | vl::MorphingActor | [inline]
getUniform(const std::string &name) | vl::Actor | [inline]
getUniform(const std::string &name) const | vl::Actor | [inline]
glslVertexBlendEnabled() const | vl::MorphingActor | [inline]
gocUniform(const std::string &name) | vl::Actor | [inline]
incReference() | vl::Object | [inline]
init(ResourceDatabase *res_db) | vl::MorphingActor |
initFrom(MorphingActor *morph_act) | vl::MorphingActor |
isOccludee() const | vl::Actor | [inline]
lastUpdateTime() const | vl::Actor | [inline]
lod(int lod_index) | vl::Actor | [inline]
lod(int lod_index) const | vl::Actor | [inline]
lodEvaluator() | vl::Actor | [inline]
lodEvaluator() const | vl::Actor | [inline]
mAABB | vl::Actor | [protected]
mAnim_t | vl::MorphingActor | [protected]
mAnim_t_Binding | vl::MorphingActor | [protected]
mAnimationEnd | vl::MorphingActor | [protected]
mAnimationPeriod | vl::MorphingActor | [protected]
mAnimationStart | vl::MorphingActor | [protected]
mAnimationStarted | vl::MorphingActor | [protected]
mAnimationStartTime | vl::MorphingActor | [protected]
mBoundsUpdateTick | vl::Actor | [protected]
mEffect | vl::Actor | [protected]
mElapsedTime | vl::MorphingActor | [protected]
mEnableMask | vl::Actor | [protected]
mFrame1 | vl::MorphingActor | [protected]
mFrame2 | vl::MorphingActor | [protected]
mGeometry | vl::MorphingActor |
mGLSLVertexBlendEnabled | vl::MorphingActor | [protected]
mIsOccludee | vl::Actor | [protected]
mLastUpdate | vl::MorphingActor | [protected]
mLastUpdateTime | vl::Actor | [protected]
mLODEvaluator | vl::Actor | [protected]
mName | vl::Object | [protected]
mNormal2_Binding | vl::MorphingActor | [protected]
mNormalFrames | vl::MorphingActor |
mNormals | vl::MorphingActor |
mOcclusionQuery | vl::Actor | [protected]
mOcclusionQueryTick | vl::Actor | [protected]
MorphingActor() | vl::MorphingActor |
MorphingCallback class | vl::MorphingActor | [friend]
mRenderables | vl::Actor | [protected]
mRenderBlock | vl::Actor | [protected]
mRenderingCallbacks | vl::Actor | [protected]
mRenderRank | vl::Actor | [protected]
mScissor | vl::Actor | [protected]
mSphere | vl::Actor | [protected]
mTransform | vl::Actor | [protected]
mTransformUpdateTick | vl::Actor | [protected]
mUniformSet | vl::Actor | [protected]
mVertex2_Binding | vl::MorphingActor | [protected]
mVertexFrames | vl::MorphingActor |
mVertices | vl::MorphingActor |
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
occlusionQuery() const | vl::Actor | [inline]
occlusionQueryTick() const | vl::Actor | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderBlock() const | vl::Actor | [inline]
renderingCallbacks() const | vl::Actor | [inline]
renderingCallbacks() | vl::Actor | [inline]
renderRank() const | vl::Actor | [inline]
resetGLSLBindings() | vl::MorphingActor |
scissor() const | vl::Actor | [inline]
scissor() | vl::Actor | [inline]
setAnimation(int start, int end, float period) | vl::MorphingActor |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEffect(Effect *effect) | vl::Actor | [inline]
setEnableMask(unsigned int mask) | vl::Actor | [inline]
setGLSLVertexBlendEnabled(bool enable) | vl::MorphingActor | [inline]
setLastUpdateTime(Real time) | vl::Actor | [inline]
setLODEvaluator(LODEvaluator *lod_evaluator) | vl::Actor | [inline]
setLODs(Renderable *lod0, Renderable *lod1=NULL, Renderable *lod2=NULL, Renderable *lod3=NULL, Renderable *lod4=NULL, Renderable *lod5=NULL) | vl::Actor | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOccludee(bool is_occludee) | vl::Actor | [inline]
setOcclusionQueryTick(unsigned tick) | vl::Actor | [inline]
setRenderBlock(int block) | vl::Actor | [inline]
setRenderRank(int rank) | vl::Actor | [inline]
setScissor(Scissor *scissor) | vl::Actor | [inline]
setTransform(Transform *transform) | vl::Actor | [inline]
setUniform(Uniform *uniform) | vl::Actor | [inline]
setUniformSet(UniformSet *uniforms) | vl::Actor | [inline]
startAnimation(Real time=-1) | vl::MorphingActor |
stopAnimation() | vl::MorphingActor |
transform() | vl::Actor | [inline]
transform() const | vl::Actor | [inline]
uniforms() const | vl::Actor | [inline]
uniformSet() const | vl::Actor | [inline]
update(int lod, Camera *, Real delta_t) | vl::MorphingActor | [virtual]
~Actor() | vl::Actor | [virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::MorphingCallback Member List

This is the complete list of members for vl::MorphingCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::MorphingCallback | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const Camera *cam, Actor *actor, Renderable *renderable, const Shader *, int pass) | vl::MorphingCallback | [virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::ObjLoader Member List

This is the complete list of members for vl::ObjLoader, including all inherited members.

loadOBJ(VirtualFile *file) | vl::ObjLoader |
loadObjMaterials(VirtualFile *file, std::vector< ObjMaterial > &materials) | vl::ObjLoader |
materials() const | vl::ObjLoader | [inline]
materials() | vl::ObjLoader | [inline]
mCoords | vl::ObjLoader | [protected]
meshes() const | vl::ObjLoader | [inline]
meshes() | vl::ObjLoader | [inline]
mMaterials | vl::ObjLoader | [protected]
mMeshes | vl::ObjLoader | [protected]
mNormals | vl::ObjLoader | [protected]
mTexCoords | vl::ObjLoader | [protected]
normalArray() const | vl::ObjLoader | [inline]
normalArray() | vl::ObjLoader | [inline]
texCoordsArray() const | vl::ObjLoader | [inline]
texCoordsArray() | vl::ObjLoader | [inline]
vertexArray() const | vl::ObjLoader | [inline]
vertexArray() | vl::ObjLoader | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::ObjMaterial Member List

This is the complete list of members for vl::ObjMaterial, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ObjMaterial | [inline, virtual]
decReference() | vl::Object | [inline]
illum() const | vl::ObjMaterial | [inline]
incReference() | vl::Object | [inline]
ka() const | vl::ObjMaterial | [inline]
kd() const | vl::ObjMaterial | [inline]
ks() const | vl::ObjMaterial | [inline]
map_Bump() const | vl::ObjMaterial | [inline]
map_d() const | vl::ObjMaterial | [inline]
map_Decal() const | vl::ObjMaterial | [inline]
map_Disp() const | vl::ObjMaterial | [inline]
map_Ka() const | vl::ObjMaterial | [inline]
map_Kd() const | vl::ObjMaterial | [inline]
map_Ks() const | vl::ObjMaterial | [inline]
map_Ns() const | vl::ObjMaterial | [inline]
mIllum | vl::ObjMaterial | [protected]
mKa | vl::ObjMaterial | [protected]
mKd | vl::ObjMaterial | [protected]
mKs | vl::ObjMaterial | [protected]
mMap_Bump | vl::ObjMaterial | [protected]
mMap_d | vl::ObjMaterial | [protected]
mMap_Decal | vl::ObjMaterial | [protected]
mMap_Disp | vl::ObjMaterial | [protected]
mMap_Ka | vl::ObjMaterial | [protected]
mMap_Kd | vl::ObjMaterial | [protected]
mMap_Ks | vl::ObjMaterial | [protected]
mMap_Ns | vl::ObjMaterial | [protected]
mName | vl::Object | [protected]
mNi | vl::ObjMaterial | [protected]
mNs | vl::ObjMaterial | [protected]
mTr | vl::ObjMaterial | [protected]
name() const | vl::Object | [inline]
ni() const | vl::ObjMaterial | [inline]
ns() const | vl::ObjMaterial | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
ObjMaterial() | vl::ObjMaterial | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setIllum(int illum) | vl::ObjMaterial | [inline]
setKa(const fvec3 &ka) | vl::ObjMaterial | [inline]
setKd(const fvec3 &kd) | vl::ObjMaterial | [inline]
setKs(const fvec3 &ks) | vl::ObjMaterial | [inline]
setMap_Bump(const ObjTexture &map_bump) | vl::ObjMaterial | [inline]
setMap_d(const ObjTexture &map_d) | vl::ObjMaterial | [inline]
setMap_Decal(const ObjTexture &map_decal) | vl::ObjMaterial | [inline]
setMap_Disp(const ObjTexture &map_disp) | vl::ObjMaterial | [inline]
setMap_Ka(const ObjTexture &map_ka) | vl::ObjMaterial | [inline]
setMap_Kd(const ObjTexture &map_kd) | vl::ObjMaterial | [inline]
setMap_Ks(const ObjTexture &map_ks) | vl::ObjMaterial | [inline]
setMap_Ns(const ObjTexture &map_ns) | vl::ObjMaterial | [inline]
setName(const std::string &name) | vl::Object | [inline]
setNi(float ni) | vl::ObjMaterial | [inline]
setNs(float ns) | vl::ObjMaterial | [inline]
setTr(float tr) | vl::ObjMaterial | [inline]
tr() const | vl::ObjMaterial | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::ObjMesh Member List

This is the complete list of members for vl::ObjMesh, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ObjMesh | [inline, virtual]
decReference() | vl::Object | [inline]
face_type() const | vl::ObjMesh | [inline]
face_type() | vl::ObjMesh | [inline]
faceNormalIndex() const | vl::ObjMesh | [inline]
faceNormalIndex() | vl::ObjMesh | [inline]
facePositionIndex() const | vl::ObjMesh | [inline]
facePositionIndex() | vl::ObjMesh | [inline]
faceTexCoordIndex() const | vl::ObjMesh | [inline]
faceTexCoordIndex() | vl::ObjMesh | [inline]
incReference() | vl::Object | [inline]
material() const | vl::ObjMesh | [inline]
material() | vl::ObjMesh | [inline]
mFace_icoords | vl::ObjMesh | [protected]
mFace_inormals | vl::ObjMesh | [protected]
mFace_itexcoords | vl::ObjMesh | [protected]
mFace_type | vl::ObjMesh | [protected]
mMaterial | vl::ObjMesh | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setMaterial(ObjMaterial *mat) | vl::ObjMesh | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::ObjTexture Member List

This is the complete list of members for vl::ObjTexture, including all inherited members.

blendU() const | vl::ObjTexture | [inline]
blendV() const | vl::ObjTexture | [inline]
bm() const | vl::ObjTexture | [inline]
cc() const | vl::ObjTexture | [inline]
clamp() const | vl::ObjTexture | [inline]
imfchan() const | vl::ObjTexture | [inline]
mBlendU | vl::ObjTexture | [protected]
mBlendV | vl::ObjTexture | [protected]
mBM | vl::ObjTexture | [protected]
mCC | vl::ObjTexture | [protected]
mClamp | vl::ObjTexture | [protected]
mFileName | vl::ObjTexture | [protected]
mImfchan | vl::ObjTexture | [protected]
mm_Base() const | vl::ObjTexture | [inline]
mm_Gain() const | vl::ObjTexture | [inline]
mMM_Base | vl::ObjTexture | [protected]
mMM_Gain | vl::ObjTexture | [protected]
mO_UVW | vl::ObjTexture | [protected]
mS_UVW | vl::ObjTexture | [protected]
mT_UVW | vl::ObjTexture | [protected]
mTexres_Value | vl::ObjTexture | [protected]
o_UVW() const | vl::ObjTexture | [inline]
ObjTexture() | vl::ObjTexture |
parseLine(const String &line, const String &file) | vl::ObjTexture |
path() const | vl::ObjTexture | [inline]
print() | vl::ObjTexture |
s_UVW() const | vl::ObjTexture | [inline]
setBlendU(bool on) | vl::ObjTexture | [inline]
setBlendV(bool on) | vl::ObjTexture | [inline]
setBM(float bm) | vl::ObjTexture | [inline]
setCC(bool on) | vl::ObjTexture | [inline]
setClamp(bool on) | vl::ObjTexture | [inline]
setImfchan(char val) | vl::ObjTexture | [inline]
setMM_Base(float base) | vl::ObjTexture | [inline]
setMM_Gain(float gain) | vl::ObjTexture | [inline]
setO_UVW(const fvec3 &o_uvw) | vl::ObjTexture | [inline]
setPath(const String &filename) | vl::ObjTexture | [inline]
setS_UVW(const fvec3 &s_uvw) | vl::ObjTexture | [inline]
setT_UVW(const fvec3 &t_uvw) | vl::ObjTexture | [inline]
setTexres_Value(float value) | vl::ObjTexture | [inline]
t_UVW() const | vl::ObjTexture | [inline]
texres_Value() const | vl::ObjTexture | [inline]
valid() const | vl::ObjTexture | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::Object Member List

This is the complete list of members for vl::Object, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::OpenGLContext Member List

This is the complete list of members for vl::OpenGLContext, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vl::OpenGLContext | [inline, virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vl::OpenGLContext | [inline, virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
height() const | vl::OpenGLContext | [inline]
hide() | vl::OpenGLContext | [inline, virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
initExtensions(bool log=true) | vl::OpenGLContext |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vl::OpenGLContext | [inline, virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vl::OpenGLContext | [inline, virtual]
quitApplication() | vl::OpenGLContext | [inline, virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool) | vl::OpenGLContext | [inline, virtual]
setMousePosition(int, int) | vl::OpenGLContext | [inline, virtual]
setMouseVisible(bool) | vl::OpenGLContext | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int, int) | vl::OpenGLContext | [inline, virtual]
setSize(int, int) | vl::OpenGLContext | [inline, virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowTitle(const String &) | vl::OpenGLContext | [inline, virtual]
show() | vl::OpenGLContext | [inline, virtual]
size() const | vl::OpenGLContext | [inline, virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vl::OpenGLContext | [inline, virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vl::OpenGLContext | [inline, virtual]
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::OpenGLContextFormat Member List

This is the complete list of members for vl::OpenGLContextFormat, including all inherited members.

accumRGBABits() const | vl::OpenGLContextFormat | [inline]
bitsPerPixel() const | vl::OpenGLContextFormat | [inline]
className() | vl::OpenGLContextFormat | [inline, virtual]
depthBufferBits() const | vl::OpenGLContextFormat | [inline]
doubleBuffer() const | vl::OpenGLContextFormat | [inline]
fullscreen() const | vl::OpenGLContextFormat | [inline]
mAccumRGBABits | vl::OpenGLContextFormat | [protected]
mFullscreen | vl::OpenGLContextFormat | [protected]
mHasDoubleBuffer | vl::OpenGLContextFormat | [protected]
mHasMultisample | vl::OpenGLContextFormat | [protected]
mMultisampleSamples | vl::OpenGLContextFormat | [protected]
mRGBABits | vl::OpenGLContextFormat | [protected]
mStencilBufferBits | vl::OpenGLContextFormat | [protected]
mStereo | vl::OpenGLContextFormat | [protected]
multisample() const | vl::OpenGLContextFormat | [inline]
multisampleSamples() const | vl::OpenGLContextFormat | [inline]
mVSync | vl::OpenGLContextFormat | [protected]
mZBufferBits | vl::OpenGLContextFormat | [protected]
OpenGLContextFormat() | vl::OpenGLContextFormat | [inline]
rgbaBits() const | vl::OpenGLContextFormat | [inline]
setAccumRGBABits(int r, int g, int b, int a) | vl::OpenGLContextFormat | [inline]
setDepthBufferBits(int bits) | vl::OpenGLContextFormat | [inline]
setDoubleBuffer(bool double_buffer_on) | vl::OpenGLContextFormat | [inline]
setFullscreen(bool fullscreent) | vl::OpenGLContextFormat | [inline]
setMultisample(bool multisample_on) | vl::OpenGLContextFormat | [inline]
setMultisampleSamples(int samples) | vl::OpenGLContextFormat | [inline]
setRGBABits(int r, int g, int b, int a) | vl::OpenGLContextFormat | [inline]
setStencilBufferBits(int bits) | vl::OpenGLContextFormat | [inline]
setStereo(bool stereo_on) | vl::OpenGLContextFormat | [inline]
setVSync(bool vsync_on) | vl::OpenGLContextFormat | [inline]
stencilBufferBits() const | vl::OpenGLContextFormat | [inline]
stereo() const | vl::OpenGLContextFormat | [inline]
vSync() const | vl::OpenGLContextFormat | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::PixelLODEvaluator Member List

This is the complete list of members for vl::PixelLODEvaluator, including all inherited members.

addPixelRange(float distance) | vl::PixelLODEvaluator |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PixelLODEvaluator | [inline, virtual]
clearPixelRangeSet() | vl::PixelLODEvaluator | [inline]
decReference() | vl::Object | [inline]
distanceRange(int index) const | vl::PixelLODEvaluator | [inline]
distanceRangeCount() const | vl::PixelLODEvaluator | [inline]
distanceRangeSet() | vl::PixelLODEvaluator | [inline]
evaluate(Actor *actor, Camera *camera) | vl::PixelLODEvaluator | [virtual]
incReference() | vl::Object | [inline]
LODEvaluator() | vl::LODEvaluator | [inline]
mName | vl::Object | [protected]
mPixelRangeSet | vl::PixelLODEvaluator | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PixelLODEvaluator() | vl::PixelLODEvaluator | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPixelRange(int index, float distance) | vl::PixelLODEvaluator |
setPixelRangeSet(const std::vector< float > &distance_set) | vl::PixelLODEvaluator |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::PixelTransfer Member List

This is the complete list of members for vl::PixelTransfer, including all inherited members.

alphaBias() const | vl::PixelTransfer | [inline]
alphaScale() const | vl::PixelTransfer | [inline]
apply(const Camera *) const | vl::PixelTransfer | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
blueBias() const | vl::PixelTransfer | [inline]
blueScale() const | vl::PixelTransfer | [inline]
className() | vl::PixelTransfer | [inline, virtual]
decReference() | vl::Object | [inline]
depthBias() const | vl::PixelTransfer | [inline]
depthScale() const | vl::PixelTransfer | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
greenBias() const | vl::PixelTransfer | [inline]
greenScale() const | vl::PixelTransfer | [inline]
incReference() | vl::Object | [inline]
indexOffset() const | vl::PixelTransfer | [inline]
indexShift() const | vl::PixelTransfer | [inline]
initResources() | vl::RenderState | [inline, virtual]
mAlphaBias | vl::PixelTransfer | [protected]
mAlphaScale | vl::PixelTransfer | [protected]
mapColor() const | vl::PixelTransfer | [inline]
mapStencil() const | vl::PixelTransfer | [inline]
mBlueBias | vl::PixelTransfer | [protected]
mBlueScale | vl::PixelTransfer | [protected]
mDepthBias | vl::PixelTransfer | [protected]
mDepthScale | vl::PixelTransfer | [protected]
mGreenBias | vl::PixelTransfer | [protected]
mGreenScale | vl::PixelTransfer | [protected]
mIndexOffset | vl::PixelTransfer | [protected]
mIndexShift | vl::PixelTransfer | [protected]
mMapColor | vl::PixelTransfer | [protected]
mMapStencil | vl::PixelTransfer | [protected]
mName | vl::Object | [protected]
mPostColorMatrixAlphaBias | vl::PixelTransfer | [protected]
mPostColorMatrixAlphaScale | vl::PixelTransfer | [protected]
mPostColorMatrixBlueBias | vl::PixelTransfer | [protected]
mPostColorMatrixBlueScale | vl::PixelTransfer | [protected]
mPostColorMatrixGreenBias | vl::PixelTransfer | [protected]
mPostColorMatrixGreenScale | vl::PixelTransfer | [protected]
mPostColorMatrixRedBias | vl::PixelTransfer | [protected]
mPostColorMatrixRedScale | vl::PixelTransfer | [protected]
mPostConvolutionAlphaBias | vl::PixelTransfer | [protected]
mPostConvolutionAlphaScale | vl::PixelTransfer | [protected]
mPostConvolutionBlueBias | vl::PixelTransfer | [protected]
mPostConvolutionBlueScale | vl::PixelTransfer | [protected]
mPostConvolutionGreenBias | vl::PixelTransfer | [protected]
mPostConvolutionGreenScale | vl::PixelTransfer | [protected]
mPostConvolutionRedBias | vl::PixelTransfer | [protected]
mPostConvolutionRedScale | vl::PixelTransfer | [protected]
mRedBias | vl::PixelTransfer | [protected]
mRedScale | vl::PixelTransfer | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PixelTransfer() | vl::PixelTransfer | [inline]
postColorMatrixAlphaBias() const | vl::PixelTransfer | [inline]
postColorMatrixAlphaScale() const | vl::PixelTransfer | [inline]
postColorMatrixBlueBias() const | vl::PixelTransfer | [inline]
postColorMatrixBlueScale() const | vl::PixelTransfer | [inline]
postColorMatrixGreenBias() const | vl::PixelTransfer | [inline]
postColorMatrixGreenScale() const | vl::PixelTransfer | [inline]
postColorMatrixRedBias() const | vl::PixelTransfer | [inline]
postColorMatrixRedScale() const | vl::PixelTransfer | [inline]
postConvolutionAlphaBias() const | vl::PixelTransfer | [inline]
postConvolutionAlphaScale() const | vl::PixelTransfer | [inline]
postConvolutionBlueBias() const | vl::PixelTransfer | [inline]
postConvolutionBlueScale() const | vl::PixelTransfer | [inline]
postConvolutionGreenBias() const | vl::PixelTransfer | [inline]
postConvolutionGreenScale() const | vl::PixelTransfer | [inline]
postConvolutionRedBias() const | vl::PixelTransfer | [inline]
postConvolutionRedScale() const | vl::PixelTransfer | [inline]
redBias() const | vl::PixelTransfer | [inline]
redScale() const | vl::PixelTransfer | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAlphaBias(float alpha_bias) | vl::PixelTransfer | [inline]
setAlphaScale(float alpha_scale) | vl::PixelTransfer | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBlueBias(float blue_bias) | vl::PixelTransfer | [inline]
setBlueScale(float blue_scale) | vl::PixelTransfer | [inline]
setDepthBias(float depth_bias) | vl::PixelTransfer | [inline]
setDepthScale(float depth_scale) | vl::PixelTransfer | [inline]
setGreenBias(float green_bias) | vl::PixelTransfer | [inline]
setGreenScale(float green_scale) | vl::PixelTransfer | [inline]
setIndexOffset(int index_offset) | vl::PixelTransfer | [inline]
setIndexShift(int index_shift) | vl::PixelTransfer | [inline]
setMapColor(bool map_color) | vl::PixelTransfer | [inline]
setMapStencil(bool map_stencil) | vl::PixelTransfer | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPostColorMatrixAlphaBias(float bias) | vl::PixelTransfer | [inline]
setPostColorMatrixAlphaScale(float scale) | vl::PixelTransfer | [inline]
setPostColorMatrixBlueBias(float bias) | vl::PixelTransfer | [inline]
setPostColorMatrixBlueScale(float scale) | vl::PixelTransfer | [inline]
setPostColorMatrixGreenBias(float bias) | vl::PixelTransfer | [inline]
setPostColorMatrixGreenScale(float scale) | vl::PixelTransfer | [inline]
setPostColorMatrixRedBias(float bias) | vl::PixelTransfer | [inline]
setPostColorMatrixRedScale(float scale) | vl::PixelTransfer | [inline]
setPostConvolutionAlphaBias(float bias) | vl::PixelTransfer | [inline]
setPostConvolutionAlphaScale(float scale) | vl::PixelTransfer | [inline]
setPostConvolutionBlueBias(float bias) | vl::PixelTransfer | [inline]
setPostConvolutionBlueScale(float scale) | vl::PixelTransfer | [inline]
setPostConvolutionGreenBias(float bias) | vl::PixelTransfer | [inline]
setPostConvolutionGreenScale(float scale) | vl::PixelTransfer | [inline]
setPostConvolutionRedBias(float bias) | vl::PixelTransfer | [inline]
setPostConvolutionRedScale(float scale) | vl::PixelTransfer | [inline]
setRedBias(float red_bias) | vl::PixelTransfer | [inline]
setRedScale(float red_scale) | vl::PixelTransfer | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PixelTransfer | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Plane Member List

This is the complete list of members for vl::Plane, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
classify(const AABB &) const | vl::Plane |
className() | vl::Plane | [inline, virtual]
decReference() | vl::Object | [inline]
distance(const vec3 &v) const | vl::Plane |
incReference() | vl::Object | [inline]
isOutside(const AABB &) const | vl::Plane |
mName | vl::Object | [protected]
mNormal | vl::Plane | [protected]
mOrigin | vl::Plane | [protected]
name() const | vl::Object | [inline]
normal() const | vl::Plane | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
origin() const | vl::Plane | [inline]
Plane(Real o=0.0f, vec3 n=vec3(0, 0, 0)) | vl::Plane | [inline]
Plane(const vec3 &o, const vec3 &n) | vl::Plane | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setNormal(const vec3 &normal) | vl::Plane | [inline]
setOrigin(Real origin) | vl::Plane | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::PlyLoader Member List

This is the complete list of members for vl::PlyLoader, including all inherited members.

analyzeHeader() | vl::PlyLoader |
binary() const | vl::PlyLoader | [inline]
elements() const | vl::PlyLoader | [inline]
elements() | vl::PlyLoader | [inline]
EType enum name | vl::PlyLoader |
littleEndian() const | vl::PlyLoader | [inline]
loadPly(VirtualFile *file) | vl::PlyLoader |
mBinary | vl::PlyLoader | [protected]
mColors | vl::PlyLoader | [protected]
mElements | vl::PlyLoader | [protected]
mIndices | vl::PlyLoader | [protected]
mLittleEndian | vl::PlyLoader | [protected]
mNormals | vl::PlyLoader | [protected]
mVertexIndex | vl::PlyLoader | [protected]
mVerts | vl::PlyLoader | [protected]
newElement(PlyElement *el) | vl::PlyLoader |
PlyChar enum value | vl::PlyLoader |
PlyDouble enum value | vl::PlyLoader |
PlyError enum value | vl::PlyLoader |
PlyFloat enum value | vl::PlyLoader |
PlyInt enum value | vl::PlyLoader |
PlyLoader() | vl::PlyLoader | [inline]
PlyShort enum value | vl::PlyLoader |
PlyUChar enum value | vl::PlyLoader |
PlyUInt enum value | vl::PlyLoader |
PlyUShort enum value | vl::PlyLoader |
readElements(VirtualFile *file) | vl::PlyLoader |
readElements(TextStream *text) | vl::PlyLoader |
readHeader(TextStream *line_reader) | vl::PlyLoader |
translateType(const String &type) | vl::PlyLoader |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::PlyLoader::PlyElement Member List

This is the complete list of members for vl::PlyLoader::PlyElement, including all inherited members.

analyze() | vl::PlyLoader::PlyElement |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
elemCount() const | vl::PlyLoader::PlyElement | [inline]
getColor() const | vl::PlyLoader::PlyElement | [inline]
getNormal() const | vl::PlyLoader::PlyElement | [inline]
getVertex() const | vl::PlyLoader::PlyElement | [inline]
incReference() | vl::Object | [inline]
mColor | vl::PlyLoader::PlyElement | [protected]
mElemCount | vl::PlyLoader::PlyElement | [protected]
mName | vl::PlyLoader::PlyElement | [protected]
mNormal | vl::PlyLoader::PlyElement | [protected]
mProperties | vl::PlyLoader::PlyElement | [protected]
mVertex | vl::PlyLoader::PlyElement | [protected]
name() const | vl::PlyLoader::PlyElement | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PlyElement() | vl::PlyLoader::PlyElement | [inline]
properties() const | vl::PlyLoader::PlyElement | [inline]
properties() | vl::PlyLoader::PlyElement | [inline]
read(VirtualFile *file, bool le) | vl::PlyLoader::PlyElement | [inline, virtual]
read(TextStream *text) | vl::PlyLoader::PlyElement | [inline, virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setElemCount(int count) | vl::PlyLoader::PlyElement | [inline]
setName(const String &name) | vl::PlyLoader::PlyElement | [inline]
vl::Object::setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::PlyLoader::PlyPropertyAbstract Member List

This is the complete list of members for vl::PlyLoader::PlyPropertyAbstract, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::PlyLoader::PlyPropertyAbstract | [protected]
name() const | vl::PlyLoader::PlyPropertyAbstract | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
read(VirtualFile *, bool le)=0 | vl::PlyLoader::PlyPropertyAbstract | [pure virtual]
read(TextStream *text)=0 | vl::PlyLoader::PlyPropertyAbstract | [pure virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const String &name) | vl::PlyLoader::PlyPropertyAbstract | [inline]
vl::Object::setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::PlyLoader::PlyScalar Member List

This is the complete list of members for vl::PlyLoader::PlyScalar, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
getAsFloat() const | vl::PlyLoader::PlyScalar |
getAsInt() const | vl::PlyLoader::PlyScalar |
incReference() | vl::Object | [inline]
mChar | vl::PlyLoader::PlyScalar |
mData | vl::PlyLoader::PlyScalar | [protected]
mDouble | vl::PlyLoader::PlyScalar |
mFloat | vl::PlyLoader::PlyScalar |
mInt | vl::PlyLoader::PlyScalar |
mName | vl::PlyLoader::PlyPropertyAbstract | [protected]
mScalarType | vl::PlyLoader::PlyScalar | [protected]
mShort | vl::PlyLoader::PlyScalar |
mUChar | vl::PlyLoader::PlyScalar |
mUInt | vl::PlyLoader::PlyScalar |
mUShort | vl::PlyLoader::PlyScalar |
name() const | vl::PlyLoader::PlyPropertyAbstract | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PlyScalar() | vl::PlyLoader::PlyScalar | [inline]
read(VirtualFile *file, bool le) | vl::PlyLoader::PlyScalar | [virtual]
read(TextStream *text) | vl::PlyLoader::PlyScalar | [virtual]
referenceCount() const | vl::Object | [inline]
scalarType() const | vl::PlyLoader::PlyScalar | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const String &name) | vl::PlyLoader::PlyPropertyAbstract | [inline]
vl::Object::setName(const std::string &name) | vl::Object | [inline]
setScalarType(EType type) | vl::PlyLoader::PlyScalar | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::PlyLoader::PlyScalarList Member List

This is the complete list of members for vl::PlyLoader::PlyScalarList, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
countType() const | vl::PlyLoader::PlyScalarList | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mCountType | vl::PlyLoader::PlyScalarList | [protected]
mName | vl::PlyLoader::PlyPropertyAbstract | [protected]
mScalars | vl::PlyLoader::PlyScalarList | [protected]
mScalarType | vl::PlyLoader::PlyScalarList | [protected]
name() const | vl::PlyLoader::PlyPropertyAbstract | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PlyScalarList() | vl::PlyLoader::PlyScalarList | [inline]
read(VirtualFile *file, bool le) | vl::PlyLoader::PlyScalarList | [inline, virtual]
read(TextStream *text) | vl::PlyLoader::PlyScalarList | [inline, virtual]
referenceCount() const | vl::Object | [inline]
scalars() const | vl::PlyLoader::PlyScalarList | [inline]
scalars() | vl::PlyLoader::PlyScalarList | [inline]
scalarType() const | vl::PlyLoader::PlyScalarList | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCountType(EType type) | vl::PlyLoader::PlyScalarList | [inline]
setName(const String &name) | vl::PlyLoader::PlyPropertyAbstract | [inline]
vl::Object::setName(const std::string &name) | vl::Object | [inline]
setScalarType(EType type) | vl::PlyLoader::PlyScalarList | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::PointParameter Member List

This is the complete list of members for vl::PointParameter, including all inherited members.

apply(const Camera *) const | vl::PointParameter | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PointParameter | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
distanceAttenuation() const | vl::PointParameter | [inline]
enable() const | vl::RenderState | [inline, virtual]
fadeThresholdSize() const | vl::PointParameter | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mDistanceAttenuation | vl::PointParameter | [protected]
mFadeThresholdSize | vl::PointParameter | [protected]
mName | vl::Object | [protected]
mSizeMax | vl::PointParameter | [protected]
mSizeMin | vl::PointParameter | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PointParameter(float sizemin=0, float sizemax=1024.0f, float fadethresholdsize=1.0f, fvec3 distanceattenuation=fvec3(1, 0, 0)) | vl::PointParameter | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(float sizemin, float sizemax, float fadethresholdsize, fvec3 distanceattenuation) | vl::PointParameter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDistanceAttenuation(fvec3 attenuation) | vl::PointParameter | [inline]
setFadeThresholdSize(float threshold) | vl::PointParameter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSizeMax(float sizemax) | vl::PointParameter | [inline]
setSizeMin(float sizemin) | vl::PointParameter | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
sizeMax() const | vl::PointParameter | [inline]
sizeMin() const | vl::PointParameter | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PointParameter | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::PointSize Member List

This is the complete list of members for vl::PointSize, including all inherited members.

apply(const Camera *) const | vl::PointSize | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PointSize | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mName | vl::Object | [protected]
mPointSize | vl::PointSize | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PointSize(float pointsize=1.0f) | vl::PointSize | [inline]
pointSize() const | vl::PointSize | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(float pointsize) | vl::PointSize | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PointSize | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::PolygonMode Member List

This is the complete list of members for vl::PolygonMode, including all inherited members.

apply(const Camera *) const | vl::PolygonMode | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
backFace() const | vl::PolygonMode | [inline]
className() | vl::PolygonMode | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
frontFace() const | vl::PolygonMode | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mBackFace | vl::PolygonMode | [protected]
mFrontFace | vl::PolygonMode | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PolygonMode(EPolygonMode frontface=PM_FILL, EPolygonMode backface=PM_FILL) | vl::PolygonMode | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EPolygonMode frontface, EPolygonMode backface) | vl::PolygonMode | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBackFace(EPolygonMode backface) | vl::PolygonMode | [inline]
setFrontFace(EPolygonMode frontface) | vl::PolygonMode | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PolygonMode | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::PolygonOffset Member List

This is the complete list of members for vl::PolygonOffset, including all inherited members.

apply(const Camera *) const | vl::PolygonOffset | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PolygonOffset | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
factor() const | vl::PolygonOffset | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mFactor | vl::PolygonOffset | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
mUnits | vl::PolygonOffset | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PolygonOffset() | vl::PolygonOffset | [inline]
PolygonOffset(float factor, float units) | vl::PolygonOffset | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(float factor, float units) | vl::PolygonOffset | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFactor(float factor) | vl::PolygonOffset | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
setUnits(float units) | vl::PolygonOffset | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PolygonOffset | [inline, virtual]
units() const | vl::PolygonOffset | [inline]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::PolygonSimplifier Member List

This is the complete list of members for vl::PolygonSimplifier, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PolygonSimplifier | [inline, virtual]
clearTrianglesAndVertices() | vl::PolygonSimplifier |
collapse(Vertex *v) | vl::PolygonSimplifier | [inline, protected]
computeCollapseInfo(Vertex *v) | vl::PolygonSimplifier | [inline, protected]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mProtectedVerts | vl::PolygonSimplifier | [protected]
mQuick | vl::PolygonSimplifier | [protected]
mRemoveDoubles | vl::PolygonSimplifier | [protected]
mSimplifiedTriangles | vl::PolygonSimplifier | [protected]
mSimplifiedVertices | vl::PolygonSimplifier | [protected]
mVerbose | vl::PolygonSimplifier | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PolygonSimplifier() | vl::PolygonSimplifier | [inline]
quick() const | vl::PolygonSimplifier | [inline]
referenceCount() const | vl::Object | [inline]
removeDoubles() const | vl::PolygonSimplifier | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setProtectedVertices(const std::vector< int > &protected_verts) | vl::PolygonSimplifier | [inline]
setQuick(bool quick) | vl::PolygonSimplifier | [inline]
setRemoveDoubles(bool remove_doubles) | vl::PolygonSimplifier | [inline]
setVerbose(bool verbose) | vl::PolygonSimplifier | [inline]
simplifiedTriangles(int index) const | vl::PolygonSimplifier | [inline]
simplifiedTrianglesCount() const | vl::PolygonSimplifier | [inline]
simplifiedVertices(int index) const | vl::PolygonSimplifier | [inline]
simplifiedVerticesCount() const | vl::PolygonSimplifier | [inline]
simplify(float simplification_ratio, Geometry *geom) | vl::PolygonSimplifier |
simplify(int target_vertex_count, Geometry *geom) | vl::PolygonSimplifier |
simplify(int target_vertex_count, std::vector< fvec3 > &in_out_verts, std::vector< int > &in_out_tris) | vl::PolygonSimplifier |
verbose() const | vl::PolygonSimplifier | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::PolygonSimplifier::QErr Member List

This is the complete list of members for vl::PolygonSimplifier::QErr, including all inherited members.

a2 | vl::PolygonSimplifier::QErr | [protected]
ab | vl::PolygonSimplifier::QErr | [protected]
ac | vl::PolygonSimplifier::QErr | [protected]
ad | vl::PolygonSimplifier::QErr | [protected]
analyticSolution(dvec3 &v) const | vl::PolygonSimplifier::QErr | [inline]
b2 | vl::PolygonSimplifier::QErr | [protected]
bc | vl::PolygonSimplifier::QErr | [protected]
bd | vl::PolygonSimplifier::QErr | [protected]
c2 | vl::PolygonSimplifier::QErr | [protected]
cd | vl::PolygonSimplifier::QErr | [protected]
d2 | vl::PolygonSimplifier::QErr | [protected]
evaluate(const dvec3 &v) const | vl::PolygonSimplifier::QErr | [inline]
matrix() const | vl::PolygonSimplifier::QErr | [inline]
offset() const | vl::PolygonSimplifier::QErr | [inline]
operator+(const QErr &other) | vl::PolygonSimplifier::QErr | [inline]
operator+=(const QErr &other) | vl::PolygonSimplifier::QErr | [inline]
QErr() | vl::PolygonSimplifier::QErr | [inline]
QErr(const dvec3 &n, double d, double w=1.0) | vl::PolygonSimplifier::QErr | [inline]
vector() const | vl::PolygonSimplifier::QErr | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::PolygonSimplifier::Triangle Member List

This is the complete list of members for vl::PolygonSimplifier::Triangle, including all inherited members.

checkTriangle() const | vl::PolygonSimplifier::Triangle | [inline]
computeArea() const | vl::PolygonSimplifier::Triangle | [inline]
computeNormal() | vl::PolygonSimplifier::Triangle | [inline]
computePotentialArea(const Vertex *oldv, const Vertex *newv) const | vl::PolygonSimplifier::Triangle | [inline]
computePotentialNormal(const Vertex *oldv, const Vertex *newv) const | vl::PolygonSimplifier::Triangle | [inline]
computeQErr() const | vl::PolygonSimplifier::Triangle | [inline]
hasVertex(const Vertex *v) const | vl::PolygonSimplifier::Triangle | [inline]
mNormal | vl::PolygonSimplifier::Triangle | [protected]
mRemoved | vl::PolygonSimplifier::Triangle | [protected]
mVertices | vl::PolygonSimplifier::Triangle | [protected]
normal() const | vl::PolygonSimplifier::Triangle | [inline]
PolygonSimplifier class | vl::PolygonSimplifier::Triangle | [friend]
removed() const | vl::PolygonSimplifier::Triangle | [inline]
replaceVertex(Vertex *oldv, Vertex *newv) | vl::PolygonSimplifier::Triangle | [inline]
Triangle() | vl::PolygonSimplifier::Triangle | [inline]
Vertex class | vl::PolygonSimplifier::Triangle | [friend]
vertex(int index) const | vl::PolygonSimplifier::Triangle | [inline]
vertex(int index) | vl::PolygonSimplifier::Triangle | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::PolygonSimplifier::Vertex Member List

This is the complete list of members for vl::PolygonSimplifier::Vertex, including all inherited members.

addAdjacentVertex(Vertex *v) | vl::PolygonSimplifier::Vertex | [inline]
addQErr(const QErr &qerr) | vl::PolygonSimplifier::Vertex | [inline]
adjacentVertex(int index) const | vl::PolygonSimplifier::Vertex | [inline]
adjacentVerticesCount() const | vl::PolygonSimplifier::Vertex | [inline]
alreadyProcessed() const | vl::PolygonSimplifier::Vertex | [inline]
checkConnectivity() | vl::PolygonSimplifier::Vertex | [inline]
checkTriangles() const | vl::PolygonSimplifier::Vertex | [inline]
collapseCost() const | vl::PolygonSimplifier::Vertex | [inline]
collapsePosition() const | vl::PolygonSimplifier::Vertex | [inline]
collapseVertex() const | vl::PolygonSimplifier::Vertex | [inline]
computeAdjacentVertices() | vl::PolygonSimplifier::Vertex | [inline]
computeEdgePenalty() | vl::PolygonSimplifier::Vertex | [inline]
discardRemovedTriangles() | vl::PolygonSimplifier::Vertex | [inline]
incidentTriangle(int index) const | vl::PolygonSimplifier::Vertex | [inline]
incidentTrianglesCount() const | vl::PolygonSimplifier::Vertex | [inline]
isAdjacentVertex(Vertex *) const | vl::PolygonSimplifier::Vertex | [inline]
isIncidentTriangle(Triangle *) const | vl::PolygonSimplifier::Vertex | [inline]
isProtected() const | vl::PolygonSimplifier::Vertex | [inline]
mAdjacentVerts | vl::PolygonSimplifier::Vertex | [protected]
mAlreadyProcessed | vl::PolygonSimplifier::Vertex | [protected]
mCollapseCost | vl::PolygonSimplifier::Vertex | [protected]
mCollapsePosition | vl::PolygonSimplifier::Vertex | [protected]
mCollapseVertex | vl::PolygonSimplifier::Vertex | [protected]
mIncidentTriangles | vl::PolygonSimplifier::Vertex | [protected]
mOriginalIndex | vl::PolygonSimplifier::Vertex | [protected]
mPosition | vl::PolygonSimplifier::Vertex | [protected]
mProtected | vl::PolygonSimplifier::Vertex | [protected]
mQErr | vl::PolygonSimplifier::Vertex | [protected]
mRemoved | vl::PolygonSimplifier::Vertex | [protected]
mRemoveOrder | vl::PolygonSimplifier::Vertex | [protected]
mSimplifiedIndex | vl::PolygonSimplifier::Vertex | [protected]
originalIndex() const | vl::PolygonSimplifier::Vertex | [inline]
PolygonSimplifier class | vl::PolygonSimplifier::Vertex | [friend]
position() const | vl::PolygonSimplifier::Vertex | [inline]
qerr() const | vl::PolygonSimplifier::Vertex | [inline]
removeAdjacentVertex(Vertex *v) | vl::PolygonSimplifier::Vertex | [inline]
removed() const | vl::PolygonSimplifier::Vertex | [inline]
removeIncidentTriangle(const Triangle *) | vl::PolygonSimplifier::Vertex | [inline]
removeOrder() const | vl::PolygonSimplifier::Vertex | [inline]
setCollapsePosition(const fvec3 &pos) | vl::PolygonSimplifier::Vertex | [inline]
setQErr(const QErr &qerr) | vl::PolygonSimplifier::Vertex | [inline]
simplifiedIndex() const | vl::PolygonSimplifier::Vertex | [inline]
Triangle class | vl::PolygonSimplifier::Vertex | [friend]
Vertex() | vl::PolygonSimplifier::Vertex | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::PolygonStipple Member List

This is the complete list of members for vl::PolygonStipple, including all inherited members.

apply(const Camera *) const | vl::PolygonStipple | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::PolygonStipple | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mask() const | vl::PolygonStipple | [inline]
mMask | vl::PolygonStipple | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
PolygonStipple() | vl::PolygonStipple |
PolygonStipple(const unsigned char *mask) | vl::PolygonStipple |
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(const unsigned char *mask) | vl::PolygonStipple |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::PolygonStipple | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Portal Member List

This is the complete list of members for vl::Portal, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
computeNormal() | vl::Portal | [protected]
decReference() | vl::Object | [inline]
geometry() | vl::Portal | [inline]
geometry() const | vl::Portal | [inline]
incReference() | vl::Object | [inline]
isOpen() const | vl::Portal | [inline]
mIsOpen | vl::Portal | [protected]
mName | vl::Object | [protected]
mNormal | vl::Portal | [protected]
mPortalGeometry | vl::Portal | [protected]
mTargetSector | vl::Portal | [protected]
mVisitTick | vl::Portal | [protected]
name() const | vl::Object | [inline]
normal() const | vl::Portal | [inline, protected]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
Portal() | vl::Portal | [inline]
referenceCount() const | vl::Object | [inline]
SceneManagerPortals class | vl::Portal | [friend]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setIsOpen(bool is_open) | vl::Portal | [inline]
setName(const std::string &name) | vl::Object | [inline]
setNormal(const fvec3 &n) | vl::Portal | [inline, protected]
setTargetSector(Sector *sector) | vl::Portal | [inline]
targetSector() | vl::Portal | [inline]
targetSector() const | vl::Portal | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::Primitives Member List

This is the complete list of members for vl::Primitives, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Primitives | [inline, virtual]
clone() const =0 | vl::Primitives | [pure virtual]
decReference() | vl::Object | [inline]
deleteVBOs()=0 | vl::Primitives | [pure virtual]
handle() const =0 | vl::Primitives | [pure virtual]
incReference() | vl::Object | [inline]
index(int i) const =0 | vl::Primitives | [pure virtual]
indexCount() const =0 | vl::Primitives | [pure virtual]
instances() const | vl::Primitives | [inline]
isEnabled() const | vl::Primitives | [inline]
lineCount() const =0 | vl::Primitives | [pure virtual]
mEnabled | vl::Primitives | [protected]
mInstances | vl::Primitives | [protected]
mName | vl::Object | [protected]
mType | vl::Primitives | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const =0 | vl::Primitives | [pure virtual]
Primitives() | vl::Primitives | [inline]
primitiveType() const | vl::Primitives | [inline]
referenceCount() const | vl::Object | [inline]
render(bool use_vbo=true) const =0 | vl::Primitives | [pure virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnabled(bool enable) | vl::Primitives | [inline]
setInstances(int instances) | vl::Primitives | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPrimitiveType(EPrimitiveType type) | vl::Primitives | [inline]
sortTriangles() | vl::Primitives | [inline, virtual]
triangleCount() const =0 | vl::Primitives | [pure virtual]
updateVBOs(bool discard_local_data=false)=0 | vl::Primitives | [pure virtual]
~Object() | vl::Object | [protected, virtual]
~Primitives() | vl::Primitives | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::Ray Member List

This is the complete list of members for vl::Ray, including all inherited members.

direction() const | vl::Ray | [inline]
mDirection | vl::Ray | [protected]
mOrigin | vl::Ray | [protected]
origin() const | vl::Ray | [inline]
setDirection(const vec3 &dir) | vl::Ray | [inline]
setOrigin(const vec3 &orig) | vl::Ray | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RayIntersection Member List

This is the complete list of members for vl::RayIntersection, including all inherited members.

actor() const | vl::RayIntersection | [inline]
actor() | vl::RayIntersection | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RayIntersection | [inline, virtual]
decReference() | vl::Object | [inline]
distance() const | vl::RayIntersection | [inline]
incReference() | vl::Object | [inline]
intersectionPoint() const | vl::RayIntersection | [inline]
mActor | vl::RayIntersection | [protected]
mDistance | vl::RayIntersection | [protected]
mIntersectionPoint | vl::RayIntersection | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
RayIntersection() | vl::RayIntersection | [inline]
referenceCount() const | vl::Object | [inline]
setActor(Actor *a) | vl::RayIntersection | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDistance(float dist) | vl::RayIntersection | [inline]
setIntersectionPoint(const vec3 &v) | vl::RayIntersection | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RayIntersectionGeometry Member List

This is the complete list of members for vl::RayIntersectionGeometry, including all inherited members.

actor() const | vl::RayIntersection | [inline]
actor() | vl::RayIntersection | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RayIntersectionGeometry | [inline, virtual]
decReference() | vl::Object | [inline]
distance() const | vl::RayIntersection | [inline]
geometry() | vl::RayIntersectionGeometry | [inline]
geometry() const | vl::RayIntersectionGeometry | [inline]
incReference() | vl::Object | [inline]
intersectionPoint() const | vl::RayIntersection | [inline]
mActor | vl::RayIntersection | [protected]
mDistance | vl::RayIntersectionGeometry | [protected]
mGeometry | vl::RayIntersectionGeometry | [protected]
mIntersectionPoint | vl::RayIntersectionGeometry | [protected]
mName | vl::Object | [protected]
mPrimitiveIndex | vl::RayIntersectionGeometry | [protected]
mPrimitives | vl::RayIntersectionGeometry | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
primitiveIndex() const | vl::RayIntersectionGeometry | [inline]
primitives() | vl::RayIntersectionGeometry | [inline]
primitives() const | vl::RayIntersectionGeometry | [inline]
RayIntersection() | vl::RayIntersection | [inline]
RayIntersectionGeometry() | vl::RayIntersectionGeometry | [inline]
referenceCount() const | vl::Object | [inline]
setActor(Actor *a) | vl::RayIntersection | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDistance(float dist) | vl::RayIntersection | [inline]
setGeometry(Geometry *g) | vl::RayIntersectionGeometry | [inline]
setIntersectionPoint(const vec3 &v) | vl::RayIntersection | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPrimitiveIndex(int p_idx) | vl::RayIntersectionGeometry | [inline]
setPrimitives(Primitives *p) | vl::RayIntersectionGeometry | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RayIntersector Member List

This is the complete list of members for vl::RayIntersector, including all inherited members.

actors() const | vl::RayIntersector | [inline]
actors() | vl::RayIntersector | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RayIntersector | [inline, virtual]
decReference() | vl::Object | [inline]
frustum() const | vl::RayIntersector | [inline]
incReference() | vl::Object | [inline]
intersect() | vl::RayIntersector |
intersect(const Ray &ray, SceneManager *scene_manager) | vl::RayIntersector |
intersect(Actor *act) | vl::RayIntersector | [protected]
intersectGeometry(Actor *act, Geometry *geom) | vl::RayIntersector | [protected]
intersections() const | vl::RayIntersector | [inline]
intersectPolygon(const std::vector< fvec3 > &polygon, Actor *, Geometry *geom, Primitives *prim) | vl::RayIntersector | [protected]
intersectQuad(const fvec3 &a, const fvec3 &b, const fvec3 &c, const fvec3 &d, Actor *, Geometry *geom, Primitives *prim, int prim_idx) | vl::RayIntersector | [protected]
intersectTriangle(const fvec3 &a, const fvec3 &b, const fvec3 &c, Actor *, Geometry *geom, Primitives *prim, int prim_idx) | vl::RayIntersector | [protected]
mActors | vl::RayIntersector | [protected]
mFrustum | vl::RayIntersector | [protected]
mIntersections | vl::RayIntersector | [protected]
mName | vl::Object | [protected]
mRay | vl::RayIntersector | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
ray() const | vl::RayIntersector | [inline]
RayIntersector() | vl::RayIntersector | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setFrustum(const Frustum &frustum) | vl::RayIntersector | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRay(const Ray &ray) | vl::RayIntersector | [inline]
sorter(const ref< RayIntersection > a, const ref< RayIntersection > b) | vl::RayIntersector | [inline, protected, static]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::ReadPixels Member List

This is the complete list of members for vl::ReadPixels, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ReadPixels | [inline, virtual]
decReference() | vl::Object | [inline]
height() const | vl::ReadPixels | [inline]
image() | vl::ReadPixels | [inline]
image() const | vl::ReadPixels | [inline]
incReference() | vl::Object | [inline]
mHeight | vl::ReadPixels | [protected]
mImage | vl::ReadPixels | [protected]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mReadBuffer | vl::ReadPixels | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
mSavePath | vl::ReadPixels | [protected]
mStoreInPixelBufferObject | vl::ReadPixels | [protected]
mWidth | vl::ReadPixels | [protected]
mX | vl::ReadPixels | [protected]
mY | vl::ReadPixels | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readBuffer() const | vl::ReadPixels | [inline]
ReadPixels() | vl::ReadPixels | [inline]
ReadPixels(int x, int y, int width, int height, EReadDrawBuffer read_buffer, Image *image, bool store_in_pbo) | vl::ReadPixels | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *, ERenderingCallback reason) | vl::ReadPixels | [inline, virtual]
RenderingCallback() | vl::RenderingCallback | [inline]
savePath() const | vl::ReadPixels | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setHeight(int height) | vl::ReadPixels | [inline]
setImage(Image *image) | vl::ReadPixels | [inline]
setName(const std::string &name) | vl::Object | [inline]
setReadBuffer(EReadDrawBuffer buffer) | vl::ReadPixels | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
setSavePath(const String &path) | vl::ReadPixels | [inline]
setStoreInPixelBufferObject(bool use_pbo) | vl::ReadPixels | [inline]
setup(int x, int y, int width, int height, EReadDrawBuffer read_buffer, bool store_in_pbo) | vl::ReadPixels | [inline]
setWidth(int width) | vl::ReadPixels | [inline]
setX(int x) | vl::ReadPixels | [inline]
setY(int y) | vl::ReadPixels | [inline]
storeInPixelBufferObject() const | vl::ReadPixels | [inline]
width() const | vl::ReadPixels | [inline]
x() const | vl::ReadPixels | [inline]
y() const | vl::ReadPixels | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::Rect< T > Member List

This is the complete list of members for vl::Rect< T >, including all inherited members.

bottom() const | vl::Rect< T > | [inline]
className() | vl::Rect< T > | [inline, virtual]
height() const | vl::Rect< T > | [inline]
intersected(const Rect &other) const | vl::Rect< T > | [inline]
isNull() const | vl::Rect< T > | [inline]
isPoint() const | vl::Rect< T > | [inline]
left() const | vl::Rect< T > | [inline]
mHeight | vl::Rect< T > | [protected]
mWidth | vl::Rect< T > | [protected]
mX | vl::Rect< T > | [protected]
mY | vl::Rect< T > | [protected]
operator<(const Rect &other) const | vl::Rect< T > | [inline]
Rect(const Rect &other) | vl::Rect< T > | [inline]
Rect() | vl::Rect< T > | [inline]
Rect(T x, T y, T width, T height) | vl::Rect< T > | [inline]
right() const | vl::Rect< T > | [inline]
setHeight(T h) | vl::Rect< T > | [inline]
setWidth(T w) | vl::Rect< T > | [inline]
setX(T x) | vl::Rect< T > | [inline]
setY(T y) | vl::Rect< T > | [inline]
top() const | vl::Rect< T > | [inline]
united(const Rect &other) const | vl::Rect< T > | [inline]
width() const | vl::Rect< T > | [inline]
x() const | vl::Rect< T > | [inline]
y() const | vl::Rect< T > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RectF Member List

This is the complete list of members for vl::RectF, including all inherited members.

addPoint(const fvec2 &p) | vl::RectF | [inline]
bottom() const | vl::Rect< float > | [inline]
bottomLeft() const | vl::RectF | [inline]
className() | vl::RectF | [inline, virtual]
height() const | vl::Rect< float > | [inline]
intersected(const Rect &other) const | vl::Rect< float > | [inline]
isNull() const | vl::Rect< float > | [inline]
isPoint() const | vl::Rect< float > | [inline]
left() const | vl::Rect< float > | [inline]
mHeight | vl::Rect< float > | [protected]
mWidth | vl::Rect< float > | [protected]
mX | vl::Rect< float > | [protected]
mY | vl::Rect< float > | [protected]
operator<(const Rect &other) const | vl::Rect< float > | [inline]
operator=(const Rect< float > &other) | vl::RectF | [inline]
operator=(const RectF &other) | vl::RectF | [inline]
Rect(const Rect &other) | vl::Rect< float > | [inline]
Rect() | vl::Rect< float > | [inline]
Rect(floatx, floaty, floatwidth, floatheight) | vl::Rect< float > | [inline]
RectF() | vl::RectF | [inline]
RectF(float x, float y, float width, float height) | vl::RectF | [inline]
RectF(const RectF &other) | vl::RectF | [inline]
RectF(const Rect< float > &other) | vl::RectF | [inline]
right() const | vl::RectF | [inline]
setHeight(floath) | vl::Rect< float > | [inline]
setWidth(floatw) | vl::Rect< float > | [inline]
setX(floatx) | vl::Rect< float > | [inline]
setY(floaty) | vl::Rect< float > | [inline]
top() const | vl::RectF | [inline]
topRight() const | vl::RectF | [inline]
united(const Rect &other) const | vl::Rect< float > | [inline]
width() const | vl::Rect< float > | [inline]
x() const | vl::Rect< float > | [inline]
y() const | vl::Rect< float > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RectI Member List

This is the complete list of members for vl::RectI, including all inherited members.

bottom() const | vl::Rect< int > | [inline]
bottomLeft() const | vl::RectI | [inline]
className() | vl::RectI | [inline, virtual]
height() const | vl::Rect< int > | [inline]
intersected(const Rect &other) const | vl::Rect< int > | [inline]
isNull() const | vl::Rect< int > | [inline]
isPoint() const | vl::Rect< int > | [inline]
left() const | vl::Rect< int > | [inline]
mHeight | vl::Rect< int > | [protected]
mWidth | vl::Rect< int > | [protected]
mX | vl::Rect< int > | [protected]
mY | vl::Rect< int > | [protected]
operator<(const Rect &other) const | vl::Rect< int > | [inline]
operator=(const Rect< int > &other) | vl::RectI | [inline]
operator=(const RectI &other) | vl::RectI | [inline]
Rect(const Rect &other) | vl::Rect< int > | [inline]
Rect() | vl::Rect< int > | [inline]
Rect(intx, inty, intwidth, intheight) | vl::Rect< int > | [inline]
RectI() | vl::RectI | [inline]
RectI(int x, int y, int width, int height) | vl::RectI | [inline]
RectI(const Rect< int > &other) | vl::RectI | [inline]
RectI(const RectI &other) | vl::RectI | [inline]
right() const | vl::RectI | [inline]
setHeight(inth) | vl::Rect< int > | [inline]
setWidth(intw) | vl::Rect< int > | [inline]
setX(intx) | vl::Rect< int > | [inline]
setY(inty) | vl::Rect< int > | [inline]
top() const | vl::RectI | [inline]
topRight() const | vl::RectI | [inline]
united(const Rect &other) const | vl::Rect< int > | [inline]
width() const | vl::Rect< int > | [inline]
x() const | vl::Rect< int > | [inline]
y() const | vl::Rect< int > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RenderQueue Member List

This is the complete list of members for vl::RenderQueue, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
at(int i) const | vl::RenderQueue | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueue | [inline, virtual]
clear() | vl::RenderQueue | [inline]
decReference() | vl::Object | [inline]
empty() | vl::RenderQueue | [inline]
incReference() | vl::Object | [inline]
mList | vl::RenderQueue | [protected]
mListMP | vl::RenderQueue | [protected]
mName | vl::Object | [protected]
mSize | vl::RenderQueue | [protected]
mSizeMP | vl::RenderQueue | [protected]
name() const | vl::Object | [inline]
newToken(bool multipass) | vl::RenderQueue | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueue() | vl::RenderQueue | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
size() const | vl::RenderQueue | [inline]
sort(RenderQueueSorter *sorter, Camera *camera) | vl::RenderQueue | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorter Member List

This is the complete list of members for vl::RenderQueueSorter, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorter | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *) const =0 | vl::RenderQueueSorter | [pure virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mightNeedZCameraDistance() const =0 | vl::RenderQueueSorter | [pure virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const =0 | vl::RenderQueueSorter | [pure virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterAggressive Member List

This is the complete list of members for vl::RenderQueueSorterAggressive, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterAggressive | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *a) const | vl::RenderQueueSorterAggressive | [inline, virtual]
decReference() | vl::Object | [inline]
depthSortMode() const | vl::RenderQueueSorterAggressive | [inline]
incReference() | vl::Object | [inline]
mDepthSortMode | vl::RenderQueueSorterAggressive |
mightNeedZCameraDistance() const | vl::RenderQueueSorterAggressive | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterAggressive | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterAggressive() | vl::RenderQueueSorterAggressive | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDepthSortMode(EDepthSortMode mode) | vl::RenderQueueSorterAggressive | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterBasic Member List

This is the complete list of members for vl::RenderQueueSorterBasic, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterBasic | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *) const | vl::RenderQueueSorterBasic | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mightNeedZCameraDistance() const =0 | vl::RenderQueueSorter | [pure virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterBasic | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterBasic() | vl::RenderQueueSorterBasic | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterByRenderable Member List

This is the complete list of members for vl::RenderQueueSorterByRenderable, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterByRenderable | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *) const | vl::RenderQueueSorterByRenderable | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mightNeedZCameraDistance() const | vl::RenderQueueSorterByRenderable | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterByRenderable | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterByRenderable() | vl::RenderQueueSorterByRenderable | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterByShader Member List

This is the complete list of members for vl::RenderQueueSorterByShader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterByShader | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *) const | vl::RenderQueueSorterByShader | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mightNeedZCameraDistance() const | vl::RenderQueueSorterByShader | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterByShader | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterByShader() | vl::RenderQueueSorterByShader | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterOcclusion Member List

This is the complete list of members for vl::RenderQueueSorterOcclusion, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterOcclusion | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *) const | vl::RenderQueueSorterOcclusion | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mightNeedZCameraDistance() const | vl::RenderQueueSorterOcclusion | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterOcclusion | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterOcclusion() | vl::RenderQueueSorterOcclusion | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderQueueSorterStandard Member List

This is the complete list of members for vl::RenderQueueSorterStandard, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderQueueSorterStandard | [inline, virtual]
confirmZCameraDistanceNeed(const RenderToken *a) const | vl::RenderQueueSorterStandard | [inline, virtual]
decReference() | vl::Object | [inline]
depthSortMode() const | vl::RenderQueueSorterStandard | [inline]
incReference() | vl::Object | [inline]
mDepthSortMode | vl::RenderQueueSorterStandard |
mightNeedZCameraDistance() const | vl::RenderQueueSorterStandard | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const RenderToken *a, const RenderToken *b) const | vl::RenderQueueSorterStandard | [inline, virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderQueueSorter() | vl::RenderQueueSorter | [inline]
RenderQueueSorterStandard() | vl::RenderQueueSorterStandard | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDepthSortMode(EDepthSortMode mode) | vl::RenderQueueSorterStandard | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderState Member List

This is the complete list of members for vl::RenderState, including all inherited members.

apply(const Camera *) const =0 | vl::RenderState | [pure virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderState | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::RenderState | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderStateSet Member List

This is the complete list of members for vl::RenderStateSet, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderStateSet | [inline, virtual]
decReference() | vl::Object | [inline]
eraseAllRenderStates() | vl::RenderStateSet | [inline]
eraseRenderState(ERenderState type) | vl::RenderStateSet | [inline]
glslProgram() const | vl::RenderStateSet | [inline]
glslProgram() | vl::RenderStateSet | [inline]
incReference() | vl::Object | [inline]
mGLSLProgram | vl::RenderStateSet | [protected]
mName | vl::Object | [protected]
mRenderStates | vl::RenderStateSet | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderState(ERenderState type) | vl::RenderStateSet | [inline]
renderState(ERenderState type) const | vl::RenderStateSet | [inline]
renderStates() const | vl::RenderStateSet | [inline]
RenderStateSet() | vl::RenderStateSet | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRenderState(RenderState *renderstate) | vl::RenderStateSet | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::RenderTarget Member List

This is the complete list of members for vl::RenderTarget, including all inherited members.

activate() | vl::RenderTarget | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindDrawBuffers() const | vl::RenderTarget |
bindFramebuffer() | vl::RenderTarget | [inline, virtual]
checkDrawBuffers() const | vl::RenderTarget |
className() | vl::RenderTarget | [inline, protected, virtual]
decReference() | vl::Object | [inline]
height() const | vl::RenderTarget | [inline]
incReference() | vl::Object | [inline]
mDrawBuffers | vl::RenderTarget | [protected]
mHeight | vl::RenderTarget | [protected]
mName | vl::Object | [protected]
mOpenGLContext | vl::RenderTarget | [protected]
mWidth | vl::RenderTarget | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext class | vl::RenderTarget | [friend]
openglContext() | vl::RenderTarget | [inline]
openglContext() const | vl::RenderTarget | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderBuffers() | vl::RenderTarget | [inline]
RenderTarget(OpenGLContext *ctx, int w, int h) | vl::RenderTarget | [inline, protected]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3) | vl::RenderTarget | [inline]
setDrawBuffers(EReadDrawBuffer render_buffer1, EReadDrawBuffer render_buffer2, EReadDrawBuffer render_buffer3, EReadDrawBuffer render_buffer4) | vl::RenderTarget | [inline]
setDrawBuffers(const std::vector< EReadDrawBuffer > &render_buffers) | vl::RenderTarget | [inline]
setHeight(int height) | vl::RenderTarget | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWidth(int width) | vl::RenderTarget | [inline]
width() const | vl::RenderTarget | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::RenderToken Member List

This is the complete list of members for vl::RenderToken, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderToken | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mActor | vl::RenderToken |
mCameraDistance | vl::RenderToken |
mEffectRenderRank | vl::RenderToken |
mName | vl::Object | [protected]
mNextPass | vl::RenderToken |
mRenderable | vl::RenderToken |
mShader | vl::RenderToken |
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderToken() | vl::RenderToken | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::Renderable Member List

This is the complete list of members for vl::Renderable, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::Renderable | [inline, virtual]
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation()=0 | vl::Renderable | [protected, pure virtual]
decReference() | vl::Object | [inline]
deleteDisplayList() | vl::Renderable | [inline]
deleteVBOs() | vl::Renderable | [inline, virtual]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
incReference() | vl::Object | [inline]
lineCount() const | vl::Renderable | [inline, virtual]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointCount() const | vl::Renderable | [inline, virtual]
referenceCount() const | vl::Object | [inline]
render(const Actor *actor, const OpenGLContext *, const Camera *camera) const =0 | vl::Renderable | [pure virtual]
Renderable() | vl::Renderable | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setName(const std::string &name) | vl::Object | [inline]
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
triangleCount() const | vl::Renderable | [inline, virtual]
updateVBOs(bool) | vl::Renderable | [inline, virtual]
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::Renderer Member List

This is the complete list of members for vl::Renderer, including all inherited members.

applyEnables(const EnableSet *prev, const EnableSet *cur) | vl::Renderer |
applyRenderStates(const RenderStateSet *prev, const RenderStateSet *cur, const Camera *camera) | vl::Renderer |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Renderer | [inline, virtual]
collectStatistics() const | vl::Renderer | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mCollectStatistics | vl::Renderer | [protected]
mCurrentEnable | vl::Renderer | [protected]
mCurrentRenderState | vl::Renderer | [protected]
mCurrentUniform | vl::Renderer | [protected]
mDefaultRenderStates | vl::Renderer | [protected]
mEnableTable | vl::Renderer | [protected]
mName | vl::Object | [protected]
mOcclusionCullingEnabled | vl::Renderer | [protected]
mOcclusionQueryTick | vl::Renderer | [protected]
mOcclusionQueryTickPrev | vl::Renderer | [protected]
mOcclusionShader | vl::Renderer | [protected]
mOcclusionThreshold | vl::Renderer | [protected]
mOpenGLContext | vl::Renderer | [protected]
mRenderedLineCount | vl::Renderer | [protected]
mRenderedPointCount | vl::Renderer | [protected]
mRenderedRenderableCount | vl::Renderer | [protected]
mRenderedTriangleCount | vl::Renderer | [protected]
mRenderStateTable | vl::Renderer | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
occlusionCullingEnabled() const | vl::Renderer | [inline]
occlusionThreshold() const | vl::Renderer | [inline]
openglContext() const | vl::Renderer | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
render(const RenderQueue *render_queue, Camera *camera) | vl::Renderer | [virtual]
renderedLinesCount() const | vl::Renderer | [inline]
renderedPointsCount() const | vl::Renderer | [inline]
renderedRenderablesCount() const | vl::Renderer | [inline]
renderedTrianglesCount() const | vl::Renderer | [inline]
Renderer() | vl::Renderer |
resetEnables() | vl::Renderer |
resetRenderStates() | vl::Renderer |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCollectStatistics(bool on) | vl::Renderer | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOcclusionCullingEnabled(bool enabled) | vl::Renderer | [inline]
setOcclusionThreshold(int threshold) | vl::Renderer | [inline]
setOpenGLContext(const OpenGLContext *ogl_context) | vl::Renderer | [inline]
setupDefaultRenderStates() | vl::Renderer | [protected]
~Object() | vl::Object | [protected, virtual]
~Renderer() | vl::Renderer | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::Rendering Member List

This is the complete list of members for vl::Rendering, including all inherited members.

actorAnimationEnabled() const | vl::Rendering | [inline]
actorQueue() | vl::Rendering | [inline, protected]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
automaticResourceInit() const | vl::Rendering | [inline]
camera() const | vl::Rendering | [inline]
camera() | vl::Rendering | [inline]
className() | vl::Rendering | [inline, virtual]
clearFlags() const | vl::Rendering | [inline]
cullingEnabled() const | vl::Rendering | [inline]
decReference() | vl::Object | [inline]
dispatchRenderingCallbacks(ERenderingCallback reason) | vl::RenderingAbstract |
enableMask() const | vl::RenderingAbstract | [inline]
evaluateLOD() const | vl::Rendering | [inline]
fillRenderQueue(ActorCollection *actor_list) | vl::Rendering | [protected]
incReference() | vl::Object | [inline]
isEnabled(unsigned int mask) | vl::RenderingAbstract | [inline]
mActorAnimationEnabled | vl::Rendering | [protected]
mActorQueue | vl::Rendering | [protected]
mAutomaticResourceInit | vl::Rendering | [protected]
mCamera | vl::Rendering | [protected]
mClearFlags | vl::Rendering | [protected]
mCullingEnabled | vl::Rendering | [protected]
mEnableMask | vl::RenderingAbstract | [protected]
mEvaluateLOD | vl::Rendering | [protected]
mName | vl::Object | [protected]
mRenderer | vl::Rendering | [protected]
mRenderingCallbacks | vl::RenderingAbstract | [protected]
mRenderQueue | vl::Rendering | [protected]
mRenderQueueSorter | vl::Rendering | [protected]
mRenderTarget | vl::Rendering | [protected]
mSceneManagers | vl::Rendering | [protected]
mShaderAnimationEnabled | vl::Rendering | [protected]
mTransform | vl::Rendering | [protected]
mUpdateTime | vl::RenderingAbstract | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Rendering &other) | vl::Rendering |
vl::RenderingAbstract::operator=(const RenderingAbstract &other) | vl::RenderingAbstract |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
render() | vl::Rendering | [virtual]
renderer() const | vl::Rendering | [inline]
renderer() | vl::Rendering | [inline]
Rendering() | vl::Rendering |
Rendering(const Rendering &other) | vl::Rendering | [inline]
RenderingAbstract() | vl::RenderingAbstract |
renderingCallbacks() | vl::RenderingAbstract | [inline]
renderingCallbacks() const | vl::RenderingAbstract | [inline]
renderQueue() | vl::Rendering | [inline, protected]
renderQueueSorter() | vl::Rendering | [inline]
renderTarget() const | vl::Rendering | [inline]
renderTarget() | vl::Rendering | [inline]
resetStates() | vl::Rendering |
sceneManagers() | vl::Rendering | [inline]
sceneManagers() const | vl::Rendering | [inline]
setActorAnimationEnabled(bool animate_actors) | vl::Rendering | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setAutomaticResourceInit(bool enable) | vl::Rendering | [inline]
setCamera(Camera *camera) | vl::Rendering | [inline]
setClearFlags(EClearFlags clear_flags) | vl::Rendering | [inline]
setCullingEnabled(bool enabled) | vl::Rendering | [inline]
setEnableMask(unsigned int mask) | vl::RenderingAbstract | [inline]
setEvaluateLOD(bool evaluate_lod) | vl::Rendering | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRenderer(Renderer *renderer) | vl::Rendering | [inline]
setRenderQueueSorter(RenderQueueSorter *render_queue_sorter) | vl::Rendering | [inline]
setRenderTarget(RenderTarget *render_target) | vl::Rendering | [inline]
setShaderAnimationEnabled(bool animate_shaders) | vl::Rendering | [inline]
setTransform(Transform *transform) | vl::Rendering | [inline]
setUpdateTime(Real cur_time) | vl::RenderingAbstract | [inline]
shaderAnimationEnabled() const | vl::Rendering | [inline]
transform() const | vl::Rendering | [inline]
transform() | vl::Rendering | [inline]
updateTime() const | vl::RenderingAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RenderingAbstract Member List

This is the complete list of members for vl::RenderingAbstract, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
dispatchRenderingCallbacks(ERenderingCallback reason) | vl::RenderingAbstract |
enableMask() const | vl::RenderingAbstract | [inline]
incReference() | vl::Object | [inline]
isEnabled(unsigned int mask) | vl::RenderingAbstract | [inline]
mEnableMask | vl::RenderingAbstract | [protected]
mName | vl::Object | [protected]
mRenderingCallbacks | vl::RenderingAbstract | [protected]
mUpdateTime | vl::RenderingAbstract | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const RenderingAbstract &other) | vl::RenderingAbstract |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
render()=0 | vl::RenderingAbstract | [pure virtual]
RenderingAbstract() | vl::RenderingAbstract |
renderingCallbacks() | vl::RenderingAbstract | [inline]
renderingCallbacks() const | vl::RenderingAbstract | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnableMask(unsigned int mask) | vl::RenderingAbstract | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUpdateTime(Real cur_time) | vl::RenderingAbstract | [inline]
updateTime() const | vl::RenderingAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RenderingCallback Member List

This is the complete list of members for vl::RenderingCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderingCallback | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mRank | vl::RenderingCallback | [protected]
mRemoveAfterCall | vl::RenderingCallback | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
removeAfterCall() const | vl::RenderingCallback | [inline]
RenderingCallback() | vl::RenderingCallback | [inline]
renderingCallback(const RenderingAbstract *rendering, ERenderingCallback reason)=0 | vl::RenderingCallback | [pure virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRemoveAfterCall(bool remove) | vl::RenderingCallback | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::RenderingTree Member List

This is the complete list of members for vl::RenderingTree, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::RenderingTree | [inline, virtual]
decReference() | vl::Object | [inline]
dispatchRenderingCallbacks(ERenderingCallback reason) | vl::RenderingAbstract |
enableMask() const | vl::RenderingAbstract | [inline]
incReference() | vl::Object | [inline]
isEnabled(unsigned int mask) | vl::RenderingAbstract | [inline]
mEnableMask | vl::RenderingAbstract | [protected]
mName | vl::Object | [protected]
mRenderingCallbacks | vl::RenderingAbstract | [protected]
mSubRendering | vl::RenderingTree | [protected]
mUpdateTime | vl::RenderingAbstract | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const RenderingTree &other) | vl::RenderingTree |
vl::RenderingAbstract::operator=(const RenderingAbstract &other) | vl::RenderingAbstract |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
render() | vl::RenderingTree | [virtual]
RenderingAbstract() | vl::RenderingAbstract |
renderingCallbacks() | vl::RenderingAbstract | [inline]
renderingCallbacks() const | vl::RenderingAbstract | [inline]
RenderingTree() | vl::RenderingTree |
RenderingTree(const RenderingTree &other) | vl::RenderingTree | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnableMask(unsigned int mask) | vl::RenderingAbstract | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUpdateTime(Real cur_time) | vl::RenderingAbstract | [inline]
subRenderings() | vl::RenderingTree | [inline]
subRenderings() const | vl::RenderingTree | [inline]
updateTime() const | vl::RenderingAbstract | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::ResourceDatabase Member List

This is the complete list of members for vl::ResourceDatabase, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ResourceDatabase | [inline, virtual]
count() const | vl::ResourceDatabase | [inline]
decReference() | vl::Object | [inline]
extract(std::vector< ref< T > > &resources, bool clear_vector=true) | vl::ResourceDatabase | [inline]
get(int j) const | vl::ResourceDatabase | [inline]
get(std::vector< ref< T > > &resources, bool clear_vector=true) | vl::ResourceDatabase | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mResources | vl::ResourceDatabase | [protected]
name() const | vl::Object | [inline]
next(int &cur_pos) const | vl::ResourceDatabase | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
resources() const | vl::ResourceDatabase | [inline]
resources() | vl::ResourceDatabase | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::ResourceLoadWriter Member List

This is the complete list of members for vl::ResourceLoadWriter, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
canLoad(const String &extension) const | vl::ResourceLoadWriter | [inline]
canWrite(const String &extension) const | vl::ResourceLoadWriter | [inline]
className() | vl::ResourceLoadWriter | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
loadExtensions() const | vl::ResourceLoadWriter | [inline]
loadResource(const String &path) const =0 | vl::ResourceLoadWriter | [pure virtual]
loadResource(VirtualFile *file) const =0 | vl::ResourceLoadWriter | [pure virtual]
mLoadExtensions | vl::ResourceLoadWriter | [protected]
mName | vl::Object | [protected]
mWriteExtensions | vl::ResourceLoadWriter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
ResourceLoadWriter(const String &load_extensions, const String &write_extensions) | vl::ResourceLoadWriter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLoadExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWriteExtensions(const String &extensions) | vl::ResourceLoadWriter | [inline]
writeExtensions() const | vl::ResourceLoadWriter | [inline]
writeResource(const String &path, ResourceDatabase *resource) const =0 | vl::ResourceLoadWriter | [pure virtual]
writeResource(VirtualFile *file, ResourceDatabase *resource) const =0 | vl::ResourceLoadWriter | [pure virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::STLLoader Member List

This is the complete list of members for vl::STLLoader, including all inherited members.

className() | vl::STLLoader | [inline, virtual]
loadAscii(VirtualFile *file) | vl::STLLoader |
loadBinary(VirtualFile *file) | vl::STLLoader |
loadSTL(VirtualFile *file) | vl::STLLoader |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:21 2009.


Visualization Library: Member List

vl::SampleCoverage Member List

This is the complete list of members for vl::SampleCoverage, including all inherited members.

apply(const Camera *) const | vl::SampleCoverage | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::SampleCoverage | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
invert() const | vl::SampleCoverage | [inline]
mInvert | vl::SampleCoverage | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
mValue | vl::SampleCoverage | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
SampleCoverage(GLclampf value=1.0f, bool invert=false) | vl::SampleCoverage | [inline]
set(GLclampf value, bool invert) | vl::SampleCoverage | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInvert(bool invert) | vl::SampleCoverage | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
setValue(GLclampf value) | vl::SampleCoverage | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::SampleCoverage | [inline, virtual]
value() const | vl::SampleCoverage | [inline]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Say Member List

This is the complete list of members for vl::Say, including all inherited members.

euronotation(const String &str, int base) const | vl::Say | [protected]
format(unsigned long long n, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const | vl::Say | [protected]
format(signed long long nn, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const | vl::Say | [protected]
format(double num, int base, int field, int decimals, int align, unsigned short fill, int plus, int finalizer, int eur) const | vl::Say | [protected]
format_string | vl::Say |
operator String() | vl::Say | [inline]
operator<<(const SayArg &p) | vl::Say | [inline]
operator<<(T p) | vl::Say | [inline]
parse(const Say &pset) const | vl::Say | [protected]
pipeline(const String &str, int base, int field, int decimals, int finalizer, int align, int eur, unsigned short fill, int negative, int plus) const | vl::Say | [protected]
Say(const String &fstr) | vl::Say | [inline]
str() const | vl::Say | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SayArg Member List

This is the complete list of members for vl::SayArg, including all inherited members.

float64 | vl::SayArg | [protected]
FLOAT64 enum value | vl::SayArg | [protected]
init() | vl::SayArg | [protected]
NO_TYPE enum value | vl::SayArg | [protected]
Say class | vl::SayArg | [friend]
SayArg() | vl::SayArg |
SayArg(const unsigned char *d) | vl::SayArg | [explicit]
SayArg(const std::string &d) | vl::SayArg | [explicit]
SayArg(const char *d) | vl::SayArg | [explicit]
SayArg(void *d) | vl::SayArg | [explicit]
SayArg(const String &d) | vl::SayArg | [explicit]
SayArg(double d) | vl::SayArg | [explicit]
SayArg(float d) | vl::SayArg | [explicit]
SayArg(unsigned char d) | vl::SayArg | [explicit]
SayArg(signed char d) | vl::SayArg | [explicit]
SayArg(unsigned short d) | vl::SayArg | [explicit]
SayArg(signed short d) | vl::SayArg | [explicit]
SayArg(unsigned int d) | vl::SayArg | [explicit]
SayArg(signed int d) | vl::SayArg | [explicit]
SayArg(unsigned long d) | vl::SayArg | [explicit]
SayArg(signed long d) | vl::SayArg | [explicit]
SayArg(unsigned long long d) | vl::SayArg | [explicit]
SayArg(signed long long d) | vl::SayArg | [explicit]
SLONGLONG enum value | vl::SayArg | [protected]
slonglong | vl::SayArg | [protected]
str | vl::SayArg | [protected]
STRING enum value | vl::SayArg | [protected]
type | vl::SayArg | [protected]
ulonglong | vl::SayArg | [protected]
ULONGLONG enum value | vl::SayArg | [protected]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SceneManager Member List

This is the complete list of members for vl::SceneManager, including all inherited members.

appendActors(ActorCollection &list)=0 | vl::SceneManager | [pure virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera)=0 | vl::SceneManager | [pure virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vl::SceneManager | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
incReference() | vl::Object | [inline]
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mName | vl::Object | [protected]
mSphere | vl::SceneManager | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SceneManagerActorKdTree Member List

This is the complete list of members for vl::SceneManagerActorKdTree, including all inherited members.

appendActors(ActorCollection &list) | vl::SceneManagerBVH< ActorKdTree > | [inline, virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera) | vl::SceneManagerBVH< ActorKdTree > | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vl::SceneManagerActorKdTree | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
incReference() | vl::Object | [inline]
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundingVolumeTree | vl::SceneManagerBVH< ActorKdTree > | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mName | vl::Object | [protected]
mSphere | vl::SceneManager | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
SceneManagerActorKdTree() | vl::SceneManagerActorKdTree | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTree(ActorKdTree *bbh) | vl::SceneManagerBVH< ActorKdTree > | [inline]
tree() const | vl::SceneManagerBVH< ActorKdTree > | [inline]
tree() | vl::SceneManagerBVH< ActorKdTree > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SceneManagerActorTree Member List

This is the complete list of members for vl::SceneManagerActorTree, including all inherited members.

appendActors(ActorCollection &list) | vl::SceneManagerBVH< ActorTree > | [inline, virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera) | vl::SceneManagerBVH< ActorTree > | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vl::SceneManagerActorTree | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
incReference() | vl::Object | [inline]
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundingVolumeTree | vl::SceneManagerBVH< ActorTree > | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mName | vl::Object | [protected]
mSphere | vl::SceneManager | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
SceneManagerActorTree() | vl::SceneManagerActorTree | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTree(ActorTree *bbh) | vl::SceneManagerBVH< ActorTree > | [inline]
tree() const | vl::SceneManagerBVH< ActorTree > | [inline]
tree() | vl::SceneManagerBVH< ActorTree > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SceneManagerBVH< T > Member List

This is the complete list of members for vl::SceneManagerBVH< T >, including all inherited members.

appendActors(ActorCollection &list) | vl::SceneManagerBVH< T > | [inline, virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera) | vl::SceneManagerBVH< T > | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vl::SceneManagerBVH< T > | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
incReference() | vl::Object | [inline]
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundingVolumeTree | vl::SceneManagerBVH< T > | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mName | vl::Object | [protected]
mSphere | vl::SceneManager | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTree(T *bbh) | vl::SceneManagerBVH< T > | [inline]
tree() const | vl::SceneManagerBVH< T > | [inline]
tree() | vl::SceneManagerBVH< T > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::SceneManagerPortals Member List

This is the complete list of members for vl::SceneManagerPortals, including all inherited members.

appendActors(ActorCollection &list) | vl::SceneManagerPortals | [virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera) | vl::SceneManagerPortals | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vl::SceneManager | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
computePortalNormals() | vl::SceneManagerPortals |
computeStartingSector(const Camera *camera) | vl::SceneManagerPortals | [protected]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
externalSector() | vl::SceneManagerPortals | [inline]
externalSector() const | vl::SceneManagerPortals | [inline]
frustumStack() const | vl::SceneManagerPortals | [inline]
incReference() | vl::Object | [inline]
initialize() | vl::SceneManagerPortals |
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mExternalSector | vl::SceneManagerPortals | [protected]
mFrustumStack | vl::SceneManagerPortals | [protected]
mName | vl::Object | [protected]
mPortalActorMap | vl::SceneManagerPortals | [protected]
mSectors | vl::SceneManagerPortals | [protected]
mShowPortals | vl::SceneManagerPortals | [protected]
mSphere | vl::SceneManager | [protected]
mTempActors | vl::SceneManagerPortals | [protected]
mVisitTick | vl::SceneManagerPortals | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderPortal(Portal *portal) | vl::SceneManagerPortals | [protected]
SceneManager() | vl::SceneManager |
SceneManagerPortals() | vl::SceneManagerPortals | [inline]
sectors() | vl::SceneManagerPortals | [inline]
sectors() const | vl::SceneManagerPortals | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
setShowPortals(bool show) | vl::SceneManagerPortals | [inline]
showPortals() const | vl::SceneManagerPortals | [inline]
visitSector(Sector *prev, Sector *sector, const vec3 &eye, const Camera *camera) | vl::SceneManagerPortals | [protected]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::Scissor Member List

This is the complete list of members for vl::Scissor, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Scissor | [inline, virtual]
decReference() | vl::Object | [inline]
disable() | vl::Scissor | [inline]
enable(const Viewport *viewport) const | vl::Scissor | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mScissor | vl::Scissor | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator<(const Scissor &other) const | vl::Scissor | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
Scissor(int x, int y, int width, int height) | vl::Scissor | [inline]
scissorRect() const | vl::Scissor | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setScissor(int x, int y, int width, int height) | vl::Scissor | [inline]
setScissor(const RectI &scissor) | vl::Scissor | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::Sector Member List

This is the complete list of members for vl::Sector, including all inherited members.

actors() | vl::Sector | [inline]
actors() const | vl::Sector | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
callbacks() | vl::Sector | [inline]
callbacks() const | vl::Sector | [inline]
className() | vl::Object | [inline, virtual]
computeBoundingBox() | vl::Sector |
decReference() | vl::Object | [inline]
executeCallbacks(const Camera *cam, SceneManagerPortals *psm, Portal *p) | vl::Sector |
incReference() | vl::Object | [inline]
mActors | vl::Sector | [protected]
mCallbacks | vl::Sector | [protected]
mName | vl::Object | [protected]
mPortals | vl::Sector | [protected]
mVolumes | vl::Sector | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
portals() | vl::Sector | [inline]
portals() const | vl::Sector | [inline]
referenceCount() const | vl::Object | [inline]
Sector() | vl::Sector | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
volumes() | vl::Sector | [inline]
volumes() const | vl::Sector | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::Sector::VisibilityCallback Member List

This is the complete list of members for vl::Sector::VisibilityCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(const Camera *cam, SceneManagerPortals *psm, Sector *s, Portal *p)=0 | vl::Sector::VisibilityCallback | [pure virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:14 2009.


Visualization Library: Member List

vl::ShadeModel Member List

This is the complete list of members for vl::ShadeModel, including all inherited members.

apply(const Camera *) const | vl::ShadeModel | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ShadeModel | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mName | vl::Object | [protected]
mShadeModel | vl::ShadeModel | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EShadeModel shademodel) | vl::ShadeModel | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
ShadeModel(EShadeModel shademodel=SM_SMOOTH) | vl::ShadeModel | [inline]
shadeModel() const | vl::ShadeModel | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::ShadeModel | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::Shader Member List

This is the complete list of members for vl::Shader, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
blendingEnabled() const | vl::Shader | [inline]
className() | vl::Shader | [inline, virtual]
decReference() | vl::Object | [inline]
disable(EEnable capability) | vl::Shader | [inline]
disableAll() | vl::Shader | [inline]
enable(EEnable capability) | vl::Shader | [inline]
enables() const | vl::Shader | [inline]
eraseAllRenderStates() | vl::Shader | [inline]
eraseAllUniforms() | vl::Shader | [inline]
eraseRenderState(ERenderState type) | vl::Shader | [inline]
eraseRenderState(RenderState *rs) | vl::Shader | [inline]
eraseUniform(const std::string &name) | vl::Shader | [inline]
eraseUniform(const Uniform *uniform) | vl::Shader | [inline]
getAlphaFunc() const | vl::Shader | [inline]
getAlphaFunc() | vl::Shader | [inline]
getBlendColor() const | vl::Shader | [inline]
getBlendColor() | vl::Shader | [inline]
getBlendEquation() const | vl::Shader | [inline]
getBlendEquation() | vl::Shader | [inline]
getBlendFunc() const | vl::Shader | [inline]
getBlendFunc() | vl::Shader | [inline]
getClipPlane(int plane_index) const | vl::Shader | [inline]
getClipPlane(int plane_index) | vl::Shader | [inline]
getColorMask() const | vl::Shader | [inline]
getColorMask() | vl::Shader | [inline]
getCullFace() const | vl::Shader | [inline]
getCullFace() | vl::Shader | [inline]
getDepthFunc() const | vl::Shader | [inline]
getDepthFunc() | vl::Shader | [inline]
getDepthMask() const | vl::Shader | [inline]
getDepthMask() | vl::Shader | [inline]
getDepthRange() const | vl::Shader | [inline]
getDepthRange() | vl::Shader | [inline]
getEnableSet() | vl::Shader | [inline]
getEnableSet() const | vl::Shader | [inline]
getFog() const | vl::Shader | [inline]
getFog() | vl::Shader | [inline]
getFrontFace() const | vl::Shader | [inline]
getFrontFace() | vl::Shader | [inline]
getGLSLProgram() const | vl::Shader | [inline]
getGLSLProgram() | vl::Shader | [inline]
getHint() const | vl::Shader | [inline]
getHint() | vl::Shader | [inline]
getLight(int light_index) const | vl::Shader | [inline]
getLight(int light_index) | vl::Shader | [inline]
getLightModel() const | vl::Shader | [inline]
getLightModel() | vl::Shader | [inline]
getLineStipple() const | vl::Shader | [inline]
getLineStipple() | vl::Shader | [inline]
getLineWidth() const | vl::Shader | [inline]
getLineWidth() | vl::Shader | [inline]
getLogicOp() const | vl::Shader | [inline]
getLogicOp() | vl::Shader | [inline]
getMaterial() const | vl::Shader | [inline]
getMaterial() | vl::Shader | [inline]
getPixelTransfer() const | vl::Shader | [inline]
getPixelTransfer() | vl::Shader | [inline]
getPointParameter() const | vl::Shader | [inline]
getPointParameter() | vl::Shader | [inline]
getPointSize() const | vl::Shader | [inline]
getPointSize() | vl::Shader | [inline]
getPolygonMode() const | vl::Shader | [inline]
getPolygonMode() | vl::Shader | [inline]
getPolygonOffset() const | vl::Shader | [inline]
getPolygonOffset() | vl::Shader | [inline]
getPolygonStipple() const | vl::Shader | [inline]
getPolygonStipple() | vl::Shader | [inline]
getRenderStateSet() | vl::Shader | [inline]
getRenderStateSet() const | vl::Shader | [inline]
getSampleCoverage() const | vl::Shader | [inline]
getSampleCoverage() | vl::Shader | [inline]
getShadeModel() const | vl::Shader | [inline]
getShadeModel() | vl::Shader | [inline]
getStencilFunc() const | vl::Shader | [inline]
getStencilFunc() | vl::Shader | [inline]
getStencilMask() const | vl::Shader | [inline]
getStencilMask() | vl::Shader | [inline]
getStencilOp() const | vl::Shader | [inline]
getStencilOp() | vl::Shader | [inline]
getTexEnv(int unit_index) const | vl::Shader | [inline]
getTexEnv(int unit_index) | vl::Shader | [inline]
getTexGen(int unit_index) const | vl::Shader | [inline]
getTexGen(int unit_index) | vl::Shader | [inline]
getTextureMatrix(int unit_index) const | vl::Shader | [inline]
getTextureMatrix(int unit_index) | vl::Shader | [inline]
getTextureUnit(int unit_index) const | vl::Shader | [inline]
getTextureUnit(int unit_index) | vl::Shader | [inline]
getUniform(const std::string &name) | vl::Shader | [inline]
getUniform(const std::string &name) const | vl::Shader | [inline]
getUniformSet() | vl::Shader | [inline]
getUniformSet() const | vl::Shader | [inline]
glslProgram() const | vl::Shader | [inline]
glslProgram() | vl::Shader | [inline]
gocAlphaFunc() | vl::Shader |
gocBlendColor() | vl::Shader |
gocBlendEquation() | vl::Shader |
gocBlendFunc() | vl::Shader |
gocClipPlane(int plane_index) | vl::Shader |
gocColorMask() | vl::Shader |
gocCullFace() | vl::Shader |
gocDepthFunc() | vl::Shader |
gocDepthMask() | vl::Shader |
gocDepthRange() | vl::Shader |
gocEnableSet() | vl::Shader | [inline]
gocFog() | vl::Shader |
gocFrontFace() | vl::Shader |
gocGLSLProgram() | vl::Shader |
gocHint() | vl::Shader |
gocLight(int light_index) | vl::Shader |
gocLightModel() | vl::Shader |
gocLineStipple() | vl::Shader |
gocLineWidth() | vl::Shader |
gocLogicOp() | vl::Shader |
gocMaterial() | vl::Shader |
gocPixelTransfer() | vl::Shader |
gocPointParameter() | vl::Shader |
gocPointSize() | vl::Shader |
gocPolygonMode() | vl::Shader |
gocPolygonOffset() | vl::Shader |
gocPolygonStipple() | vl::Shader |
gocRenderStateSet() | vl::Shader | [inline]
gocSampleCoverage() | vl::Shader |
gocShadeModel() | vl::Shader |
gocStencilFunc() | vl::Shader |
gocStencilMask() | vl::Shader |
gocStencilOp() | vl::Shader |
gocTexEnv(int unit_index) | vl::Shader |
gocTexGen(int unit_index) | vl::Shader |
gocTextureMatrix(int unit_index) | vl::Shader |
gocTextureUnit(int unit_index) | vl::Shader |
gocUniform(const std::string &name) | vl::Shader | [inline]
gocUniformSet() | vl::Shader | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::Shader | [inline]
isEnabled(EEnable capability) const | vl::Shader | [inline]
lastUpdateTime() const | vl::Shader | [inline]
mEnableSet | vl::Shader | [protected]
mLastUpdateTime | vl::Shader | [protected]
mName | vl::Object | [protected]
mRenderStateSet | vl::Shader | [protected]
mScissor | vl::Shader | [protected]
mUniformSet | vl::Shader | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderState(ERenderState type) const | vl::Shader | [inline]
renderState(ERenderState type) | vl::Shader | [inline]
renderStates() const | vl::Shader | [inline]
reset() | vl::Shader | [inline]
scissor() const | vl::Shader | [inline]
scissor() | vl::Shader | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnableSet(EnableSet *es) | vl::Shader | [inline]
setLastUpdateTime(Real time) | vl::Shader | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRenderState(RenderState *renderstate) | vl::Shader | [inline]
setRenderStateSet(RenderStateSet *rss) | vl::Shader | [inline]
setScissor(Scissor *scissor) | vl::Shader | [inline]
setUniform(Uniform *uniform) | vl::Shader | [inline]
setUniformSet(UniformSet *us) | vl::Shader | [inline]
Shader() | vl::Shader |
uniforms() const | vl::Shader | [inline]
update(Camera *, Real) | vl::Shader | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~Shader() | vl::Shader | [virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::ShaderNode Member List

This is the complete list of members for vl::ShaderNode, including all inherited members.

addChild(ShaderNode *node) | vl::ShaderNode | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
child(unsigned i) | vl::ShaderNode | [inline]
child(unsigned i) const | vl::ShaderNode | [inline]
childrenCount() const | vl::ShaderNode | [inline]
className() | vl::ShaderNode | [inline, virtual]
decReference() | vl::Object | [inline]
eraseChild(ShaderNode *node) | vl::ShaderNode | [inline]
eraseChild(unsigned index) | vl::ShaderNode | [inline]
eraseChildren(unsigned start, unsigned count) | vl::ShaderNode | [inline]
eraseEnable(EEnable en) | vl::ShaderNode | [inline]
eraseRenderState(RenderState *rs) | vl::ShaderNode | [inline]
eraseUniform(Uniform *unif) | vl::ShaderNode | [inline]
findChild(const ShaderNode *node) const | vl::ShaderNode | [inline]
incReference() | vl::Object | [inline]
inherit(ShaderNode *parent) | vl::ShaderNode | [inline]
mEnables | vl::ShaderNode | [protected]
mEnables_Final | vl::ShaderNode | [protected]
mName | vl::Object | [protected]
mNodes | vl::ShaderNode | [protected]
mParent | vl::ShaderNode | [protected]
mRenderStates | vl::ShaderNode | [protected]
mRenderStates_Final | vl::ShaderNode | [protected]
mShader | vl::ShaderNode | [protected]
mUniforms | vl::ShaderNode | [protected]
mUniforms_Final | vl::ShaderNode | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() | vl::ShaderNode | [inline]
parent() const | vl::ShaderNode | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnable(EEnable en, bool on, EInheritance inheritance=IN_Propagate) | vl::ShaderNode | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRenderState(RenderState *rs, EInheritance inheritance=IN_Propagate) | vl::ShaderNode | [inline]
setShader(Shader *shader) | vl::ShaderNode | [inline]
setUniform(Uniform *unif, EInheritance inheritance=IN_Propagate) | vl::ShaderNode | [inline]
shader() const | vl::ShaderNode | [inline]
shader() | vl::ShaderNode | [inline]
ShaderNode() | vl::ShaderNode | [inline]
updateHierachy() | vl::ShaderNode | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: Member List

vl::ShaderSequence Member List

This is the complete list of members for vl::ShaderSequence, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
at(int i) const | vl::Collection< Shader > | [inline]
at(int i) | vl::Collection< Shader > | [inline]
automaticDelete() const | vl::Object | [inline]
back() const | vl::Collection< Shader > | [inline]
back() | vl::Collection< Shader > | [inline]
capacity() const | vl::Collection< Shader > | [inline]
className() | vl::ShaderSequence | [inline, virtual]
clear() | vl::Collection< Shader > | [inline]
Collection(const std::vector< ref< Shader > > &vector) | vl::Collection< Shader > | [inline]
Collection() | vl::Collection< Shader > | [inline]
decReference() | vl::Object | [inline]
empty() const | vl::Collection< Shader > | [inline]
erase(int start, int count) | vl::Collection< Shader > | [inline]
erase(const Shader *data) | vl::Collection< Shader > | [inline]
eraseAt(int index) | vl::Collection< Shader > | [inline]
find(Shader *obj) const | vl::Collection< Shader > | [inline]
incReference() | vl::Object | [inline]
insert(int start, const Collection< Shader > &objs) | vl::Collection< Shader > | [inline]
insert(int index, Shader *obj) | vl::Collection< Shader > | [inline]
less(const ref< Shader > &a, const ref< Shader > &b) | vl::Collection< Shader > | [inline, protected, static]
mName | vl::Object | [protected]
mVector | vl::Collection< Shader > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator std::vector< ref< Shader > >() const | vl::Collection< Shader > | [inline]
operator=(const std::vector< ref< Shader > > &vector) | vl::Collection< Shader > | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
operator[](int i) const | vl::Collection< Shader > | [inline]
operator[](int i) | vl::Collection< Shader > | [inline]
pop_back() | vl::Collection< Shader > | [inline]
push_back(Shader *data) | vl::Collection< Shader > | [inline]
push_back(const Collection< Shader > &objs) | vl::Collection< Shader > | [inline]
referenceCount() const | vl::Object | [inline]
reserve(int capacity) | vl::Collection< Shader > | [inline]
resize(int size) | vl::Collection< Shader > | [inline]
set(const Collection< Shader > &objs) | vl::Collection< Shader > | [inline]
set(int index, Shader *obj) | vl::Collection< Shader > | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
ShaderSequence(Shader *pass1=NULL, Shader *pass2=NULL, Shader *pass3=NULL, Shader *pass4=NULL) | vl::ShaderSequence | [inline]
shrink() | vl::Collection< Shader > | [inline]
size() const | vl::Collection< Shader > | [inline]
sort() | vl::Collection< Shader > | [inline]
swap(Collection &other) | vl::Collection< Shader > | [inline]
vector() const | vl::Collection< Shader > | [inline]
vector() | vl::Collection< Shader > | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:10 2009.


Visualization Library: Member List

vl::Sphere Member List

This is the complete list of members for vl::Sphere, including all inherited members.

center() const | vl::Sphere | [inline]
includes(const Sphere &other) const | vl::Sphere | [inline]
isNull() const | vl::Sphere | [inline]
isPoint() const | vl::Sphere | [inline]
mCenter | vl::Sphere | [protected]
mRadius | vl::Sphere | [protected]
operator+(const Sphere &other) | vl::Sphere | [inline]
operator+=(const Sphere &other) | vl::Sphere | [inline]
operator=(const AABB &aabb) | vl::Sphere | [inline]
radius() const | vl::Sphere | [inline]
setCenter(const vec3 &center) | vl::Sphere | [inline]
setNull() | vl::Sphere | [inline]
setPoint() | vl::Sphere | [inline]
setRadius(Real radius) | vl::Sphere | [inline]
Sphere() | vl::Sphere | [inline]
Sphere(const AABB &aabb) | vl::Sphere | [inline]
transformed(Sphere &sphere, const mat4 &mat) const | vl::Sphere | [inline]
transformed(const mat4 &mat) const | vl::Sphere | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: Member List

vl::StandardLog Member List

This is the complete list of members for vl::StandardLog, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bug(const String &log) | vl::Log | [static]
className() | vl::StandardLog | [inline, virtual]
debug(const String &log) | vl::Log | [static]
decReference() | vl::Object | [inline]
error(const String &log) | vl::Log | [static]
incReference() | vl::Object | [inline]
info(const String &log) | vl::Log | [static]
Log() | vl::Log | [inline]
logFile() const | vl::StandardLog | [inline]
logger() | vl::Log | [inline, static]
mLogFile | vl::StandardLog | [protected]
mLogger | vl::Log | [protected, static]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
print(ELogLevel level, const String &log) | vl::Log | [static]
print(const String &log) | vl::Log | [static]
printImplementation(ELogLevel level, const String &log) | vl::StandardLog | [protected, virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLogFile(const String &file) | vl::StandardLog | [inline]
setLogger(Log *logger) | vl::Log | [inline, static]
setName(const std::string &name) | vl::Object | [inline]
warning(const String &log) | vl::Log | [static]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vl::StencilFunc Member List

This is the complete list of members for vl::StencilFunc, including all inherited members.

apply(const Camera *) const | vl::StencilFunc | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::StencilFunc | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
function_Back() const | vl::StencilFunc | [inline]
function_Front() const | vl::StencilFunc | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mask_Back() const | vl::StencilFunc | [inline]
mask_Front() const | vl::StencilFunc | [inline]
mFunction_Back | vl::StencilFunc | [protected]
mFunction_Front | vl::StencilFunc | [protected]
mMask_Back | vl::StencilFunc | [protected]
mMask_Front | vl::StencilFunc | [protected]
mName | vl::Object | [protected]
mRefValue_Back | vl::StencilFunc | [protected]
mRefValue_Front | vl::StencilFunc | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
refValue_Back() const | vl::StencilFunc | [inline]
refValue_Front() const | vl::StencilFunc | [inline]
RenderState() | vl::RenderState | [inline]
set(EPolygonFace face, EFunction function, int refvalue, unsigned int mask) | vl::StencilFunc | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
StencilFunc(EFunction function=FU_ALWAYS, int refvalue=0, unsigned int mask=~(unsigned int) 0) | vl::StencilFunc | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::StencilFunc | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::StencilMask Member List

This is the complete list of members for vl::StencilMask, including all inherited members.

apply(const Camera *) const | vl::StencilMask | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::StencilMask | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mask_Back() const | vl::StencilMask | [inline]
mask_Front() const | vl::StencilMask | [inline]
mMask_Back | vl::StencilMask | [protected]
mMask_Front | vl::StencilMask | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EPolygonFace face, unsigned int mask) | vl::StencilMask | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
StencilMask(unsigned int mask=~(unsigned int) 0) | vl::StencilMask | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::StencilMask | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::StencilOp Member List

This is the complete list of members for vl::StencilOp, including all inherited members.

apply(const Camera *) const | vl::StencilOp | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::StencilOp | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
dpFail_Back() const | vl::StencilOp | [inline]
dpFail_Front() const | vl::StencilOp | [inline]
dpPass_Back() const | vl::StencilOp | [inline]
dpPass_Front() const | vl::StencilOp | [inline]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mDpFail_Back | vl::StencilOp | [protected]
mDpFail_Front | vl::StencilOp | [protected]
mDpPass_Back | vl::StencilOp | [protected]
mDpPass_Front | vl::StencilOp | [protected]
mName | vl::Object | [protected]
mSFail_Back | vl::StencilOp | [protected]
mSFail_Front | vl::StencilOp | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
set(EPolygonFace face, EStencilOp sfail, EStencilOp dpfail, EStencilOp dppass) | vl::StencilOp | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
sFail_Back() const | vl::StencilOp | [inline]
sFail_Front() const | vl::StencilOp | [inline]
StencilOp(EStencilOp sfail=SO_KEEP, EStencilOp dpfail=SO_KEEP, EStencilOp dppass=SO_KEEP) | vl::StencilOp | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::StencilOp | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:15 2009.


Visualization Library: Member List

vl::String Member List

This is the complete list of members for vl::String, including all inherited members.

acquireData() const | vl::String | [inline]
append(const String &other) | vl::String |
append(wchar_t ch, int count=1) | vl::String |
clear() | vl::String | [inline]
compare(const String &other) const | vl::String |
contains(wchar_t ch) const | vl::String |
contains(const String &str) const | vl::String |
count(wchar_t ch, int start=0) const | vl::String |
count(const String &str, int start=0) const | vl::String |
createData() const | vl::String | [inline, protected]
detectEncoding(const void *str, int byte_count, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING) | vl::String | [static]
empty() const | vl::String | [inline]
endsWith(const String &str) const | vl::String |
endsWith(wchar_t ch) const | vl::String |
extractFileExtension(bool require_dot=true) const | vl::String |
extractFileName() const | vl::String |
extractPath() const | vl::String |
field(wchar_t separator, int field_index) const | vl::String |
fill(wchar_t ch) | vl::String |
filterStrings(std::vector< String > &strings, const String &filter) | vl::String | [static]
find(wchar_t ch, int start=0) const | vl::String |
find(const String &str, int start=0) const | vl::String |
findBackwards(wchar_t ch) const | vl::String |
findBackwards(const String &str) const | vl::String |
fromAscii(const char *str, int size=-1) | vl::String | [static]
fromDouble(double value, int decimals=6) | vl::String | [static]
fromInt(int value) | vl::String | [static]
fromLatin1(const char *str, int character_count=-1) | vl::String | [static]
fromLongLong(long long value) | vl::String | [static]
fromStdString(const std::string &str) | vl::String | [static]
fromStdWString(const std::wstring &str) | vl::String | [static]
fromUInt(unsigned int value) | vl::String | [static]
fromULongLong(unsigned long long value) | vl::String | [static]
fromUTF16(const unsigned short *str, int byte_count=-1) | vl::String | [static]
fromUTF16BE(const unsigned short *str, int byte_count=-1) | vl::String | [static]
fromUTF16LE(const unsigned short *str, int byte_count=-1) | vl::String | [static]
fromUTF8(const char *str, int byte_count=-1) | vl::String | [static]
getLowerCase(unsigned short ch) | vl::String | [static]
getTitleCase(unsigned short ch) | vl::String | [static]
getUpperCase(unsigned short ch) | vl::String | [static]
insert(int pos, const String &str) | vl::String |
insert(int pos, wchar_t ch, int count=1) | vl::String |
left(int count) const | vl::String |
length() const | vl::String | [inline]
loadText(const String &path, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING) | vl::String | [static]
loadText(const char *path, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING) | vl::String | [inline, static]
loadText(VirtualFile *file, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING) | vl::String | [static]
loadText(void *data, int bytes, EStringEncoding encoding=VL_PLATFORM_DEFAULT_ENCODING) | vl::String | [static]
normalizeSlashes() | vl::String |
null() const | vl::String | [inline]
operator!=(const String &other) const | vl::String | [inline]
operator!=(const std::string &other) const | vl::String | [inline]
operator!=(const std::wstring &other) const | vl::String | [inline]
operator!=(const char *other) const | vl::String | [inline]
operator!=(const wchar_t *other) const | vl::String | [inline]
operator+(wchar_t ch) const | vl::String | [inline]
operator+(const String &other) const | vl::String | [inline]
operator+=(wchar_t ch) | vl::String | [inline]
operator+=(const String &other) | vl::String | [inline]
operator<(const String &other) const | vl::String | [inline]
operator=(const char *str) | vl::String | [inline]
operator=(const std::string &str) | vl::String | [inline]
operator=(const wchar_t *wstr) | vl::String | [inline]
operator=(const std::wstring &str) | vl::String | [inline]
operator=(const String &other) | vl::String | [inline]
operator==(const String &other) const | vl::String | [inline]
operator==(const std::string &other) const | vl::String | [inline]
operator==(const std::wstring &other) const | vl::String | [inline]
operator==(const char *other) const | vl::String | [inline]
operator==(const wchar_t *other) const | vl::String | [inline]
operator[](int i) const | vl::String | [inline]
operator[](int i) | vl::String | [inline]
platformSlash() | vl::String | [inline, static]
prepend(const String &str) | vl::String |
prepend(wchar_t ch, int count) | vl::String |
ptr() const | vl::String | [inline]
ptr() | vl::String | [inline]
remove(wchar_t ch, int start=0, int count=-1) | vl::String |
remove(const String &str, int start=0, int count=-1) | vl::String |
remove(int start, int count) | vl::String |
replace(wchar_t old_ch, wchar_t new_ch) | vl::String |
replace(int start, int count, wchar_t ch) | vl::String |
replace(int start, int count, const String &str) | vl::String |
replace(const String &oldstr, const String &newstr, bool case_sensitive=true) | vl::String |
resize(int character_count) | vl::String |
reverse() | vl::String |
right(int count) const | vl::String |
split(wchar_t separator, std::vector< String > &fields, bool remove_empty_fields=false) const | vl::String |
split(const String &separator_list, std::vector< String > &fields, bool remove_empty_fields=false) const | vl::String |
splitLines(std::vector< String > &lines) const | vl::String |
squeeze() | vl::String |
startsWith(const String &str) const | vl::String |
startsWith(wchar_t ch) const | vl::String |
String() | vl::String |
String(const String &other) | vl::String |
String(const wchar_t *wstr) | vl::String |
String(const char *str) | vl::String |
String(wchar_t ch, int count=1) | vl::String | [explicit]
substring(int start, int count=-1) const | vl::String |
toAscii(std::string &ascii, bool translate_non_ascii_chars=true) const | vl::String |
toDouble() const | vl::String |
toFloat() const | vl::String | [inline]
toInt(bool hex=false) const | vl::String |
toLatin1(std::vector< unsigned char > &latin1) const | vl::String |
toLowerCase() const | vl::String |
toStdString() const | vl::String |
toStdWString() const | vl::String |
toUpperCase() const | vl::String |
toUTF16BE(std::vector< unsigned char > &utf16, bool include_utf16be_signature=true) const | vl::String |
toUTF16LE(std::vector< unsigned char > &utf16, bool include_utf16le_signature=true) const | vl::String |
toUTF8(std::vector< unsigned char > &utf8, bool include_utf8_signature=true) const | vl::String |
toUTF8(std::string &utf8, bool include_utf8_signature=true) const | vl::String |
trim(wchar_t ch) | vl::String |
trim(const String &chars) | vl::String |
trim() | vl::String |
trimStdString(const std::string &text) | vl::String | [static]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: Member List

vl::Terrain Member List

This is the complete list of members for vl::Terrain, including all inherited members.

appendActors(ActorCollection &list) | vl::SceneManagerBVH< ActorKdTree > | [inline, virtual]
appendVisibleActors(ActorCollection &list, const Camera *camera) | vl::SceneManagerBVH< ActorKdTree > | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
chunk(int i) | vl::Terrain | [inline]
chunk(int i) const | vl::Terrain | [inline]
chunkCount() const | vl::Terrain | [inline]
chunks() const | vl::Terrain | [inline]
className() | vl::Terrain | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
depth() const | vl::Terrain | [inline]
detailRepetitionMode() const | vl::Terrain | [inline]
detailTexture() const | vl::Terrain | [inline]
detailTextureFormat() const | vl::Terrain | [inline]
enableMask() const | vl::SceneManager | [inline]
fragmentShader() const | vl::Terrain | [inline]
height() const | vl::Terrain | [inline]
heightmapTexture() const | vl::Terrain | [inline]
heightmapTextureFormat() const | vl::Terrain | [inline]
incReference() | vl::Object | [inline]
init() | vl::Terrain |
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mBoundingVolumeTree | vl::SceneManagerBVH< ActorKdTree > | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mChunks | vl::Terrain | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mDepth | vl::Terrain | [protected]
mDetailRepetitionCount | vl::Terrain | [protected]
mDetailTexture | vl::Terrain | [protected]
mDetailTextureFormat | vl::Terrain | [protected]
mEnableMask | vl::SceneManager | [protected]
mFragmentShader | vl::Terrain | [protected]
mHeight | vl::Terrain | [protected]
mHeightmapTexture | vl::Terrain | [protected]
mHeightmapTextureFormat | vl::Terrain | [protected]
mName | vl::Object | [protected]
mOrigin | vl::Terrain | [protected]
mShaderNode | vl::Terrain | [protected]
mSphere | vl::SceneManager | [protected]
mTerrainTexture | vl::Terrain | [protected]
mTerrainTextureFormat | vl::Terrain | [protected]
mUseGLSL | vl::Terrain | [protected]
mVertexShader | vl::Terrain | [protected]
mWidth | vl::Terrain | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
origin() const | vl::Terrain | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
SceneManagerActorKdTree() | vl::SceneManagerActorKdTree | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setDepth(double d) | vl::Terrain | [inline]
setDetailRepetitionCount(int count) | vl::Terrain | [inline]
setDetailTexture(const String &texture) | vl::Terrain | [inline]
setDetailTextureFormat(ETextureFormat format) | vl::Terrain | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setFragmentShader(const String &fs_path) | vl::Terrain | [inline]
setHeight(double h) | vl::Terrain | [inline]
setHeightmapTexture(const String &texture) | vl::Terrain | [inline]
setHeightmapTextureFormat(ETextureFormat format) | vl::Terrain | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOrigin(const vec3 &origin) | vl::Terrain | [inline]
setTerrainTexture(const String &texture) | vl::Terrain | [inline]
setTerrainTextureFormat(ETextureFormat format) | vl::Terrain | [inline]
setTree(ActorKdTree *bbh) | vl::SceneManagerBVH< ActorKdTree > | [inline]
setUseGLSL(bool enable) | vl::Terrain | [inline]
setVertexShader(const String &vs_path) | vl::Terrain | [inline]
setWidth(double w) | vl::Terrain | [inline]
shaderNode() const | vl::Terrain | [inline]
shaderNode() | vl::Terrain | [inline]
Terrain() | vl::Terrain | [inline]
terrainTexture() const | vl::Terrain | [inline]
terrainTextureFormat() const | vl::Terrain | [inline]
tree() const | vl::SceneManagerBVH< ActorKdTree > | [inline]
tree() | vl::SceneManagerBVH< ActorKdTree > | [inline]
useGLSL() const | vl::Terrain | [inline]
vertexShader() const | vl::Terrain | [inline]
width() const | vl::Terrain | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: Member List

vl::Tessellator Member List

This is the complete list of members for vl::Tessellator, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundaryOnly() const | vl::Tessellator | [inline]
className() | vl::Object | [inline, virtual]
contours() const | vl::Tessellator | [inline]
contours() | vl::Tessellator | [inline]
contourVerts() const | vl::Tessellator | [inline]
contourVerts() | vl::Tessellator | [inline]
decReference() | vl::Object | [inline]
freeCombinedVertices() | vl::Tessellator | [protected]
incReference() | vl::Object | [inline]
mBoundaryOnly | vl::Tessellator | [protected]
mCombinedVertices | vl::Tessellator | [protected]
mContours | vl::Tessellator | [protected]
mContourVerts | vl::Tessellator | [protected]
mFans | vl::Tessellator | [protected]
mLineLoops | vl::Tessellator | [protected]
mName | vl::Object | [protected]
mPrimitiveType | vl::Tessellator | [protected]
mTessellatedTris | vl::Tessellator | [protected]
mTessellateIntoSinglePolygon | vl::Tessellator | [protected]
mTessNormal | vl::Tessellator | [protected]
mTolerance | vl::Tessellator | [protected]
mTriStrips | vl::Tessellator | [protected]
mWindingRule | vl::Tessellator | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundaryOnly(bool on) | vl::Tessellator | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTessellateIntoSinglePolygon(bool on) | vl::Tessellator | [inline]
setTessNormal(const fvec3 &normal) | vl::Tessellator | [inline]
setTolerance(double tolerance) | vl::Tessellator | [inline]
setWindingRule(ETessellationWinding rule) | vl::Tessellator | [inline]
tessBeginData(GLenum type, Tessellator *tessellator) | vl::Tessellator | [protected, static]
tessCombineData(GLdouble coords[3], dvec3 *d[4], GLfloat w[4], dvec3 **dataOut, Tessellator *tessellator) | vl::Tessellator | [protected, static]
tessellate(bool append_tessellated_tris=false) | vl::Tessellator |
tessellatedTris() const | vl::Tessellator | [inline]
tessellatedTris() | vl::Tessellator | [inline]
tessellateGeometry(bool append_tessellated_tris=false) | vl::Tessellator |
tessellateIntoSinglePolygon() const | vl::Tessellator | [inline]
Tessellator() | vl::Tessellator |
tessEnd(void) | vl::Tessellator | [protected, static]
tessError(GLenum errno) | vl::Tessellator | [protected, static]
tessNormal() const | vl::Tessellator | [inline]
tessVertexData(dvec3 *vec, Tessellator *tessellator) | vl::Tessellator | [protected, static]
tolerance() const | vl::Tessellator | [inline]
windingRule() const | vl::Tessellator | [inline]
~Object() | vl::Object | [protected, virtual]
~Tessellator() | vl::Tessellator |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:17 2009.


Visualization Library: Member List

vl::TexEnv Member List

This is the complete list of members for vl::TexEnv, including all inherited members.

alphaScale() const | vl::TexEnv | [inline]
apply(const Camera *) const | vl::TexEnv | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::TexEnv | [inline, virtual]
color() const | vl::TexEnv | [inline]
combineAlpha() const | vl::TexEnv | [inline]
combineRGB() const | vl::TexEnv | [inline]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
lodBias() const | vl::TexEnv | [inline]
mAlphaScale | vl::TexEnv |
mColor | vl::TexEnv |
mCombineAlpha | vl::TexEnv |
mCombineRGB | vl::TexEnv |
mLodBias | vl::TexEnv |
mMode | vl::TexEnv |
mName | vl::Object | [protected]
mode() const | vl::TexEnv | [inline]
mOperand0Alpha | vl::TexEnv |
mOperand0RGB | vl::TexEnv |
mOperand1Alpha | vl::TexEnv |
mOperand1RGB | vl::TexEnv |
mOperand2Alpha | vl::TexEnv |
mOperand2RGB | vl::TexEnv |
mPointSpriteCoordReplace | vl::TexEnv |
mRGBScale | vl::TexEnv |
mSource0Alpha | vl::TexEnv |
mSource0RGB | vl::TexEnv |
mSource1Alpha | vl::TexEnv |
mSource1RGB | vl::TexEnv |
mSource2Alpha | vl::TexEnv |
mSource2RGB | vl::TexEnv |
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operand0Alpha() const | vl::TexEnv | [inline]
operand0RGB() const | vl::TexEnv | [inline]
operand1Alpha() const | vl::TexEnv | [inline]
operand1RGB() const | vl::TexEnv | [inline]
operand2Alpha() const | vl::TexEnv | [inline]
operand2RGB() const | vl::TexEnv | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointSpriteCoordReplace() const | vl::TexEnv | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
rgbScale() const | vl::TexEnv | [inline]
setAlphaScale(float alphascale) | vl::TexEnv | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setColor(fvec4 color) | vl::TexEnv | [inline]
setCombineAlpha(ETexEnvMode combineAlpha) | vl::TexEnv | [inline]
setCombineRGB(ETexEnvMode combineRGB) | vl::TexEnv | [inline]
setLodBias(float lodbias) | vl::TexEnv | [inline]
setMode(ETexEnvMode mode) | vl::TexEnv | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOperand0Alpha(ETexEnvOperand operand) | vl::TexEnv | [inline]
setOperand0RGB(ETexEnvOperand operand) | vl::TexEnv | [inline]
setOperand1Alpha(ETexEnvOperand operand) | vl::TexEnv | [inline]
setOperand1RGB(ETexEnvOperand operand) | vl::TexEnv | [inline]
setOperand2Alpha(ETexEnvOperand operand) | vl::TexEnv | [inline]
setOperand2RGB(ETexEnvOperand operand) | vl::TexEnv | [inline]
setPointSpriteCoordReplace(bool replace) | vl::TexEnv | [inline]
setRGBScale(float rgbscale) | vl::TexEnv | [inline]
setSource0Alpha(ETexEnvSource source) | vl::TexEnv | [inline]
setSource0RGB(ETexEnvSource source) | vl::TexEnv | [inline]
setSource1Alpha(ETexEnvSource source) | vl::TexEnv | [inline]
setSource1RGB(ETexEnvSource source) | vl::TexEnv | [inline]
setSource2Alpha(ETexEnvSource source) | vl::TexEnv | [inline]
setSource2RGB(ETexEnvSource source) | vl::TexEnv | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
source0Alpha() const | vl::TexEnv | [inline]
source0RGB() const | vl::TexEnv | [inline]
source1Alpha() const | vl::TexEnv | [inline]
source1RGB() const | vl::TexEnv | [inline]
source2Alpha() const | vl::TexEnv | [inline]
source2RGB() const | vl::TexEnv | [inline]
TexEnv(int texunit) | vl::TexEnv |
textureUnit() const | vl::RenderState | [inline]
type() const | vl::TexEnv | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::TexGen Member List

This is the complete list of members for vl::TexGen, including all inherited members.

apply(const Camera *) const | vl::TexGen | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::TexGen | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
eyePlaneQ() const | vl::TexGen | [inline]
eyePlaneR() const | vl::TexGen | [inline]
eyePlaneS() const | vl::TexGen | [inline]
eyePlaneT() const | vl::TexGen | [inline]
genModeQ() const | vl::TexGen | [inline]
genModeR() const | vl::TexGen | [inline]
genModeS() const | vl::TexGen | [inline]
genModeT() const | vl::TexGen | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
mEyePlaneQ | vl::TexGen |
mEyePlaneR | vl::TexGen |
mEyePlaneS | vl::TexGen |
mEyePlaneT | vl::TexGen |
mGenModeQ | vl::TexGen |
mGenModeR | vl::TexGen |
mGenModeS | vl::TexGen |
mGenModeT | vl::TexGen |
mName | vl::Object | [protected]
mObjectPlaneQ | vl::TexGen |
mObjectPlaneR | vl::TexGen |
mObjectPlaneS | vl::TexGen |
mObjectPlaneT | vl::TexGen |
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
objectPlaneQ() const | vl::TexGen | [inline]
objectPlaneR() const | vl::TexGen | [inline]
objectPlaneS() const | vl::TexGen | [inline]
objectPlaneT() const | vl::TexGen | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEyePlaneQ(fvec4 plane) | vl::TexGen | [inline]
setEyePlaneR(fvec4 plane) | vl::TexGen | [inline]
setEyePlaneS(fvec4 plane) | vl::TexGen | [inline]
setEyePlaneT(fvec4 plane) | vl::TexGen | [inline]
setGenModeQ(ETexGenMode mode) | vl::TexGen | [inline]
setGenModeR(ETexGenMode mode) | vl::TexGen | [inline]
setGenModeS(ETexGenMode mode) | vl::TexGen | [inline]
setGenModeT(ETexGenMode mode) | vl::TexGen | [inline]
setName(const std::string &name) | vl::Object | [inline]
setObjectPlaneQ(fvec4 plane) | vl::TexGen | [inline]
setObjectPlaneR(fvec4 plane) | vl::TexGen | [inline]
setObjectPlaneS(fvec4 plane) | vl::TexGen | [inline]
setObjectPlaneT(fvec4 plane) | vl::TexGen | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
TexGen(int texunit) | vl::TexGen |
textureUnit() const | vl::RenderState | [inline]
type() const | vl::TexGen | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::TexParameter Member List

This is the complete list of members for vl::TexParameter, including all inherited members.

anisotropy() const | vl::TexParameter | [inline]
apply(ETextureDimension dimension) | vl::TexParameter |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
borderColor() const | vl::TexParameter | [inline]
className() | vl::TexParameter | [inline, virtual]
compareFunc() const | vl::TexParameter | [inline]
compareMode() const | vl::TexParameter | [inline]
decReference() | vl::Object | [inline]
depthTextureMode() const | vl::TexParameter | [inline]
dirty() const | vl::TexParameter | [inline]
generateMipmap() const | vl::TexParameter | [inline]
incReference() | vl::Object | [inline]
magFilter() const | vl::TexParameter | [inline]
mAnisotropy | vl::TexParameter | [protected]
mBorderColor | vl::TexParameter | [protected]
mCompareFunc | vl::TexParameter | [protected]
mCompareMode | vl::TexParameter | [protected]
mDepthTextureMode | vl::TexParameter | [protected]
mDirty | vl::TexParameter | [protected]
mGenerateMipmap | vl::TexParameter | [protected]
minFilter() const | vl::TexParameter | [inline]
mMagfilter | vl::TexParameter | [protected]
mMinFilter | vl::TexParameter | [protected]
mName | vl::Object | [protected]
mWrapR | vl::TexParameter | [protected]
mWrapS | vl::TexParameter | [protected]
mWrapT | vl::TexParameter | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAnisotropy(float anisotropy) | vl::TexParameter | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBorderColor(fvec4 bordercolor) | vl::TexParameter | [inline]
setDepthTextureMode(EDepthTextureMode mode) | vl::TexParameter | [inline]
setGenerateMipmap(bool generate_mipmap) | vl::TexParameter | [inline]
setMagFilter(ETexParamFilter magfilter) | vl::TexParameter |
setMinFilter(ETexParamFilter minfilter) | vl::TexParameter | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTexCompareFunc(ETexCompareFunc func) | vl::TexParameter | [inline]
setTexCompareMode(ETexCompareMode mode) | vl::TexParameter | [inline]
setWrapR(ETexParamWrap texturewrap) | vl::TexParameter | [inline]
setWrapS(ETexParamWrap texturewrap) | vl::TexParameter | [inline]
setWrapT(ETexParamWrap texturewrap) | vl::TexParameter | [inline]
TexParameter() | vl::TexParameter |
wrapR() const | vl::TexParameter | [inline]
wrapS() const | vl::TexParameter | [inline]
wrapT() const | vl::TexParameter | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::Text Member List

This is the complete list of members for vl::Text, including all inherited members.

alignment() const | vl::Text | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
backgroundColor() const | vl::Text | [inline]
backgroundEnabled() const | vl::Text | [inline]
borderColor() const | vl::Text | [inline]
borderEnabled() const | vl::Text | [inline]
boundingBox() const | vl::Renderable | [inline]
boundingRect() const | vl::Text |
boundingRect(const String &text) const | vl::Text |
boundingRectTransformed(vec3 &a, vec3 &b, vec3 &c, vec3 &d, const Camera *camera, const Actor *actor=NULL) const | vl::Text |
boundingRectTransformed(const Camera *camera, const Actor *actor=NULL) const | vl::Text |
boundingSphere() const | vl::Renderable | [inline]
boundsDirty() const | vl::Renderable | [inline]
boundsUpdateTick() const | vl::Renderable | [inline]
className() | vl::Text | [inline, virtual]
color() const | vl::Text | [inline]
compileDisplayList(Actor *act, OpenGLContext *glctx, Camera *camera) | vl::Renderable | [inline]
computeBounds() | vl::Renderable | [inline]
computeBounds_Implementation() | vl::Text | [inline, virtual]
decReference() | vl::Object | [inline]
deleteDisplayList() | vl::Renderable | [inline]
deleteVBOs() | vl::Renderable | [inline, virtual]
displayList() const | vl::Renderable | [inline]
displayListDirty() const | vl::Renderable | [inline]
displayListEnabled() const | vl::Renderable | [inline]
font() const | vl::Text | [inline]
incReference() | vl::Object | [inline]
interlineSpacing() const | vl::Text | [inline]
kerningEnabled() const | vl::Text | [inline]
layout() const | vl::Text | [inline]
lineCount() const | vl::Renderable | [inline, virtual]
mAlignment | vl::Text | [protected]
margin() const | vl::Text | [inline]
matrix() const | vl::Text | [inline]
mBackgroundColor | vl::Text | [protected]
mBackgroundEnabled | vl::Text | [protected]
mBorderColor | vl::Text | [protected]
mBorderEnabled | vl::Text | [protected]
mColor | vl::Text | [protected]
mFont | vl::Text | [protected]
mInterlineSpacing | vl::Text | [protected]
mKerningEnabled | vl::Text | [protected]
mLayout | vl::Text | [protected]
mMargin | vl::Text | [protected]
mMatrix | vl::Text | [protected]
mMode | vl::Text | [protected]
mName | vl::Object | [protected]
mode() const | vl::Text | [inline]
mOutlineColor | vl::Text | [protected]
mOutlineEnabled | vl::Text | [protected]
mShadowColor | vl::Text | [protected]
mShadowEnabled | vl::Text | [protected]
mShadowVector | vl::Text | [protected]
mText | vl::Text | [protected]
mTextAlignment | vl::Text | [protected]
mViewportAlignment | vl::Text | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
outlineColor() const | vl::Text | [inline]
outlineEnabled() const | vl::Text | [inline]
pointCount() const | vl::Renderable | [inline, virtual]
rawboundingRect(const String &text) const | vl::Text | [protected]
referenceCount() const | vl::Object | [inline]
render(const Actor *, const OpenGLContext *, const Camera *camera) const | vl::Text | [virtual]
Renderable() | vl::Renderable | [inline]
renderBackground(const Actor *actor, const Camera *camera) const | vl::Text | [protected]
renderBorder(const Actor *actor, const Camera *camera) const | vl::Text | [protected]
renderText(const Actor *, const Camera *camera, const fvec4 &color, const fvec2 &offset) const | vl::Text | [protected]
resetMatrix() | vl::Text |
rotate(float degrees, float x, float y, float z) | vl::Text |
setAlignment(int align) | vl::Text | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBackgroundColor(const fvec4 &background_color) | vl::Text | [inline]
setBackgroundEnabled(bool background) | vl::Text | [inline]
setBorderColor(const fvec4 &border_color) | vl::Text | [inline]
setBorderEnabled(bool border) | vl::Text | [inline]
setBoundingBox(const AABB &aabb) | vl::Renderable | [inline]
setBoundingSphere(const Sphere &sphere) | vl::Renderable | [inline]
setBoundsDirty(bool dirty) | vl::Renderable | [inline]
setColor(const fvec4 &color) | vl::Text | [inline]
setDisplayList(unsigned int disp_list) | vl::Renderable | [inline]
setDisplayListDirty(bool dirty) | vl::Renderable | [inline]
setDisplayListEnabled(bool enabled) | vl::Renderable | [inline]
setFont(Font *font) | vl::Text | [inline]
setInterlineSpacing(float spacing) | vl::Text | [inline]
setKerningEnabled(bool kerning) | vl::Text | [inline]
setLayout(ETextLayout layout) | vl::Text | [inline]
setMargin(int margin) | vl::Text | [inline]
setMatrix(const fmat4 &matrix) | vl::Text | [inline]
setMode(ETextMode mode) | vl::Text | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOutlineColor(const fvec4 &outline_color) | vl::Text | [inline]
setOutlineEnabled(bool outline) | vl::Text | [inline]
setShadowColor(const fvec4 &shadow_color) | vl::Text | [inline]
setShadowEnabled(bool shadow) | vl::Text | [inline]
setShadowVector(const fvec2 &shadow_vector) | vl::Text | [inline]
setText(const String &text) | vl::Text | [inline]
setTextAlignment(ETextAlign align) | vl::Text | [inline]
setVBODirty(bool dirty) | vl::Renderable | [inline]
setVBOEnabled(bool enabled) | vl::Renderable | [inline]
setViewportAlignment(int align) | vl::Text | [inline]
shadowColor() const | vl::Text | [inline]
shadowEnabled() const | vl::Text | [inline]
shadowVector() const | vl::Text | [inline]
Text() | vl::Text | [inline]
text() const | vl::Text | [inline]
textAlignment() const | vl::Text | [inline]
translate(float x, float y, float z) | vl::Text |
triangleCount() const | vl::Renderable | [inline, virtual]
updateVBOs(bool) | vl::Renderable | [inline, virtual]
vboDirty() const | vl::Renderable | [inline]
vboEnabled() const | vl::Renderable | [inline]
viewportAlignment() const | vl::Text | [inline]
~Object() | vl::Object | [protected, virtual]
~Renderable() | vl::Renderable | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::TextStream Member List

This is the complete list of members for vl::TextStream, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
BufferedStream() | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
bufferEmpty() | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
className() | vl::TextStream | [inline, virtual]
decReference() | vl::Object | [inline]
fillBuffer() | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
incReference() | vl::Object | [inline]
inputFile() const | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
mBuffer | vl::BufferedStream< unsigned char, 128 *1024 > | [protected]
mInputFile | vl::BufferedStream< unsigned char, 128 *1024 > | [protected]
mName | vl::Object | [protected]
mPtr | vl::BufferedStream< unsigned char, 128 *1024 > | [protected]
mSize | vl::BufferedStream< unsigned char, 128 *1024 > | [protected]
mTmpStdStr | vl::TextStream | [protected]
mTmpStr | vl::TextStream | [protected]
mUngetBuffer | vl::BufferedStream< unsigned char, 128 *1024 > | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
readDouble(double &d) | vl::TextStream | [inline]
readInt(int &i, bool hex=false) | vl::TextStream | [inline]
readLine(std::string &utf8) | vl::TextStream | [inline]
readLine(String &line) | vl::TextStream | [inline]
readLineCR(String &line) | vl::TextStream | [inline]
readLineLF(String &line) | vl::TextStream | [inline]
readQuotedString(String &token) | vl::TextStream | [inline]
readStdString(std::string &token) | vl::TextStream | [inline]
readString(String &token) | vl::TextStream | [inline]
readToken(unsigned char *token) | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
referenceCount() const | vl::Object | [inline]
seek(long long pos) | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setInputFile(VirtualFile *file) | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
setName(const std::string &name) | vl::Object | [inline]
TextStream(VirtualFile *file=NULL) | vl::TextStream | [inline]
ungetLine(const std::string &utf8) | vl::TextStream | [inline]
ungetToken(const unsigned char &token) | vl::BufferedStream< unsigned char, 128 *1024 > | [inline]
~Object() | vl::Object | [protected, virtual]
~TextStream() | vl::TextStream | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::Texture Member List

This is the complete list of members for vl::Texture, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
border() const | vl::Texture | [inline]
className() | vl::Texture | [inline, virtual]
createTexture() | vl::Texture |
decReference() | vl::Object | [inline]
depth() const | vl::Texture | [inline]
dimension() const | vl::Texture | [inline]
getTexParameter() const | vl::Texture | [inline]
handle() const | vl::Texture | [inline]
hasMipMaps() const | vl::Texture | [inline]
height() const | vl::Texture | [inline]
incReference() | vl::Object | [inline]
internalFormat() const | vl::Texture | [inline]
isCompressedFormat(int format) | vl::Texture | [static]
isValid() const | vl::Texture |
mBorder | vl::Texture | [protected]
mDepth | vl::Texture | [protected]
mDimension | vl::Texture | [protected]
mFormat | vl::Texture | [protected]
mHandle | vl::Texture | [protected]
mHasMipmaps | vl::Texture | [protected]
mHeight | vl::Texture | [protected]
mName | vl::Object | [protected]
mSetupParams | vl::Texture | [protected]
mTexParameter | vl::Texture | [protected]
mWidth | vl::Texture | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBorder(bool border) | vl::Texture | [inline]
setDepth(int z) | vl::Texture | [inline]
setDimension(ETextureDimension dimension) | vl::Texture | [inline]
setHandle(unsigned int id) | vl::Texture | [inline]
setHeight(int y) | vl::Texture | [inline]
setInternalFormat(ETextureFormat format) | vl::Texture | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSetupParams(SetupParams *setup_params) | vl::Texture | [inline]
setupParams() const | vl::Texture | [inline]
setupParams() | vl::Texture | [inline]
setupTexture1D(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTexture1D(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTexture1DArray(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true) | vl::Texture | [inline]
setupTexture1DArray(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true) | vl::Texture | [inline]
setupTexture2D(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTexture2D(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTexture2DArray(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true) | vl::Texture | [inline]
setupTexture2DArray(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true) | vl::Texture | [inline]
setupTexture3D(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTexture3D(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTextureCubemap(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTextureCubemap(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture | [inline]
setupTextureRectangle(const String &image_path, ETextureFormat format=TF_RGBA) | vl::Texture | [inline]
setupTextureRectangle(Image *image, ETextureFormat format=TF_RGBA) | vl::Texture | [inline]
setWidth(int x) | vl::Texture | [inline]
supports(ETextureDimension texture_dim, ETextureFormat format, bool border, const Image *image, bool verbose=true) | vl::Texture | [static]
Texture(const String &image_path, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture |
Texture(Image *image, ETextureFormat format=TF_RGBA, bool mipmaps=true, bool border=false) | vl::Texture |
Texture(int width, ETextureFormat format=TF_RGBA, bool border=false) | vl::Texture |
Texture(int width, int height, ETextureFormat format=TF_RGBA, bool border=false) | vl::Texture |
Texture(int width, int height, int depth, ETextureFormat format=TF_RGBA, bool border=false) | vl::Texture |
Texture() | vl::Texture |
width() const | vl::Texture | [inline]
~Object() | vl::Object | [protected, virtual]
~Texture() | vl::Texture | [virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::Texture::SetupParams Member List

This is the complete list of members for vl::Texture::SetupParams, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
border() const | vl::Texture::SetupParams | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
dimension() const | vl::Texture::SetupParams | [inline]
format() const | vl::Texture::SetupParams | [inline]
hasMipmaps() const | vl::Texture::SetupParams | [inline]
image() const | vl::Texture::SetupParams | [inline]
imagePath() const | vl::Texture::SetupParams | [inline]
incReference() | vl::Object | [inline]
mBorder | vl::Texture::SetupParams | [protected]
mDimension | vl::Texture::SetupParams | [protected]
mFormat | vl::Texture::SetupParams | [protected]
mHasMipmaps | vl::Texture::SetupParams | [protected]
mImage | vl::Texture::SetupParams | [protected]
mImagePath | vl::Texture::SetupParams | [protected]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBorder(bool on) | vl::Texture::SetupParams | [inline]
setDimension(ETextureDimension dimension) | vl::Texture::SetupParams | [inline]
setFormat(ETextureFormat format) | vl::Texture::SetupParams | [inline]
setHasMipmaps(bool on) | vl::Texture::SetupParams | [inline]
setImage(Image *image) | vl::Texture::SetupParams | [inline]
setImagePath(const String &path) | vl::Texture::SetupParams | [inline]
setName(const std::string &name) | vl::Object | [inline]
SetupParams() | vl::Texture::SetupParams | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::TextureMatrix Member List

This is the complete list of members for vl::TextureMatrix, including all inherited members.

apply(const Camera *) const | vl::TextureMatrix | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::TextureMatrix | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::RenderState | [inline, virtual]
enable() const | vl::RenderState | [inline, virtual]
incReference() | vl::Object | [inline]
initResources() | vl::RenderState | [inline, virtual]
matrix() const | vl::TextureMatrix | [inline]
mMatrix | vl::TextureMatrix | [protected]
mName | vl::Object | [protected]
mTextureUnit | vl::RenderState | [protected]
mUseCameraRotationInverse | vl::TextureMatrix | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setMatrix(const mat4 &matrix) | vl::TextureMatrix | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
setUseCameraRotationInverse(bool use) | vl::TextureMatrix | [inline]
TextureMatrix(int texunit) | vl::TextureMatrix | [inline]
textureUnit() const | vl::RenderState | [inline]
type() const | vl::TextureMatrix | [inline, virtual]
useCameraRotationInverse() const | vl::TextureMatrix | [inline]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::TextureUnit Member List

This is the complete list of members for vl::TextureUnit, including all inherited members.

apply(const Camera *) const | vl::TextureUnit | [virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::TextureUnit | [inline, virtual]
decReference() | vl::Object | [inline]
disable() const | vl::TextureUnit | [virtual]
enable() const | vl::TextureUnit | [virtual]
hasTexture() const | vl::TextureUnit | [inline]
incReference() | vl::Object | [inline]
initResources() | vl::TextureUnit | [inline, virtual]
mName | vl::Object | [protected]
mTexture | vl::TextureUnit | [protected]
mTextureUnit | vl::RenderState | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
RenderState() | vl::RenderState | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setTexture(Texture *texture) | vl::TextureUnit | [inline]
setUnitIndex(int unit_index) | vl::RenderState | [inline]
texture() | vl::TextureUnit | [inline]
texture() const | vl::TextureUnit | [inline]
textureUnit() const | vl::RenderState | [inline]
TextureUnit(int texunit) | vl::TextureUnit | [inline]
type() const | vl::TextureUnit | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~RenderState() | vl::RenderState | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:16 2009.


Visualization Library: Member List

vl::Time Member List

This is the complete list of members for vl::Time, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Time | [inline, virtual]
currentTime() | vl::Time | [static]
dayOfMonth() const | vl::Time | [inline]
dayOfWeek() const | vl::Time | [inline]
decReference() | vl::Object | [inline]
elapsed(int index=0) const | vl::Time | [inline]
hour() const | vl::Time | [inline]
incReference() | vl::Object | [inline]
isStarted(int index=0) const | vl::Time | [inline]
mDayOfMonth | vl::Time | [protected]
mDayOfWeek | vl::Time | [protected]
mHour | vl::Time | [protected]
microsecond() const | vl::Time | [inline]
minute() const | vl::Time | [inline]
mMicrosecond | vl::Time | [protected]
mMinute | vl::Time | [protected]
mMonth | vl::Time | [protected]
mName | vl::Object | [protected]
month() const | vl::Time | [inline]
mSecond | vl::Time | [protected]
mStart | vl::Time | [protected]
mYear | vl::Time | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
second() const | vl::Time | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
sleep(unsigned int milliseconds) | vl::Time | [static]
start(int index=0) | vl::Time | [inline]
stop(int index=0) | vl::Time | [inline]
Time() | vl::Time |
year() const | vl::Time | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::TrackballManipulator Member List

This is the complete list of members for vl::TrackballManipulator, including all inherited members.

adjustView(const AABB &aabb, const vec3 &dir, const vec3 &up, Real bias=1.0f) | vl::TrackballManipulator |
adjustView(ActorCollection &actors, const vec3 &dir, const vec3 &up, Real bias=1.0f) | vl::TrackballManipulator |
adjustView(SceneManager *scene, const vec3 &dir, const vec3 &up, Real bias=1.0f) | vl::TrackballManipulator |
adjustView(Rendering *rendering, const vec3 &dir, const vec3 &up, Real bias=1.0f) | vl::TrackballManipulator |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
camera() | vl::TrackballManipulator | [inline]
className() | vl::TrackballManipulator | [inline, virtual]
computeVector(int x, int y) | vl::TrackballManipulator |
decReference() | vl::Object | [inline]
destroyEvent() | vl::UIEventListener | [inline, virtual]
ETrackballMode enum name | vl::TrackballManipulator |
fileDroppedEvent(const std::vector< String > &) | vl::UIEventListener | [inline, virtual]
incReference() | vl::Object | [inline]
initEvent() | vl::UIEventListener | [inline, virtual]
isEnabled() const | vl::UIEventListener | [inline]
keyPressEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
keyReleaseEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
mCamera | vl::TrackballManipulator | [protected]
mEnabled | vl::UIEventListener | [protected]
mMode | vl::TrackballManipulator | [protected]
mMouseStart | vl::TrackballManipulator | [protected]
mName | vl::Object | [protected]
mode() const | vl::TrackballManipulator | [inline]
mOpenGLContext | vl::UIEventListener | [protected]
mouseDownEvent(EMouseButton, int x, int y) | vl::TrackballManipulator | [virtual]
mouseMoveEvent(int x, int y) | vl::TrackballManipulator | [virtual]
mouseUpEvent(EMouseButton, int x, int y) | vl::TrackballManipulator | [virtual]
mouseWheelEvent(int) | vl::UIEventListener | [inline, virtual]
mPivot | vl::TrackballManipulator | [protected]
mRank | vl::UIEventListener | [protected]
mRotationButton | vl::TrackballManipulator | [protected]
mRotationSpeed | vl::TrackballManipulator | [protected]
mStartCameraPos | vl::TrackballManipulator | [protected]
mStartMatrix | vl::TrackballManipulator | [protected]
mStartPivot | vl::TrackballManipulator | [protected]
mTransform | vl::TrackballManipulator | [protected]
mTranslationButton | vl::TrackballManipulator | [protected]
mTranslationSpeed | vl::TrackballManipulator | [protected]
mZoomButton | vl::TrackballManipulator | [protected]
mZoomSpeed | vl::TrackballManipulator | [protected]
name() const | vl::Object | [inline]
NoMode enum value | vl::TrackballManipulator |
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
openglContext() | vl::UIEventListener |
openglContextBoundEvent(OpenGLContext *) | vl::UIEventListener | [inline, virtual]
operator<(const UIEventListener &other) const | vl::UIEventListener | [inline]
operator=(const Object &other) | vl::Object | [inline]
pivot() const | vl::TrackballManipulator | [inline]
prepareToReconnect() | vl::TrackballManipulator | [inline, virtual]
rank() const | vl::UIEventListener |
referenceCount() const | vl::Object | [inline]
resizeEvent(int, int) | vl::UIEventListener | [inline, virtual]
rotationButton() const | vl::TrackballManipulator | [inline]
RotationMode enum value | vl::TrackballManipulator |
rotationSpeed() const | vl::TrackballManipulator | [inline]
runEvent() | vl::UIEventListener | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setCamera(Camera *camera) | vl::TrackballManipulator | [inline]
setEnabled(bool enabled) | vl::UIEventListener | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setPivot(vec3 pivot) | vl::TrackballManipulator | [inline]
setRank(int rank) | vl::UIEventListener |
setRotationButton(int mouse_button) | vl::TrackballManipulator | [inline]
setRotationSpeed(float speed) | vl::TrackballManipulator | [inline]
setTransform(Transform *tr) | vl::TrackballManipulator | [inline]
setTranslationButton(int mouse_button) | vl::TrackballManipulator | [inline]
setTranslationSpeed(float speed) | vl::TrackballManipulator | [inline]
setZoomButton(int mouse_button) | vl::TrackballManipulator | [inline]
setZoomSpeed(float speed) | vl::TrackballManipulator | [inline]
TrackballManipulator() | vl::TrackballManipulator | [inline]
trackballRotation(int x, int y) | vl::TrackballManipulator |
transform() | vl::TrackballManipulator | [inline]
translationButton() const | vl::TrackballManipulator | [inline]
TranslationMode enum value | vl::TrackballManipulator |
translationSpeed() const | vl::TrackballManipulator | [inline]
UIEventListener() | vl::UIEventListener | [inline]
visibilityEvent(bool) | vl::UIEventListener | [inline, virtual]
zoomButton() const | vl::TrackballManipulator | [inline]
ZoomMode enum value | vl::TrackballManipulator |
zoomSpeed() const | vl::TrackballManipulator | [inline]
~Object() | vl::Object | [protected, virtual]
~UIEventListener() | vl::UIEventListener | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:18 2009.


Visualization Library: Member List

vl::Transform Member List

This is the complete list of members for vl::Transform, including all inherited members.

addChild(Transform *child) | vl::Transform |
alwaysIdentityWorldMatrix() | vl::Transform | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
child(int i) | vl::Transform |
childCount() const | vl::Transform |
className() | vl::Transform | [inline, virtual]
computeWorldMatrix(Camera *camera=NULL) | vl::Transform | [virtual]
computeWorldMatrixRecursive(Camera *camera=NULL) | vl::Transform |
decReference() | vl::Object | [inline]
eraseAllChildren() | vl::Transform |
eraseAllChildrenRecursive() | vl::Transform |
eraseChild(Transform *child) | vl::Transform |
eraseChildren(int index, int count) | vl::Transform |
getComputedWorldMatrix() | vl::Transform |
incReference() | vl::Object | [inline]
lastChild() | vl::Transform |
localMatrix() const | vl::Transform |
mAssumeIdentityWorldMatrix | vl::Transform | [protected]
mChildren | vl::Transform | [protected]
mLocalMatrix | vl::Transform | [protected]
mName | vl::Object | [protected]
mParent | vl::Transform | [protected]
mWorldMatrix | vl::Transform | [protected]
mWorldMatrixUpdateTick | vl::Transform | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
parent() const | vl::Transform | [inline]
parent() | vl::Transform | [inline]
referenceCount() const | vl::Object | [inline]
rotate(Real degrees, Real x, Real y, Real z) | vl::Transform |
rotate(const vec3 &from, const vec3 &to) | vl::Transform |
scale(Real x, Real y, Real z) | vl::Transform |
setAlwaysIdentityWorldMatrix(bool assume_I) | vl::Transform | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setChild(int index, Transform *child) | vl::Transform |
setLocalMatrix(const mat4 &matrix) | vl::Transform |
setName(const std::string &name) | vl::Object | [inline]
setWorldMatrix(const mat4 &matrix) | vl::Transform | [protected]
Transform() | vl::Transform | [inline]
Transform(const mat4 &matrix) | vl::Transform | [inline]
translate(Real x, Real y, Real z) | vl::Transform |
translate(const vec3 &t) | vl::Transform |
worldMatrix() const | vl::Transform |
worldMatrixUpdateTick() const | vl::Transform | [inline]
~Object() | vl::Object | [protected, virtual]
~Transform() | vl::Transform | [virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::TriangleStripGenerator Member List

This is the complete list of members for vl::TriangleStripGenerator, including all inherited members.

className() | vl::TriangleStripGenerator | [inline, virtual]
stripfy(Geometry *geom, int cache_size=22, bool merge_strips=true, bool remove_doubles=true, bool substitute_quads=true) | vl::TriangleStripGenerator | [static]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::UIEventListener Member List

This is the complete list of members for vl::UIEventListener, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::UIEventListener | [inline, virtual]
decReference() | vl::Object | [inline]
destroyEvent() | vl::UIEventListener | [inline, virtual]
fileDroppedEvent(const std::vector< String > &) | vl::UIEventListener | [inline, virtual]
incReference() | vl::Object | [inline]
initEvent() | vl::UIEventListener | [inline, virtual]
isEnabled() const | vl::UIEventListener | [inline]
keyPressEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
keyReleaseEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
mEnabled | vl::UIEventListener | [protected]
mName | vl::Object | [protected]
mOpenGLContext | vl::UIEventListener | [protected]
mouseDownEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseMoveEvent(int, int) | vl::UIEventListener | [inline, virtual]
mouseUpEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseWheelEvent(int) | vl::UIEventListener | [inline, virtual]
mRank | vl::UIEventListener | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext class | vl::UIEventListener | [friend]
openglContext() | vl::UIEventListener |
openglContextBoundEvent(OpenGLContext *) | vl::UIEventListener | [inline, virtual]
operator<(const UIEventListener &other) const | vl::UIEventListener | [inline]
operator=(const Object &other) | vl::Object | [inline]
prepareToReconnect() | vl::UIEventListener | [inline, virtual]
rank() const | vl::UIEventListener |
referenceCount() const | vl::Object | [inline]
resizeEvent(int, int) | vl::UIEventListener | [inline, virtual]
runEvent() | vl::UIEventListener | [inline, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnabled(bool enabled) | vl::UIEventListener | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setRank(int rank) | vl::UIEventListener |
UIEventListener() | vl::UIEventListener | [inline]
visibilityEvent(bool) | vl::UIEventListener | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~UIEventListener() | vl::UIEventListener | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::Uniform Member List

This is the complete list of members for vl::Uniform, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Uniform | [inline, virtual]
count() const | vl::Uniform | [inline]
decReference() | vl::Object | [inline]
EUniformType enum name | vl::Uniform |
getUniform(float *value) | vl::Uniform | [inline]
getUniform(int *value) | vl::Uniform | [inline]
getUniform(unsigned int *value) | vl::Uniform | [inline]
getUniform(ivec2 *value) | vl::Uniform | [inline]
getUniform(ivec3 *value) | vl::Uniform | [inline]
getUniform(ivec4 *value) | vl::Uniform | [inline]
getUniform(uvec2 *value) | vl::Uniform | [inline]
getUniform(uvec3 *value) | vl::Uniform | [inline]
getUniform(uvec4 *value) | vl::Uniform | [inline]
getUniform(fvec2 *value) | vl::Uniform | [inline]
getUniform(fvec3 *value) | vl::Uniform | [inline]
getUniform(fvec4 *value) | vl::Uniform | [inline]
getUniform(fmat2 *value) | vl::Uniform | [inline]
getUniform(fmat3 *value) | vl::Uniform | [inline]
getUniform(fmat4 *value) | vl::Uniform | [inline]
GLSLProgram class | vl::Uniform | [friend]
incReference() | vl::Object | [inline]
initFloat(int count) | vl::Uniform | [inline, protected]
initInt(int count) | vl::Uniform | [inline, protected]
initUInt(int count) | vl::Uniform | [inline, protected]
mFloatData | vl::Uniform | [protected]
mIntData | vl::Uniform | [protected]
mName | vl::Object | [protected]
mType | vl::Uniform | [protected]
mUIntData | vl::Uniform | [protected]
name() const | vl::Object | [inline]
NONE enum value | vl::Uniform |
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUniform(int count, const ivec2 *value) | vl::Uniform | [inline]
setUniform(int count, const ivec3 *value) | vl::Uniform | [inline]
setUniform(int count, const ivec4 *value) | vl::Uniform | [inline]
setUniform(int count, const uvec2 *value) | vl::Uniform | [inline]
setUniform(int count, const uvec3 *value) | vl::Uniform | [inline]
setUniform(int count, const uvec4 *value) | vl::Uniform | [inline]
setUniform(int count, const fvec2 *value) | vl::Uniform | [inline]
setUniform(int count, const fvec3 *value) | vl::Uniform | [inline]
setUniform(int count, const fvec4 *value) | vl::Uniform | [inline]
setUniform(int count, const fmat2 *value) | vl::Uniform | [inline]
setUniform(int count, const fmat3 *value) | vl::Uniform | [inline]
setUniform(int count, const fmat4 *value) | vl::Uniform | [inline]
setUniform(const int &value) | vl::Uniform | [inline]
setUniform(const ivec2 &value) | vl::Uniform | [inline]
setUniform(const ivec3 &value) | vl::Uniform | [inline]
setUniform(const ivec4 &value) | vl::Uniform | [inline]
setUniform(const unsigned int &value) | vl::Uniform | [inline]
setUniform(const uvec2 &value) | vl::Uniform | [inline]
setUniform(const uvec3 &value) | vl::Uniform | [inline]
setUniform(const uvec4 &value) | vl::Uniform | [inline]
setUniform(const float &value) | vl::Uniform | [inline]
setUniform(const fvec2 &value) | vl::Uniform | [inline]
setUniform(const fvec3 &value) | vl::Uniform | [inline]
setUniform(const fvec4 &value) | vl::Uniform | [inline]
setUniform(const fmat2 &value) | vl::Uniform | [inline]
setUniform(const fmat3 &value) | vl::Uniform | [inline]
setUniform(const fmat4 &value) | vl::Uniform | [inline]
setUniform1f(int count, const float *value) | vl::Uniform | [inline]
setUniform1i(int count, const int *value) | vl::Uniform | [inline]
setUniform1ui(int count, const unsigned int *value) | vl::Uniform | [inline]
setUniform2f(int count, const float *value) | vl::Uniform | [inline]
setUniform2i(int count, const int *value) | vl::Uniform | [inline]
setUniform2ui(int count, const unsigned int *value) | vl::Uniform | [inline]
setUniform3f(int count, const float *value) | vl::Uniform | [inline]
setUniform3i(int count, const int *value) | vl::Uniform | [inline]
setUniform3ui(int count, const unsigned int *value) | vl::Uniform | [inline]
setUniform4f(int count, const float *value) | vl::Uniform | [inline]
setUniform4i(int count, const int *value) | vl::Uniform | [inline]
setUniform4ui(int count, const unsigned int *value) | vl::Uniform | [inline]
setUniformMatrix2f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix2x3f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix2x4f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix3f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix3x2f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix3x4f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix4f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix4x2f(int count, const float *value) | vl::Uniform | [inline]
setUniformMatrix4x3f(int count, const float *value) | vl::Uniform | [inline]
type() const | vl::Uniform | [inline]
Uniform() | vl::Uniform | [inline]
Uniform(const std::string &name) | vl::Uniform | [inline]
UT_Float enum value | vl::Uniform |
UT_Float2 enum value | vl::Uniform |
UT_Float3 enum value | vl::Uniform |
UT_Float4 enum value | vl::Uniform |
UT_Int enum value | vl::Uniform |
UT_Int2 enum value | vl::Uniform |
UT_Int3 enum value | vl::Uniform |
UT_Int4 enum value | vl::Uniform |
UT_Mat2 enum value | vl::Uniform |
UT_Mat2x3 enum value | vl::Uniform |
UT_Mat2x4 enum value | vl::Uniform |
UT_Mat3 enum value | vl::Uniform |
UT_Mat3x2 enum value | vl::Uniform |
UT_Mat3x4 enum value | vl::Uniform |
UT_Mat4 enum value | vl::Uniform |
UT_Mat4x2 enum value | vl::Uniform |
UT_Mat4x3 enum value | vl::Uniform |
UT_UInt enum value | vl::Uniform |
UT_UInt2 enum value | vl::Uniform |
UT_UInt3 enum value | vl::Uniform |
UT_UInt4 enum value | vl::Uniform |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::UniformSet Member List

This is the complete list of members for vl::UniformSet, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::UniformSet | [inline, virtual]
decReference() | vl::Object | [inline]
eraseAllUniforms() | vl::UniformSet | [inline]
eraseUniform(const std::string &name) | vl::UniformSet | [inline]
eraseUniform(const Uniform *uniform) | vl::UniformSet | [inline]
getUniform(const std::string &name) | vl::UniformSet | [inline]
getUniform(const std::string &name) const | vl::UniformSet | [inline]
gocUniform(const std::string &name) | vl::UniformSet | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
mUniforms | vl::UniformSet | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setUniform(Uniform *uniform, bool check_for_doubles=true) | vl::UniformSet | [inline]
uniforms() const | vl::UniformSet | [inline]
UniformSet() | vl::UniformSet | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::Vector2< scalar_type > Member List

This is the complete list of members for vl::Vector2< scalar_type >, including all inherited members.

g() const | vl::Vector2< scalar_type > | [inline]
g() | vl::Vector2< scalar_type > | [inline]
isNull() const | vl::Vector2< scalar_type > | [inline]
length() const | vl::Vector2< scalar_type > | [inline]
lengthSquared() const | vl::Vector2< scalar_type > | [inline]
mScalar | vl::Vector2< scalar_type > | [protected]
normalize() | vl::Vector2< scalar_type > | [inline]
operator!=(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator*(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator*(scalar_type val) const | vl::Vector2< scalar_type > | [inline]
operator*=(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
operator*=(scalar_type val) | vl::Vector2< scalar_type > | [inline]
operator+(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator+(scalar_type val) const | vl::Vector2< scalar_type > | [inline]
operator+=(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
operator+=(scalar_type val) | vl::Vector2< scalar_type > | [inline]
operator-(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator-(scalar_type val) const | vl::Vector2< scalar_type > | [inline]
operator-() const | vl::Vector2< scalar_type > | [inline]
operator-=(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
operator-=(scalar_type val) | vl::Vector2< scalar_type > | [inline]
operator/(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator/(scalar_type val) const | vl::Vector2< scalar_type > | [inline]
operator/=(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
operator/=(scalar_type val) | vl::Vector2< scalar_type > | [inline]
operator<(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator=(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
operator=(scalar_type val) | vl::Vector2< scalar_type > | [inline]
operator==(const Vector2 &other) const | vl::Vector2< scalar_type > | [inline]
operator[](unsigned i) | vl::Vector2< scalar_type > | [inline]
operator[](unsigned i) const | vl::Vector2< scalar_type > | [inline]
ptr() | vl::Vector2< scalar_type > | [inline]
ptr() const | vl::Vector2< scalar_type > | [inline]
r() const | vl::Vector2< scalar_type > | [inline]
r() | vl::Vector2< scalar_type > | [inline]
s() const | vl::Vector2< scalar_type > | [inline]
s() | vl::Vector2< scalar_type > | [inline]
scalar_count | vl::Vector2< scalar_type > | [static]
t() const | vl::Vector2< scalar_type > | [inline]
t() | vl::Vector2< scalar_type > | [inline]
Vector2(const Vector2 &other) | vl::Vector2< scalar_type > | [inline]
Vector2() | vl::Vector2< scalar_type > | [inline]
Vector2(const T &other) | vl::Vector2< scalar_type > | [inline, explicit]
Vector2(scalar_type x, scalar_type y) | vl::Vector2< scalar_type > | [inline, explicit]
x() const | vl::Vector2< scalar_type > | [inline]
x() | vl::Vector2< scalar_type > | [inline]
y() const | vl::Vector2< scalar_type > | [inline]
y() | vl::Vector2< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::Vector3< scalar_type > Member List

This is the complete list of members for vl::Vector3< scalar_type >, including all inherited members.

b() const | vl::Vector3< scalar_type > | [inline]
b() | vl::Vector3< scalar_type > | [inline]
g() const | vl::Vector3< scalar_type > | [inline]
g() | vl::Vector3< scalar_type > | [inline]
isNull() const | vl::Vector3< scalar_type > | [inline]
length() const | vl::Vector3< scalar_type > | [inline]
lengthSquared() const | vl::Vector3< scalar_type > | [inline]
mScalar | vl::Vector3< scalar_type > | [protected]
normalize() | vl::Vector3< scalar_type > | [inline]
operator!=(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator*(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator*(scalar_type val) const | vl::Vector3< scalar_type > | [inline]
operator*=(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
operator*=(scalar_type val) | vl::Vector3< scalar_type > | [inline]
operator+(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator+(scalar_type val) const | vl::Vector3< scalar_type > | [inline]
operator+=(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
operator+=(scalar_type val) | vl::Vector3< scalar_type > | [inline]
operator-(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator-(scalar_type val) const | vl::Vector3< scalar_type > | [inline]
operator-() const | vl::Vector3< scalar_type > | [inline]
operator-=(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
operator-=(scalar_type val) | vl::Vector3< scalar_type > | [inline]
operator/(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator/(scalar_type val) const | vl::Vector3< scalar_type > | [inline]
operator/=(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
operator/=(scalar_type val) | vl::Vector3< scalar_type > | [inline]
operator<(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator=(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
operator=(scalar_type val) | vl::Vector3< scalar_type > | [inline]
operator==(const Vector3 &other) const | vl::Vector3< scalar_type > | [inline]
operator[](unsigned i) | vl::Vector3< scalar_type > | [inline]
operator[](unsigned i) const | vl::Vector3< scalar_type > | [inline]
p() const | vl::Vector3< scalar_type > | [inline]
p() | vl::Vector3< scalar_type > | [inline]
ptr() | vl::Vector3< scalar_type > | [inline]
ptr() const | vl::Vector3< scalar_type > | [inline]
r() const | vl::Vector3< scalar_type > | [inline]
r() | vl::Vector3< scalar_type > | [inline]
s() const | vl::Vector3< scalar_type > | [inline]
s() | vl::Vector3< scalar_type > | [inline]
scalar_count | vl::Vector3< scalar_type > | [static]
st() const | vl::Vector3< scalar_type > | [inline]
t() const | vl::Vector3< scalar_type > | [inline]
t() | vl::Vector3< scalar_type > | [inline]
Vector3(const Vector3 &other) | vl::Vector3< scalar_type > | [inline]
Vector3() | vl::Vector3< scalar_type > | [inline]
Vector3(const T &other) | vl::Vector3< scalar_type > | [inline, explicit]
Vector3(scalar_type x, scalar_type y, scalar_type z) | vl::Vector3< scalar_type > | [inline, explicit]
Vector3(const Vector2< scalar_type > &v, scalar_type z) | vl::Vector3< scalar_type > | [inline, explicit]
x() const | vl::Vector3< scalar_type > | [inline]
x() | vl::Vector3< scalar_type > | [inline]
xy() const | vl::Vector3< scalar_type > | [inline]
y() const | vl::Vector3< scalar_type > | [inline]
y() | vl::Vector3< scalar_type > | [inline]
z() const | vl::Vector3< scalar_type > | [inline]
z() | vl::Vector3< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::Vector4< scalar_type > Member List

This is the complete list of members for vl::Vector4< scalar_type >, including all inherited members.

a() const | vl::Vector4< scalar_type > | [inline]
a() | vl::Vector4< scalar_type > | [inline]
b() const | vl::Vector4< scalar_type > | [inline]
b() | vl::Vector4< scalar_type > | [inline]
g() const | vl::Vector4< scalar_type > | [inline]
g() | vl::Vector4< scalar_type > | [inline]
isNull() const | vl::Vector4< scalar_type > | [inline]
length() const | vl::Vector4< scalar_type > | [inline]
lengthSquared() const | vl::Vector4< scalar_type > | [inline]
mScalar | vl::Vector4< scalar_type > | [protected]
normalize() | vl::Vector4< scalar_type > | [inline]
operator!=(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator*(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator*(scalar_type val) const | vl::Vector4< scalar_type > | [inline]
operator*=(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
operator*=(scalar_type val) | vl::Vector4< scalar_type > | [inline]
operator+(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator+(scalar_type val) const | vl::Vector4< scalar_type > | [inline]
operator+=(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
operator+=(scalar_type val) | vl::Vector4< scalar_type > | [inline]
operator-(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator-(scalar_type val) const | vl::Vector4< scalar_type > | [inline]
operator-() const | vl::Vector4< scalar_type > | [inline]
operator-=(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
operator-=(scalar_type val) | vl::Vector4< scalar_type > | [inline]
operator/(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator/(scalar_type val) const | vl::Vector4< scalar_type > | [inline]
operator/=(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
operator/=(scalar_type val) | vl::Vector4< scalar_type > | [inline]
operator<(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator=(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
operator=(scalar_type val) | vl::Vector4< scalar_type > | [inline]
operator==(const Vector4 &other) const | vl::Vector4< scalar_type > | [inline]
operator[](unsigned i) | vl::Vector4< scalar_type > | [inline]
operator[](unsigned i) const | vl::Vector4< scalar_type > | [inline]
p() const | vl::Vector4< scalar_type > | [inline]
p() | vl::Vector4< scalar_type > | [inline]
ptr() | vl::Vector4< scalar_type > | [inline]
ptr() const | vl::Vector4< scalar_type > | [inline]
q() const | vl::Vector4< scalar_type > | [inline]
q() | vl::Vector4< scalar_type > | [inline]
r() const | vl::Vector4< scalar_type > | [inline]
r() | vl::Vector4< scalar_type > | [inline]
rg() const | vl::Vector4< scalar_type > | [inline]
rgb() const | vl::Vector4< scalar_type > | [inline]
s() const | vl::Vector4< scalar_type > | [inline]
s() | vl::Vector4< scalar_type > | [inline]
scalar_count | vl::Vector4< scalar_type > | [static]
st() const | vl::Vector4< scalar_type > | [inline]
stp() const | vl::Vector4< scalar_type > | [inline]
t() const | vl::Vector4< scalar_type > | [inline]
t() | vl::Vector4< scalar_type > | [inline]
Vector4(const Vector4 &other) | vl::Vector4< scalar_type > | [inline]
Vector4() | vl::Vector4< scalar_type > | [inline]
Vector4(const T &other) | vl::Vector4< scalar_type > | [inline, explicit]
Vector4(scalar_type x, scalar_type y, scalar_type z, scalar_type w) | vl::Vector4< scalar_type > | [inline, explicit]
Vector4(const Vector3< scalar_type > &v, scalar_type w) | vl::Vector4< scalar_type > | [inline, explicit]
Vector4(const Vector2< scalar_type > &u, const Vector2< scalar_type > &v) | vl::Vector4< scalar_type > | [inline, explicit]
w() const | vl::Vector4< scalar_type > | [inline]
w() | vl::Vector4< scalar_type > | [inline]
x() const | vl::Vector4< scalar_type > | [inline]
x() | vl::Vector4< scalar_type > | [inline]
xy() const | vl::Vector4< scalar_type > | [inline]
xyz() const | vl::Vector4< scalar_type > | [inline]
y() const | vl::Vector4< scalar_type > | [inline]
y() | vl::Vector4< scalar_type > | [inline]
z() const | vl::Vector4< scalar_type > | [inline]
z() | vl::Vector4< scalar_type > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:19 2009.


Visualization Library: Member List

vl::VertexAttributeArray Member List

This is the complete list of members for vl::VertexAttributeArray, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
attribIndex() const | vl::VertexAttributeArray | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::VertexAttributeArray | [inline, virtual]
data() const | vl::VertexAttributeArray | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mAttribIndex | vl::VertexAttributeArray | [protected]
mData | vl::VertexAttributeArray | [protected]
mName | vl::Object | [protected]
mNormalize | vl::VertexAttributeArray | [protected]
mPureInteger | vl::VertexAttributeArray | [protected]
name() const | vl::Object | [inline]
normalize() const | vl::VertexAttributeArray | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pureInteger() const | vl::VertexAttributeArray | [inline]
referenceCount() const | vl::Object | [inline]
setAttribIndex(unsigned int index) | vl::VertexAttributeArray | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setData(ArrayAbstract *data) | vl::VertexAttributeArray | [inline]
setName(const std::string &name) | vl::Object | [inline]
setNormalize(bool normalize) | vl::VertexAttributeArray | [inline]
setPureInteger(bool pure_integer) | vl::VertexAttributeArray | [inline]
VertexAttributeArray(unsigned int location, bool normalize, bool pure_integer, ArrayAbstract *data) | vl::VertexAttributeArray | [inline]
VertexAttributeArray() | vl::VertexAttributeArray | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::VertexMapper Member List

This is the complete list of members for vl::VertexMapper, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::VertexMapper | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
regenerate(ArrayAbstract *data, const std::vector< unsigned int > &map_new_to_old) const | vl::VertexMapper |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:09 2009.


Visualization Library: Member List

vl::Viewport Member List

This is the complete list of members for vl::Viewport, including all inherited members.

activate() const | vl::Viewport |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
center() const | vl::Viewport | [inline]
className() | vl::Viewport | [inline, virtual]
clearColor() const | vl::Viewport | [inline]
clearColorInt() const | vl::Viewport | [inline]
clearColorMode() const | vl::Viewport | [inline]
clearColorUInt() const | vl::Viewport | [inline]
clearDepth() const | vl::Viewport | [inline]
clearFlags() const | vl::Viewport | [inline]
clearStencil() const | vl::Viewport | [inline]
decReference() | vl::Object | [inline]
height() const | vl::Viewport | [inline]
incReference() | vl::Object | [inline]
isPointInside(int x, int y, int render_target_height) const | vl::Viewport |
mClearColor | vl::Viewport | [protected]
mClearColorInt | vl::Viewport | [protected]
mClearColorMode | vl::Viewport | [protected]
mClearColorUInt | vl::Viewport | [protected]
mClearDepth | vl::Viewport | [protected]
mClearFlags | vl::Viewport | [protected]
mClearStencil | vl::Viewport | [protected]
mHeight | vl::Viewport | [protected]
mName | vl::Object | [protected]
mWidth | vl::Viewport | [protected]
mX | vl::Viewport | [protected]
mY | vl::Viewport | [protected]
name() const | vl::Object | [inline]
null() | vl::Viewport | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
rect() const | vl::Viewport | [inline]
referenceCount() const | vl::Object | [inline]
set(int x, int y, int w, int h) | vl::Viewport | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setClearColor(float r, float g, float b, float a) | vl::Viewport | [inline]
setClearColor(const fvec4 &color) | vl::Viewport | [inline]
setClearColorInt(int r, int g, int b, int a) | vl::Viewport | [inline]
setClearColorInt(const ivec4 &color) | vl::Viewport | [inline]
setClearColorMode(EClearColorMode mode) | vl::Viewport | [inline]
setClearColorUInt(unsigned int r, unsigned int g, unsigned int b, unsigned int a) | vl::Viewport | [inline]
setClearColorUInt(const uvec4 &color) | vl::Viewport | [inline]
setClearDepth(Real depth) | vl::Viewport | [inline]
setClearFlags(EClearFlags clear_flags) | vl::Viewport | [inline]
setClearStencil(int stencil) | vl::Viewport | [inline]
setHeight(int height) | vl::Viewport | [inline]
setName(const std::string &name) | vl::Object | [inline]
setWidth(int width) | vl::Viewport | [inline]
setX(int x) | vl::Viewport | [inline]
setY(int y) | vl::Viewport | [inline]
Viewport() | vl::Viewport |
Viewport(int x, int y, int w, int h) | vl::Viewport |
width() const | vl::Viewport | [inline]
x() const | vl::Viewport | [inline]
y() const | vl::Viewport | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::VirtualDirectory Member List

This is the complete list of members for vl::VirtualDirectory, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::VirtualDirectory | [inline, virtual]
decReference() | vl::Object | [inline]
file(const String &name) const =0 | vl::VirtualDirectory | [pure virtual]
fileExists(const String &name) const | vl::VirtualDirectory | [inline]
incReference() | vl::Object | [inline]
listFiles(std::vector< String > &file_list, bool append=false) const =0 | vl::VirtualDirectory | [pure virtual]
listFilesRecursive(std::vector< String > &file_list) const =0 | vl::VirtualDirectory | [pure virtual]
listFilesRecursive(std::vector< String > &file_list, const String &match) const | vl::VirtualDirectory | [inline, virtual]
listSubDirs(std::vector< String > &dirs, bool append=false) const =0 | vl::VirtualDirectory | [pure virtual]
mName | vl::Object | [protected]
mPath | vl::VirtualDirectory | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualDirectory | [inline, virtual]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &path) | vl::VirtualDirectory | [virtual]
subDir(const String &subdir_name) const =0 | vl::VirtualDirectory | [pure virtual]
translatePath(const String &p) const | vl::VirtualDirectory | [protected]
VirtualDirectory(const String &path="/") | vl::VirtualDirectory | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::VirtualFile Member List

This is the complete list of members for vl::VirtualFile, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::VirtualFile | [inline, virtual]
clone() const =0 | vl::VirtualFile | [pure virtual]
close()=0 | vl::VirtualFile | [pure virtual]
crc32() | vl::VirtualFile |
decReference() | vl::Object | [inline]
endOfFile() const | vl::VirtualFile | [inline]
exists() const =0 | vl::VirtualFile | [pure virtual]
incReference() | vl::Object | [inline]
isOpen() const =0 | vl::VirtualFile | [pure virtual]
load(std::vector< unsigned char > &data) | vl::VirtualFile |
load(void *buffer, long long max=-1) | vl::VirtualFile |
md5() | vl::VirtualFile |
mName | vl::Object | [protected]
mPath | vl::VirtualFile | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
open(EOpenMode mode)=0 | vl::VirtualFile | [pure virtual]
operator=(const VirtualFile &other) | vl::VirtualFile | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualFile | [inline]
peek(void *buffer, long long byte_count) | vl::VirtualFile |
position() const | vl::VirtualFile |
position_Implementation() const =0 | vl::VirtualFile | [protected, pure virtual]
read(void *buffer, long long byte_count) | vl::VirtualFile |
read_Implementation(void *buffer, long long byte_count)=0 | vl::VirtualFile | [protected, pure virtual]
readDouble(bool little_endian_data=true) | vl::VirtualFile |
readDouble(void *buffer, long long count) | vl::VirtualFile |
readFloat(bool little_endian_data=true) | vl::VirtualFile |
readFloat(void *buffer, long long count) | vl::VirtualFile |
readSByte() | vl::VirtualFile |
readSByte(void *buffer, long long count) | vl::VirtualFile |
readSInt16(bool little_endian_data=true) | vl::VirtualFile |
readSInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt32(bool little_endian_data=true) | vl::VirtualFile |
readSInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt64(bool little_endian_data=true) | vl::VirtualFile |
readSInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUByte() | vl::VirtualFile |
readUByte(void *buffer, long long count) | vl::VirtualFile |
readUInt16(bool little_endian_data=true) | vl::VirtualFile |
readUInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt32(bool little_endian_data=true) | vl::VirtualFile |
readUInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt64(bool little_endian_data=true) | vl::VirtualFile |
readUInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
referenceCount() const | vl::Object | [inline]
seekCur(long long offset) | vl::VirtualFile |
seekEnd(long long offset) | vl::VirtualFile |
seekSet(long long offset) | vl::VirtualFile |
seekSet_Implementation(long long offset)=0 | vl::VirtualFile | [protected, pure virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::VirtualFile | [inline]
size() const =0 | vl::VirtualFile | [pure virtual]
VirtualFile(const VirtualFile &other) | vl::VirtualFile | [inline, protected]
VirtualFile() | vl::VirtualFile | [inline]
write(const void *buffer, long long byte_count) | vl::VirtualFile |
write_Implementation(const void *buffer, long long byte_count)=0 | vl::VirtualFile | [protected, pure virtual]
writeSInt16(short data, bool little_endian=true) | vl::VirtualFile |
writeSInt32(long data, bool little_endian=true) | vl::VirtualFile |
writeSInt8(char data) | vl::VirtualFile |
writeUInt16(unsigned short data, bool little_endian=true) | vl::VirtualFile |
writeUInt32(unsigned long data, bool little_endian=true) | vl::VirtualFile |
writeUInt8(unsigned char data) | vl::VirtualFile |
~Object() | vl::Object | [protected, virtual]
~VirtualFile() | vl::VirtualFile | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::VisualizationLibrary Member List

This is the complete list of members for vl::VisualizationLibrary, including all inherited members.

envVars() | vl::VisualizationLibrary | [static]
fileSystem() | vl::VisualizationLibrary | [static]
fontManager() | vl::VisualizationLibrary | [static]
freeTypeLibrary() | vl::VisualizationLibrary | [static]
init() | vl::VisualizationLibrary | [static]
initEnvVars() | vl::VisualizationLibrary | [protected, static]
initialized() | vl::VisualizationLibrary | [static]
loadWriterManager() | vl::VisualizationLibrary | [static]
logger() | vl::VisualizationLibrary | [static]
rendering() | vl::VisualizationLibrary | [static]
setRendering(RenderingAbstract *rendering) | vl::VisualizationLibrary | [static]
shutdown() | vl::VisualizationLibrary | [static]
versionString() | vl::VisualizationLibrary | [static]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:20 2009.


Visualization Library: Member List

vl::WriteCallback Member List

This is the complete list of members for vl::WriteCallback, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator()(ResourceDatabase *db)=0 | vl::WriteCallback | [pure virtual]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:11 2009.


Visualization Library: Member List

vl::ZippedDirectory Member List

This is the complete list of members for vl::ZippedDirectory, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ZippedDirectory | [inline, virtual]
decReference() | vl::Object | [inline]
file(const String &name) const | vl::ZippedDirectory | [virtual]
fileExists(const String &name) const | vl::VirtualDirectory | [inline]
incReference() | vl::Object | [inline]
init() | vl::ZippedDirectory | [protected]
isCorrupted() | vl::ZippedDirectory |
listFiles(std::vector< String > &file_list, bool append=false) const | vl::ZippedDirectory | [virtual]
listFilesRecursive(std::vector< String > &file_list) const | vl::ZippedDirectory | [virtual]
vl::VirtualDirectory::listFilesRecursive(std::vector< String > &file_list, const String &match) const | vl::VirtualDirectory | [inline, virtual]
listSubDirs(std::vector< String > &dirs, bool append=false) const | vl::ZippedDirectory | [virtual]
mFiles | vl::ZippedDirectory | [protected]
mName | vl::Object | [protected]
mPath | vl::VirtualDirectory | [protected]
mSourceZipFile | vl::ZippedDirectory | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualDirectory | [inline, virtual]
referenceCount() const | vl::Object | [inline]
reset() | vl::ZippedDirectory |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::ZippedDirectory | [virtual]
setSourceZipFile(VirtualFile *file) | vl::ZippedDirectory |
sourceZipFile() const | vl::ZippedDirectory |
subDir(const String &subdir_name) const | vl::ZippedDirectory | [inline, virtual]
translatePath(const String &p) const | vl::VirtualDirectory | [protected]
VirtualDirectory(const String &path="/") | vl::VirtualDirectory | [inline]
ZippedDirectory() | vl::ZippedDirectory |
ZippedDirectory(const String &zip_file) | vl::ZippedDirectory |
ZippedDirectory(VirtualFile *zip_file) | vl::ZippedDirectory |
zippedFile(const String &name) const | vl::ZippedDirectory |
zippedFile(int index) const | vl::ZippedDirectory |
zippedFileCount() const | vl::ZippedDirectory |
zippedSubDir(const String &subdir_name) const | vl::ZippedDirectory |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: Member List

vl::ZippedFile Member List

This is the complete list of members for vl::ZippedFile, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
CHUNK_SIZE | vl::ZippedFile | [protected, static]
className() | vl::ZippedFile | [inline, virtual]
clone() const | vl::ZippedFile | [virtual]
close() | vl::ZippedFile | [virtual]
crc32() | vl::VirtualFile |
decReference() | vl::Object | [inline]
endOfFile() const | vl::VirtualFile | [inline]
exists() const | vl::ZippedFile | [virtual]
extract(char *destination, bool check_sum=true) | vl::ZippedFile |
fillUncompressedBuffer() | vl::ZippedFile | [protected, virtual]
incReference() | vl::Object | [inline]
isOpen() const | vl::ZippedFile | [virtual]
load(std::vector< unsigned char > &data) | vl::VirtualFile |
load(void *buffer, long long max=-1) | vl::VirtualFile |
md5() | vl::VirtualFile |
mName | vl::Object | [protected]
mPath | vl::VirtualFile | [protected]
mReadBytes | vl::ZippedFile | [protected]
mUncompressedBuffer | vl::ZippedFile | [protected]
mUncompressedBufferPtr | vl::ZippedFile | [protected]
mZipBufferIn | vl::ZippedFile | [protected]
mZipBufferOut | vl::ZippedFile | [protected]
mZippedFileInfo | vl::ZippedFile | [protected]
mZStream | vl::ZippedFile | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
open(EOpenMode mode) | vl::ZippedFile | [virtual]
operator=(const ZippedFile &other) | vl::ZippedFile | [inline]
vl::VirtualFile::operator=(const VirtualFile &other) | vl::VirtualFile | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
path() const | vl::VirtualFile | [inline]
peek(void *buffer, long long byte_count) | vl::VirtualFile |
position() const | vl::VirtualFile |
position_Implementation() const | vl::ZippedFile | [inline, protected, virtual]
read(void *buffer, long long byte_count) | vl::VirtualFile |
read_Implementation(void *buffer, long long bytes_to_read) | vl::ZippedFile | [protected, virtual]
readDouble(bool little_endian_data=true) | vl::VirtualFile |
readDouble(void *buffer, long long count) | vl::VirtualFile |
readFloat(bool little_endian_data=true) | vl::VirtualFile |
readFloat(void *buffer, long long count) | vl::VirtualFile |
readSByte() | vl::VirtualFile |
readSByte(void *buffer, long long count) | vl::VirtualFile |
readSInt16(bool little_endian_data=true) | vl::VirtualFile |
readSInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt32(bool little_endian_data=true) | vl::VirtualFile |
readSInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readSInt64(bool little_endian_data=true) | vl::VirtualFile |
readSInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUByte() | vl::VirtualFile |
readUByte(void *buffer, long long count) | vl::VirtualFile |
readUInt16(bool little_endian_data=true) | vl::VirtualFile |
readUInt16(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt32(bool little_endian_data=true) | vl::VirtualFile |
readUInt32(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
readUInt64(bool little_endian_data=true) | vl::VirtualFile |
readUInt64(void *buffer, long long count, bool little_endian_data=true) | vl::VirtualFile |
referenceCount() const | vl::Object | [inline]
resetStream() | vl::ZippedFile |
seekCur(long long offset) | vl::VirtualFile |
seekEnd(long long offset) | vl::VirtualFile |
seekSet(long long offset) | vl::VirtualFile |
seekSet_Implementation(long long) | vl::ZippedFile | [protected, virtual]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPath(const String &name) | vl::VirtualFile | [inline]
setZippedFileInfo(ZippedFileInfo *info) | vl::ZippedFile |
size() const | vl::ZippedFile | [virtual]
VirtualFile(const VirtualFile &other) | vl::VirtualFile | [inline, protected]
VirtualFile() | vl::VirtualFile | [inline]
write(const void *buffer, long long byte_count) | vl::VirtualFile |
write_Implementation(const void *, long long) | vl::ZippedFile | [inline, protected, virtual]
writeSInt16(short data, bool little_endian=true) | vl::VirtualFile |
writeSInt32(long data, bool little_endian=true) | vl::VirtualFile |
writeSInt8(char data) | vl::VirtualFile |
writeUInt16(unsigned short data, bool little_endian=true) | vl::VirtualFile |
writeUInt32(unsigned long data, bool little_endian=true) | vl::VirtualFile |
writeUInt8(unsigned char data) | vl::VirtualFile |
ZippedFile() | vl::ZippedFile |
zippedFileInfo() const | vl::ZippedFile |
~Object() | vl::Object | [protected, virtual]
~VirtualFile() | vl::VirtualFile | [inline]
~ZippedFile() | vl::ZippedFile |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: Member List

vl::ZippedFileInfo Member List

This is the complete list of members for vl::ZippedFileInfo, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::ZippedFileInfo | [inline, virtual]
compressedSize() const | vl::ZippedFileInfo | [inline]
compressionMethod() const | vl::ZippedFileInfo | [inline]
crc32() const | vl::ZippedFileInfo | [inline]
day() const | vl::ZippedFileInfo | [inline]
decReference() | vl::Object | [inline]
extraFieldLength() const | vl::ZippedFileInfo | [inline]
fileNameLength() const | vl::ZippedFileInfo | [inline]
generalPurposeFlag() const | vl::ZippedFileInfo | [inline]
hour() const | vl::ZippedFileInfo | [inline]
incReference() | vl::Object | [inline]
mCompressedSize | vl::ZippedFileInfo |
mCompressionMethod | vl::ZippedFileInfo |
mCRC32 | vl::ZippedFileInfo |
mDay | vl::ZippedFileInfo |
mExtraFieldLength | vl::ZippedFileInfo |
mFileName | vl::ZippedFileInfo |
mFileNameLength | vl::ZippedFileInfo |
mGeneralPurposeFlag | vl::ZippedFileInfo |
mHour | vl::ZippedFileInfo |
minute() const | vl::ZippedFileInfo | [inline]
mMinute | vl::ZippedFileInfo |
mMonth | vl::ZippedFileInfo |
mName | vl::Object | [protected]
month() const | vl::ZippedFileInfo | [inline]
mSecond | vl::ZippedFileInfo |
mSourceZipFile | vl::ZippedFileInfo |
mUncompressedSize | vl::ZippedFileInfo |
mVersionNeeded | vl::ZippedFileInfo |
mYear | vl::ZippedFileInfo |
mZippedFileOffset | vl::ZippedFileInfo |
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
path() const | vl::ZippedFileInfo | [inline]
referenceCount() const | vl::Object | [inline]
second() const | vl::ZippedFileInfo | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setName(const std::string &name) | vl::Object | [inline]
setSourceZipFile(VirtualFile *file) | vl::ZippedFileInfo | [inline]
sourceZipFile() const | vl::ZippedFileInfo | [inline]
uncompressedSize() const | vl::ZippedFileInfo | [inline]
versionNeeded() const | vl::ZippedFileInfo | [inline]
year() const | vl::ZippedFileInfo | [inline]
ZippedDirectory class | vl::ZippedFileInfo | [friend]
ZippedFile class | vl::ZippedFileInfo | [friend]
ZippedFileInfo() | vl::ZippedFileInfo | [inline]
zippedFileOffset() const | vl::ZippedFileInfo | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: Member List

vl::quat Member List

This is the complete list of members for vl::quat, including all inherited members.

conjugate() const | vl::quat | [inline]
dot(const quat &q) const | vl::quat | [inline]
fromAxisAngle(Real degrees, const vec3 &axis) | vl::quat |
fromEulerXYZ(Real degX, Real degY, Real degZ) | vl::quat |
fromEulerZYX(Real degZ, Real degY, Real degX) | vl::quat |
fromMatrix(const mat4 &m) | vl::quat |
fromVectors(const vec4 &from, const vec4 &to) | vl::quat | [inline]
fromVectors(const vec3 &from, const vec3 &to) | vl::quat |
getNormalized() const | vl::quat | [inline]
inverse() const | vl::quat | [inline]
length() const | vl::quat | [inline]
lengthSquared() const | vl::quat | [inline]
mXYZW | vl::quat | [protected]
nlerp(Real t, const quat &a, const quat &b) const | vl::quat | [inline]
normalize() | vl::quat | [inline]
operator!=(const quat &q) const | vl::quat | [inline]
operator*(Real real) const | vl::quat | [inline]
operator*=(Real real) | vl::quat | [inline]
operator+(const quat &q) const | vl::quat | [inline]
operator+=(const quat &q) | vl::quat | [inline]
operator-(const quat &q) const | vl::quat | [inline]
operator-() const | vl::quat | [inline]
operator-=(const quat &q) | vl::quat | [inline]
operator/(Real real) const | vl::quat | [inline]
operator/=(Real real) | vl::quat | [inline]
operator<(const vec4 &v) const | vl::quat | [inline]
operator==(const quat &q) const | vl::quat | [inline]
quat() | vl::quat | [inline]
quat(const vec4 &v) | vl::quat | [inline, explicit]
quat(Real x, Real y, Real z, Real w) | vl::quat | [inline, explicit]
quat(Real degrees, const vec3 &axis) | vl::quat | [inline, explicit]
setNoRotation() | vl::quat | [inline]
setZero() | vl::quat | [inline]
slerp(Real t, const quat &a, const quat &b) const | vl::quat |
squad(Real t, const quat &a, const quat &p, const quat &q, const quat &b) const | vl::quat | [inline]
toAxisAngle(vec4 &axis, Real &angle) const | vl::quat |
toMatrix() const | vl::quat |
w() | vl::quat | [inline]
w() const | vl::quat | [inline]
x() | vl::quat | [inline]
x() const | vl::quat | [inline]
xyzw() const | vl::quat | [inline]
xyzw() | vl::quat | [inline]
y() | vl::quat | [inline]
y() const | vl::quat | [inline]
z() | vl::quat | [inline]
z() const | vl::quat | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:13 2009.


Visualization Library: Member List

vl::ref< T > Member List

This is the complete list of members for vl::ref< T >, including all inherited members.

get() const | vl::ref< T > | [inline]
mObject | vl::ref< T > | [protected]
operator bool() const | vl::ref< T > | [inline]
operator*() const | vl::ref< T > | [inline]
operator->() const | vl::ref< T > | [inline]
operator<(const ref &other) const | vl::ref< T > | [inline]
operator=(const ref &other) | vl::ref< T > | [inline]
operator=(const ref< T2 > other) | vl::ref< T > | [inline]
operator=(T *other) | vl::ref< T > | [inline]
operator=(T2 *other) | vl::ref< T > | [inline]
ref(T *object=NULL) | vl::ref< T > | [inline]
ref(const ref &other) | vl::ref< T > | [inline]
ref(const ref< T2 > &other) | vl::ref< T > | [inline]
swap(ref &other) | vl::ref< T > | [inline]
~ref() | vl::ref< T > | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:12 2009.


Visualization Library: Member List

vlGLUT::GLUTWindow Member List

This is the complete list of members for vlGLUT::GLUTWindow, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vlGLUT::GLUTWindow | [virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlGLUT::GLUTWindow | [virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
glut_close_func() | vlGLUT::GLUTWindow | [protected, static]
glut_display_func() | vlGLUT::GLUTWindow | [protected, static]
glut_idle_func() | vlGLUT::GLUTWindow | [protected, static]
glut_keyboard_func(unsigned char ch, int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_keyboard_up_func(unsigned char ch, int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_motion_func(int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_mouse_func(int button, int state, int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_mouse_wheel_func(int a, int rotation, int c, int d) | vlGLUT::GLUTWindow | [protected, static]
glut_passive_motion_func(int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_reshape_func(int w, int h) | vlGLUT::GLUTWindow | [protected, static]
glut_special_func(int key, int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_special_up_func(int key, int x, int y) | vlGLUT::GLUTWindow | [protected, static]
glut_visibility_func(int visibility) | vlGLUT::GLUTWindow | [protected, static]
glut_wmclose_func() | vlGLUT::GLUTWindow | [protected, static]
GLUTWindow() | vlGLUT::GLUTWindow |
GLUTWindow(const vl::String &title, const vl::OpenGLContextFormat &info, int x, int y, int width, int height) | vlGLUT::GLUTWindow |
handle() const | vlGLUT::GLUTWindow | [inline]
height() const | vl::OpenGLContext | [inline]
hide() | vlGLUT::GLUTWindow | [virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
initExtensions(bool log=true) | vl::OpenGLContext |
initGLUTWindow(const vl::String &title, const vl::OpenGLContextFormat &info, int x, int y, int width, int height) | vlGLUT::GLUTWindow |
initKeymap() | vlGLUT::GLUTWindow | [protected]
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlGLUT::GLUTWindow | [virtual]
mapAsciiKey(unsigned char ascii) | vlGLUT::GLUTWindow | [protected]
mapSpecialKey(int special_key) | vlGLUT::GLUTWindow | [protected, static]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mHandle | vlGLUT::GLUTWindow | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mInited | vlGLUT::GLUTWindow | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mKeymap | vlGLUT::GLUTWindow | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
mWinMap | vlGLUT::GLUTWindow | [protected, static]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vlGLUT::GLUTWindow | [virtual]
quitApplication() | vlGLUT::GLUTWindow | [inline, virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool fs) | vlGLUT::GLUTWindow | [virtual]
setMousePosition(int x, int y) | vlGLUT::GLUTWindow | [virtual]
setMouseVisible(bool visible) | vlGLUT::GLUTWindow | [virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlGLUT::GLUTWindow | [virtual]
setSize(int w, int h) | vlGLUT::GLUTWindow | [virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowTitle(const vl::String &title) | vlGLUT::GLUTWindow | [virtual]
show() | vlGLUT::GLUTWindow | [virtual]
size() const | vlGLUT::GLUTWindow | [virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlGLUT::GLUTWindow | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vlGLUT::GLUTWindow | [virtual]
updateModifiers() | vlGLUT::GLUTWindow | [protected]
updateOverlay() | vlGLUT::GLUTWindow |
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
~GLUTWindow() | vlGLUT::GLUTWindow | [inline]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: Member List

vlMFC::MFCWindow Member List

This is the complete list of members for vlMFC::MFCWindow, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
CountAndCapture() | vlMFC::MFCWindow | [protected]
CountAndRelease() | vlMFC::MFCWindow | [protected]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vlMFC::MFCWindow | [virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
destroyWindow() | vlMFC::MFCWindow |
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlWin32::Win32Context | [virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
hdc() const | vlWin32::Win32Context | [inline]
height() const | vl::OpenGLContext | [inline]
hglrc() const | vlWin32::Win32Context | [inline]
hide() | vlWin32::Win32Context | [virtual]
hwnd() const | vlMFC::MFCWindow | [inline, virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
init(HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x, int y, int width, int height) | vlWin32::Win32Context | [protected]
initExtensions(bool log=true) | vl::OpenGLContext |
initMFCWindow(CWnd *parent, MFCWindow *share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x=0, int y=0, int width=640, int height=480) | vlMFC::MFCWindow |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlWin32::Win32Context | [virtual]
mClassName | vlMFC::MFCWindow | [protected, static]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
MFCWindow() | vlMFC::MFCWindow | [inline]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mHDC | vlWin32::Win32Context | [protected]
mHGLRC | vlWin32::Win32Context | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseDownCount | vlMFC::MFCWindow | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mNormFlags | vlWin32::Win32Context | [protected]
mNormPosit | vlWin32::Win32Context | [protected]
mNormSize | vlWin32::Win32Context | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OnClose() | vlMFC::MFCWindow |
OnCreate(LPCREATESTRUCT lpCreateStruct) | vlMFC::MFCWindow |
OnDropFiles(HDROP hDropInfo) | vlMFC::MFCWindow |
OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) | vlMFC::MFCWindow |
OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) | vlMFC::MFCWindow |
OnLButtonDblClk(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnLButtonDown(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnLButtonUp(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnMButtonDblClk(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnMButtonDown(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnMButtonUp(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnMouseMove(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) | vlMFC::MFCWindow |
OnPaint() | vlMFC::MFCWindow |
OnRButtonDblClk(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnRButtonDown(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnRButtonUp(UINT nFlags, CPoint point) | vlMFC::MFCWindow |
OnSize(UINT nType, int cx, int cy) | vlMFC::MFCWindow |
OnTimer(UINT_PTR nIDEvent) | vlMFC::MFCWindow |
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vlWin32::Win32Context | [virtual]
quitApplication() | vlWin32::Win32Context | [virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool fullscreen_on) | vlWin32::Win32Context | [virtual]
setMousePosition(int x, int y) | vlWin32::Win32Context | [virtual]
setMouseVisible(bool visible) | vlWin32::Win32Context | [virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlWin32::Win32Context | [virtual]
setSize(int w, int h) | vlWin32::Win32Context | [virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowSize(int w, int h) | vlWin32::Win32Context |
setWindowTitle(const vl::String &title) | vlWin32::Win32Context | [virtual]
shareOpenGLResources(HGLRC hGLRC) | vlWin32::Win32Context |
show() | vlWin32::Win32Context | [virtual]
size() const | vlWin32::Win32Context | [virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlWin32::Win32Context | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vlWin32::Win32Context | [virtual]
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
Win32Context() | vlWin32::Win32Context | [inline]
Win32Context(int w, int h) | vlWin32::Win32Context | [inline]
windowSize() const | vlWin32::Win32Context |
~MFCWindow() | vlMFC::MFCWindow | [inline, virtual]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:22 2009.


Visualization Library: Member List

vlMolecule::Atom Member List

This is the complete list of members for vlMolecule::Atom, including all inherited members.

adjacentAtoms() const | vlMolecule::Atom | [inline]
adjacentAtoms() | vlMolecule::Atom | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
Atom() | vlMolecule::Atom | [inline]
Atom(const Atom &other) | vlMolecule::Atom | [inline]
atomName() const | vlMolecule::Atom | [inline]
atomType() const | vlMolecule::Atom | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::Object | [inline, virtual]
color() const | vlMolecule::Atom | [inline]
coordinates() const | vlMolecule::Atom | [inline]
decReference() | vl::Object | [inline]
id() const | vlMolecule::Atom | [inline]
incReference() | vl::Object | [inline]
isAtomAdjacent(Atom *atom) const | vlMolecule::Atom | [inline]
mAdjacentAtoms | vlMolecule::Atom | [protected]
mAtomName | vlMolecule::Atom | [protected]
mAtomType | vlMolecule::Atom | [protected]
mColor | vlMolecule::Atom | [protected]
mCoordinates | vlMolecule::Atom | [protected]
mId | vlMolecule::Atom | [protected]
mName | vl::Object | [protected]
mRadius | vlMolecule::Atom | [protected]
mShowAtomName | vlMolecule::Atom | [protected]
mVisible | vlMolecule::Atom | [protected]
mVisited | vlMolecule::Atom | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Atom &other) | vlMolecule::Atom | [inline]
vl::Object::operator=(const Object &other) | vl::Object | [inline]
radius() const | vlMolecule::Atom | [inline]
referenceCount() const | vl::Object | [inline]
setAtomName(const std::string &name) | vlMolecule::Atom | [inline]
setAtomType(EAtomType type) | vlMolecule::Atom | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setColor(const vl::fvec4 &color) | vlMolecule::Atom | [inline]
setCoordinates(const vl::fvec3 &coordinates) | vlMolecule::Atom | [inline]
setId(unsigned int id) | vlMolecule::Atom | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRadius(float radius) | vlMolecule::Atom | [inline]
setShowAtomName(bool show) | vlMolecule::Atom | [inline]
setVisible(bool visible) | vlMolecule::Atom | [inline]
setVisited(bool visited) | vlMolecule::Atom | [inline]
showAtomName() const | vlMolecule::Atom | [inline]
visible() const | vlMolecule::Atom | [inline]
visited() const | vlMolecule::Atom | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: Member List

vlMolecule::AtomInfo Member List

This is the complete list of members for vlMolecule::AtomInfo, including all inherited members.

atomicMass() const | vlMolecule::AtomInfo | [inline]
atomicNumber() const | vlMolecule::AtomInfo | [inline]
AtomInfo(EAtomType type, const char *name, const char *symbol, int atomic_num, double atomic_mass, double melting_pt, double boiling_pt, double electroneg, double electron_aff, int valence, double calculated_r, double empirical_r, double covalent_r, double vdw_r, unsigned int cpk_color, unsigned int rasmol_color) | vlMolecule::AtomInfo | [inline]
boilingPoint() const | vlMolecule::AtomInfo | [inline]
calculatedRadius() const | vlMolecule::AtomInfo | [inline]
covalentRadius() const | vlMolecule::AtomInfo | [inline]
cpkColor() const | vlMolecule::AtomInfo | [inline]
electronAffinity() const | vlMolecule::AtomInfo | [inline]
electronegativity() const | vlMolecule::AtomInfo | [inline]
empiricalRadius() const | vlMolecule::AtomInfo | [inline]
mAtomicMass | vlMolecule::AtomInfo | [protected]
mAtomicNumber | vlMolecule::AtomInfo | [protected]
mBoilingPoint | vlMolecule::AtomInfo | [protected]
mCalculatedRadius | vlMolecule::AtomInfo | [protected]
mCovalentRadius | vlMolecule::AtomInfo | [protected]
mCPKColor | vlMolecule::AtomInfo | [protected]
mElectronAffinity | vlMolecule::AtomInfo | [protected]
mElectronegativity | vlMolecule::AtomInfo | [protected]
meltingPoint() const | vlMolecule::AtomInfo | [inline]
mEmpiricalRadius | vlMolecule::AtomInfo | [protected]
mMeltingPoint | vlMolecule::AtomInfo | [protected]
mName | vlMolecule::AtomInfo | [protected]
mRasMolColor | vlMolecule::AtomInfo | [protected]
mSymbol | vlMolecule::AtomInfo | [protected]
mType | vlMolecule::AtomInfo | [protected]
mValence | vlMolecule::AtomInfo | [protected]
mVanDerWaalsRadius | vlMolecule::AtomInfo | [protected]
name() const | vlMolecule::AtomInfo | [inline]
rasmolColor() const | vlMolecule::AtomInfo | [inline]
symbol() const | vlMolecule::AtomInfo | [inline]
type() const | vlMolecule::AtomInfo | [inline]
valence() const | vlMolecule::AtomInfo | [inline]
vanDerWaalsRadius() const | vlMolecule::AtomInfo | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: Member List

vlMolecule::Bond Member List

This is the complete list of members for vlMolecule::Bond, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
atom1() const | vlMolecule::Bond | [inline]
atom2() const | vlMolecule::Bond | [inline]
automaticDelete() const | vl::Object | [inline]
Bond() | vlMolecule::Bond | [inline]
Bond(const Bond &other) | vlMolecule::Bond | [inline]
bondType() const | vlMolecule::Bond | [inline]
className() | vl::Object | [inline, virtual]
color() const | vlMolecule::Bond | [inline]
decReference() | vl::Object | [inline]
id() const | vlMolecule::Bond | [inline]
incReference() | vl::Object | [inline]
mAtom1 | vlMolecule::Bond | [protected]
mAtom2 | vlMolecule::Bond | [protected]
mColor | vlMolecule::Bond | [protected]
mId | vlMolecule::Bond | [protected]
mName | vl::Object | [protected]
mRadius | vlMolecule::Bond | [protected]
mType | vlMolecule::Bond | [protected]
mUseAtomColors | vlMolecule::Bond | [protected]
mVisible | vlMolecule::Bond | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
radius() const | vlMolecule::Bond | [inline]
referenceCount() const | vl::Object | [inline]
setAtom1(Atom *atom) | vlMolecule::Bond | [inline]
setAtom2(Atom *atom) | vlMolecule::Bond | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBondType(EBondType type) | vlMolecule::Bond | [inline]
setColor(const vl::fvec4 &color) | vlMolecule::Bond | [inline]
setId(unsigned int id) | vlMolecule::Bond | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRadius(float radius) | vlMolecule::Bond | [inline]
setUseAtomColors(bool use_atom_color) | vlMolecule::Bond | [inline]
setVisible(bool visible) | vlMolecule::Bond | [inline]
useAtomColors() const | vlMolecule::Bond | [inline]
visible() const | vlMolecule::Bond | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: Member List

vlMolecule::Molecule Member List

This is the complete list of members for vlMolecule::Molecule, including all inherited members.

actorTree() const | vlMolecule::Molecule | [inline]
actorTree() | vlMolecule::Molecule | [inline]
addAtom(Atom *atom) | vlMolecule::Molecule |
addBond(Bond *bond) | vlMolecule::Molecule |
addBond(Atom *a1, Atom *a2) | vlMolecule::Molecule |
aromaticRingColor() const | vlMolecule::Molecule | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
atom(int index) const | vlMolecule::Molecule |
atomCount() const | vlMolecule::Molecule | [inline]
atomDetail() const | vlMolecule::Molecule | [inline]
atomLabelEffect() const | vlMolecule::Molecule | [inline]
atomLabelEffect() | vlMolecule::Molecule | [inline]
atomLabelTemplate() | vlMolecule::Molecule | [inline]
atomLabelTemplate() const | vlMolecule::Molecule | [inline]
atoms() const | vlMolecule::Molecule | [inline]
atoms() | vlMolecule::Molecule | [inline]
atomsStyle() | vlMolecule::Molecule | [protected]
automaticDelete() const | vl::Object | [inline]
ballAndStickStyle() | vlMolecule::Molecule | [protected]
bond(int index) const | vlMolecule::Molecule |
bond(Atom *a1, Atom *a2) | vlMolecule::Molecule |
bondCount() const | vlMolecule::Molecule | [inline]
bondDetail() const | vlMolecule::Molecule | [inline]
bonds() const | vlMolecule::Molecule | [inline]
bonds() | vlMolecule::Molecule | [inline]
className() | vl::Object | [inline, virtual]
computeAtomAdjacency() | vlMolecule::Molecule |
cycle(int i) const | vlMolecule::Molecule | [inline]
cycle(int i) | vlMolecule::Molecule | [inline]
cycles() const | vlMolecule::Molecule | [inline]
cycles() | vlMolecule::Molecule | [inline]
decReference() | vl::Object | [inline]
eraseAllAtoms() | vlMolecule::Molecule |
eraseAllBonds() | vlMolecule::Molecule |
eraseAtom(Atom *atom) | vlMolecule::Molecule |
eraseAtom(int index) | vlMolecule::Molecule |
eraseBond(Bond *bond) | vlMolecule::Molecule |
eraseBond(int bond) | vlMolecule::Molecule |
eraseBond(Atom *a1, Atom *a2) | vlMolecule::Molecule |
eraseBond(int a1, int a2) | vlMolecule::Molecule |
generateAtomLabel(const Atom *atom, vl::Transform *tr) | vlMolecule::Molecule | [protected]
generateAtomLabels() | vlMolecule::Molecule | [protected]
generateRings() | vlMolecule::Molecule | [protected]
id() const | vlMolecule::Molecule | [inline]
incidentBonds(std::vector< Bond * > &inc_bonds, Atom *atom) | vlMolecule::Molecule |
incReference() | vl::Object | [inline]
lineWidth() const | vlMolecule::Molecule | [inline]
mActorTree | vlMolecule::Molecule | [protected]
mAromaticRingColor | vlMolecule::Molecule | [protected]
mAtomDetail | vlMolecule::Molecule | [protected]
mAtomLabelEffect | vlMolecule::Molecule | [protected]
mAtomLabelTemplate | vlMolecule::Molecule | [protected]
mAtoms | vlMolecule::Molecule | [protected]
mBondDetail | vlMolecule::Molecule | [protected]
mBonds | vlMolecule::Molecule | [protected]
mCycles | vlMolecule::Molecule | [protected]
mId | vlMolecule::Molecule | [protected]
mLineWidth | vlMolecule::Molecule | [protected]
mMoleculeName | vlMolecule::Molecule | [protected]
mMoleculeStyle | vlMolecule::Molecule | [protected]
mName | vl::Object | [protected]
Molecule() | vlMolecule::Molecule |
Molecule(const Molecule &other) | vlMolecule::Molecule | [inline]
moleculeName() const | vlMolecule::Molecule | [inline]
moleculeStyle() const | vlMolecule::Molecule | [inline]
mRingOffset | vlMolecule::Molecule | [protected]
mShowAtomNames | vlMolecule::Molecule | [protected]
mSmoothLines | vlMolecule::Molecule | [protected]
mTags | vlMolecule::Molecule | [protected]
mTransformTree | vlMolecule::Molecule | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Molecule &other) | vlMolecule::Molecule |
vl::Object::operator=(const Object &other) | vl::Object | [inline]
prepareAtomInsert(int bonus=100) | vlMolecule::Molecule | [inline, protected]
prepareBondInsert(int bonus=100) | vlMolecule::Molecule | [inline, protected]
prepareForRendering() | vlMolecule::Molecule |
referenceCount() const | vl::Object | [inline]
reset() | vlMolecule::Molecule |
ringOffset() const | vlMolecule::Molecule | [inline]
setAromaticBondsColor(const vl::fvec4 &color) | vlMolecule::Molecule |
setAromaticRingColor(const vl::fvec4 &color) | vlMolecule::Molecule | [inline]
setAtomColors(const vl::fvec4 &color) | vlMolecule::Molecule |
setAtomDetail(int detail) | vlMolecule::Molecule | [inline]
setAtomRadii(float radius) | vlMolecule::Molecule |
setAtomTypeVisible(EAtomType type, bool visible) | vlMolecule::Molecule |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBondDetail(int detail) | vlMolecule::Molecule | [inline]
setBondRadii(float radius) | vlMolecule::Molecule |
setCalculatedAtomRadii(float percentage=1.0f) | vlMolecule::Molecule |
setCovalentAtomRadii(float percentage=1.0f) | vlMolecule::Molecule |
setCPKAtomColors() | vlMolecule::Molecule |
setEmpiricalAtomRadii(float percentage=1.0f) | vlMolecule::Molecule |
setId(unsigned int id) | vlMolecule::Molecule | [inline]
setLineWidth(float w) | vlMolecule::Molecule | [inline]
setMoleculeName(const std::string &name) | vlMolecule::Molecule | [inline]
setMoleculeStyle(EMoleculeStyle style) | vlMolecule::Molecule | [inline]
setName(const std::string &name) | vl::Object | [inline]
setRingOffset(float offset) | vlMolecule::Molecule | [inline]
setShowAtomNames(bool show) | vlMolecule::Molecule | [inline]
setSmoothLines(bool smooth) | vlMolecule::Molecule | [inline]
setVanDerWaalsAtomRadii(float percentage=1.0f) | vlMolecule::Molecule |
showAtomNames() const | vlMolecule::Molecule | [inline]
smoothLines() const | vlMolecule::Molecule | [inline]
sticksStyle() | vlMolecule::Molecule | [protected]
tags() | vlMolecule::Molecule | [inline]
tags() const | vlMolecule::Molecule | [inline]
transformTree() | vlMolecule::Molecule | [inline]
transformTree() const | vlMolecule::Molecule | [inline]
wireframeStyle() | vlMolecule::Molecule | [protected]
~Molecule() | vlMolecule::Molecule | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: Member List

vlMolecule::RingExtractor Member List

This is the complete list of members for vlMolecule::RingExtractor, including all inherited members.

bootstrap() | vlMolecule::RingExtractor | [inline]
depthFirstVisit(Atom *atom, std::vector< vl::ref< Atom > > &current_path) | vlMolecule::RingExtractor | [inline]
keepAromaticCycles() | vlMolecule::RingExtractor | [inline]
keepMinimalCycles() | vlMolecule::RingExtractor | [inline]
keepPlanarCycles(float epsilon) | vlMolecule::RingExtractor | [inline]
mMolecule | vlMolecule::RingExtractor | [protected]
molecule() const | vlMolecule::RingExtractor | [inline]
removeDoubles() | vlMolecule::RingExtractor | [inline]
RingExtractor(Molecule *mol) | vlMolecule::RingExtractor | [inline]
run() | vlMolecule::RingExtractor | [inline]
setMolecule(Molecule *mol) | vlMolecule::RingExtractor | [inline]
sortCycles() | vlMolecule::RingExtractor | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:23 2009.


Visualization Library: Member List

vlQt4::Qt4Widget Member List

This is the complete list of members for vlQt4::Qt4Widget, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vlQt4::Qt4Widget | [inline, virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
dragEnterEvent(QDragEnterEvent *ev) | vlQt4::Qt4Widget | [inline]
dropEvent(QDropEvent *ev) | vlQt4::Qt4Widget | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlQt4::Qt4Widget | [inline, virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
height() const | vl::OpenGLContext | [inline]
hide() | vlQt4::Qt4Widget | [inline, virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
initExtensions(bool log=true) | vl::OpenGLContext |
initializeGL() | vlQt4::Qt4Widget | [inline]
initQt4Widget(const vl::String &title, const vl::OpenGLContextFormat &info, const QGLContext *shareContext=0, int x=0, int y=0, int width=640, int height=480) | vlQt4::Qt4Widget | [inline]
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyPressEvent(QKeyEvent *ev) | vlQt4::Qt4Widget | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
keyReleaseEvent(QKeyEvent *ev) | vlQt4::Qt4Widget | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlQt4::Qt4Widget | [inline, virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mouseMoveEvent(QMouseEvent *ev) | vlQt4::Qt4Widget | [inline]
mousePressEvent(QMouseEvent *ev) | vlQt4::Qt4Widget | [inline]
mouseReleaseEvent(QMouseEvent *ev) | vlQt4::Qt4Widget | [inline]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
mUpdateTimer | vlQt4::Qt4Widget | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
paintGL() | vlQt4::Qt4Widget | [inline]
position() const | vlQt4::Qt4Widget | [inline, virtual]
Qt4Widget(QWidget *parent=NULL, const QGLWidget *shareWidget=NULL, Qt::WindowFlags f=0) | vlQt4::Qt4Widget | [inline]
quitApplication() | vlQt4::Qt4Widget | [inline, virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
resizeGL(int width, int height) | vlQt4::Qt4Widget | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vlQt4::Qt4Widget | [inline, virtual]
setFullscreen(bool fullscreen) | vlQt4::Qt4Widget | [inline, virtual]
setMousePosition(int x, int y) | vlQt4::Qt4Widget | [inline, virtual]
setMouseVisible(bool visible) | vlQt4::Qt4Widget | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlQt4::Qt4Widget | [inline, virtual]
setSize(int w, int h) | vlQt4::Qt4Widget | [inline, virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowTitle(const vl::String &title) | vlQt4::Qt4Widget | [inline, virtual]
show() | vlQt4::Qt4Widget | [inline, virtual]
size() const | vlQt4::Qt4Widget | [inline, virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlQt4::Qt4Widget | [inline, virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
translateKeyEvent(QKeyEvent *ev, unsigned short &unicode_out, vl::EKey &key_out) | vlQt4::Qt4Widget | [protected]
update() | vlQt4::Qt4Widget | [inline, virtual]
vsyncEnabled() const | vl::OpenGLContext |
wheelEvent(QWheelEvent *ev) | vlQt4::Qt4Widget | [inline]
width() const | vl::OpenGLContext | [inline]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: Member List

vlSDL::SDLWindow Member List

This is the complete list of members for vlSDL::SDLWindow, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vlSDL::SDLWindow | [virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vl::OpenGLContext | [inline, virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
height() const | vl::OpenGLContext | [inline]
hide() | vl::OpenGLContext | [inline, virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
initExtensions(bool log=true) | vl::OpenGLContext |
initSDLWindow(const vl::String &title, const vl::OpenGLContextFormat &info, int x=0, int y=0, int width=640, int height=480) | vlSDL::SDLWindow |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlSDL::SDLWindow | [inline, virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mScreen | vlSDL::SDLWindow | [protected, static]
mTextureUnitCount | vl::OpenGLContext | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vl::OpenGLContext | [inline, virtual]
quitApplication() | vlSDL::SDLWindow | [virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
sdlSurface() | vlSDL::SDLWindow | [inline, static]
SDLWindow() | vlSDL::SDLWindow |
SDLWindow(const vl::String &title, const vl::OpenGLContextFormat &info, int x=0, int y=0, int width=640, int height=480) | vlSDL::SDLWindow |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool) | vl::OpenGLContext | [inline, virtual]
setMousePosition(int x, int y) | vlSDL::SDLWindow | [inline, virtual]
setMouseVisible(bool visible) | vlSDL::SDLWindow | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlSDL::SDLWindow | [virtual]
setSize(int, int) | vl::OpenGLContext | [inline, virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowTitle(const vl::String &) | vlSDL::SDLWindow | [virtual]
show() | vl::OpenGLContext | [inline, virtual]
size() const | vl::OpenGLContext | [inline, virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlSDL::SDLWindow | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
translateEvent(SDL_Event *ev) | vlSDL::SDLWindow |
update() | vlSDL::SDLWindow | [virtual]
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]
~SDLWindow() | vlSDL::SDLWindow |

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: Member List

vlVG::SceneManagerVectorGraphics Member List

This is the complete list of members for vlVG::SceneManagerVectorGraphics, including all inherited members.

actorRenderRankStart() const | vlVG::SceneManagerVectorGraphics | [inline]
appendActors(vl::ActorCollection &queue) | vlVG::SceneManagerVectorGraphics | [inline, virtual]
appendVisibleActors(vl::ActorCollection &queue, const vl::Camera *) | vlVG::SceneManagerVectorGraphics | [inline, virtual]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::SceneManager | [inline]
boundingSphere() const | vl::SceneManager | [inline]
boundsDirty() const | vl::SceneManager | [inline]
className() | vlVG::SceneManagerVectorGraphics | [inline, virtual]
computeBounds() | vl::SceneManager | [virtual]
cullingEnabled() const | vl::SceneManager | [inline]
decReference() | vl::Object | [inline]
enableMask() const | vl::SceneManager | [inline]
incReference() | vl::Object | [inline]
isEnabled(Actor *a) | vl::SceneManager | [inline]
mAABB | vl::SceneManager | [protected]
mActorRenderRankStart | vlVG::SceneManagerVectorGraphics | [protected]
mBoundsDirty | vl::SceneManager | [protected]
mCullingEnabled | vl::SceneManager | [protected]
mEnableMask | vl::SceneManager | [protected]
mName | vl::Object | [protected]
mSphere | vl::SceneManager | [protected]
mVectorGraphicObjects | vlVG::SceneManagerVectorGraphics | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
SceneManager() | vl::SceneManager |
SceneManagerVectorGraphics() | vlVG::SceneManagerVectorGraphics | [inline]
setActorRenderRankStart(int rank_start) | vlVG::SceneManagerVectorGraphics | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBoundingBox(const AABB &bbox) | vl::SceneManager | [inline]
setBoundingSphere(const Sphere &sphere) | vl::SceneManager | [inline]
setBoundsDirty(bool dirty) | vl::SceneManager | [inline]
setCullingEnabled(bool enable) | vl::SceneManager | [inline]
setEnableMask(unsigned int enabled) | vl::SceneManager | [inline]
setName(const std::string &name) | vl::Object | [inline]
vectorGraphicObjects() | vlVG::SceneManagerVectorGraphics | [inline]
vectorGraphicObjects() const | vlVG::SceneManagerVectorGraphics | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: Member List

vlVG::VectorGraphics Member List

This is the complete list of members for vlVG::VectorGraphics, including all inherited members.

actors() const | vlVG::VectorGraphics | [inline]
actors() | vlVG::VectorGraphics | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vlVG::VectorGraphics | [inline, virtual]
clear() | vlVG::VectorGraphics | [inline]
clearColor(const vl::fvec4 &color, int x=0, int y=0, int w=-1, int h=-1) | vlVG::VectorGraphics | [inline]
clearStencil(int clear_val, int x=0, int y=0, int w=-1, int h=-1) | vlVG::VectorGraphics | [inline]
color() const | vlVG::VectorGraphics | [inline]
colorMask() const | vlVG::VectorGraphics | [inline]
continueDrawing() | vlVG::VectorGraphics | [inline]
currentEffect() | vlVG::VectorGraphics | [inline]
decReference() | vl::Object | [inline]
drawActor(vl::Actor *actor, vl::Transform *transform=NULL, bool keep_effect=false) | vlVG::VectorGraphics | [inline]
drawActorCopy(vl::Actor *actor, vl::Transform *transform=NULL) | vlVG::VectorGraphics | [inline]
drawEllipse(double origx, double origy, double xaxis, double yaxis, int segments=64) | vlVG::VectorGraphics | [inline]
drawLine(double x1, double y1, double x2, double y2) | vlVG::VectorGraphics | [inline]
drawLineLoop(const std::vector< vl::dvec2 > &ln) | vlVG::VectorGraphics | [inline]
drawLines(const std::vector< vl::dvec2 > &ln) | vlVG::VectorGraphics | [inline]
drawLineStrip(const std::vector< vl::dvec2 > &ln) | vlVG::VectorGraphics | [inline]
drawPoint(double x, double y) | vlVG::VectorGraphics | [inline]
drawPoints(const std::vector< vl::dvec2 > &pt) | vlVG::VectorGraphics | [inline]
drawQuad(double left, double bottom, double right, double top) | vlVG::VectorGraphics | [inline]
drawText(vl::Text *text) | vlVG::VectorGraphics | [inline]
drawText(int x, int y, const vl::String &text, int alignment=vl::AlignBottom|vl::AlignLeft) | vlVG::VectorGraphics | [inline]
drawText(const vl::String &text, int alignment=vl::AlignBottom|vl::AlignLeft) | vlVG::VectorGraphics | [inline]
endDrawing(bool release_cache=true) | vlVG::VectorGraphics | [inline]
fillEllipse(double origx, double origy, double xaxis, double yaxis, int segments=64) | vlVG::VectorGraphics | [inline]
fillPolygon(const std::vector< vl::dvec2 > &poly) | vlVG::VectorGraphics | [inline]
fillQuad(double left, double bottom, double right, double top) | vlVG::VectorGraphics | [inline]
fillQuads(const std::vector< vl::dvec2 > &quads) | vlVG::VectorGraphics | [inline]
fillQuadStrip(const std::vector< vl::dvec2 > &quad_strip) | vlVG::VectorGraphics | [inline]
fillTriangleFan(const std::vector< vl::dvec2 > &fan) | vlVG::VectorGraphics | [inline]
fillTriangles(const std::vector< vl::dvec2 > &triangles) | vlVG::VectorGraphics | [inline]
fillTriangleStrip(const std::vector< vl::dvec2 > &strip) | vlVG::VectorGraphics | [inline]
font() const | vlVG::VectorGraphics | [inline]
getAlphaFunc(vl::EFunction &func, float &ref_value) const | vlVG::VectorGraphics | [inline]
getBlendEquation(vl::EBlendEquation &rgb_eq, vl::EBlendEquation &alpha_eq) const | vlVG::VectorGraphics | [inline]
getBlendFunc(vl::EBlendFactor &src_rgb, vl::EBlendFactor &dst_rgb, vl::EBlendFactor &src_alpha, vl::EBlendFactor &dst_alpha) const | vlVG::VectorGraphics | [inline]
getStencilFunc(vl::EFunction &func, int &refval, unsigned int &mask) | vlVG::VectorGraphics | [inline]
getStencilOp(vl::EStencilOp &sfail, vl::EStencilOp &dpfail, vl::EStencilOp &dppass) | vlVG::VectorGraphics | [inline]
image() const | vlVG::VectorGraphics | [inline]
image() | vlVG::VectorGraphics | [inline]
incReference() | vl::Object | [inline]
lineSmoothing() const | vlVG::VectorGraphics | [inline]
lineStipple() const | vlVG::VectorGraphics | [inline]
lineWidth() const | vlVG::VectorGraphics | [inline]
logicOp() const | vlVG::VectorGraphics | [inline]
matrix() const | vlVG::VectorGraphics | [inline]
matrixStack() const | vlVG::VectorGraphics | [inline]
mName | vl::Object | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
pointSize() const | vlVG::VectorGraphics | [inline]
pointSmoothing() const | vlVG::VectorGraphics | [inline]
polygonSmoothing() const | vlVG::VectorGraphics | [inline]
polygonStipple() const | vlVG::VectorGraphics | [inline]
polygonStipple() | vlVG::VectorGraphics | [inline]
popMatrix() | vlVG::VectorGraphics | [inline]
popScissor() | vlVG::VectorGraphics | [inline]
popState() | vlVG::VectorGraphics | [inline]
pushMatrix() | vlVG::VectorGraphics | [inline]
pushScissor(int x, int y, int w, int h) | vlVG::VectorGraphics | [inline]
pushState() | vlVG::VectorGraphics | [inline]
referenceCount() const | vl::Object | [inline]
removeScissor() | vlVG::VectorGraphics | [inline]
resetMatrix() | vlVG::VectorGraphics | [inline]
rotate(double deg) | vlVG::VectorGraphics | [inline]
scale(double x, double y, double z=1.0) | vlVG::VectorGraphics | [inline]
scissor() const | vlVG::VectorGraphics | [inline]
scissorStack() const | vlVG::VectorGraphics | [inline]
setAlphaFunc(vl::EFunction func, float ref_value) | vlVG::VectorGraphics | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBlendEquation(vl::EBlendEquation rgb_eq, vl::EBlendEquation alpha_eq) | vlVG::VectorGraphics | [inline]
setBlendFunc(vl::EBlendFactor src_rgb, vl::EBlendFactor dst_rgb, vl::EBlendFactor src_alpha, vl::EBlendFactor dst_alpha) | vlVG::VectorGraphics | [inline]
setColor(const vl::fvec4 &color) | vlVG::VectorGraphics | [inline]
setColorMask(bool r, bool g, bool b, bool a) | vlVG::VectorGraphics | [inline]
setDefaultFont() | vlVG::VectorGraphics | [inline]
setFont(const vl::String &name, int size, bool smooth=false) | vlVG::VectorGraphics | [inline]
setFont(const vl::Font *font) | vlVG::VectorGraphics | [inline]
setImage(vl::Image *image) | vlVG::VectorGraphics | [inline]
setLineSmoothing(bool smooth) | vlVG::VectorGraphics | [inline]
setLineStipple(ELineStipple stipple) | vlVG::VectorGraphics | [inline]
setLineStipple(unsigned short stipple) | vlVG::VectorGraphics | [inline]
setLineWidth(float width) | vlVG::VectorGraphics | [inline]
setLogicOp(vl::ELogicOp op) | vlVG::VectorGraphics | [inline]
setMatrix(const vl::dmat4 &matrix) | vlVG::VectorGraphics | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPoint(vl::Image *image) | vlVG::VectorGraphics | [inline]
setPointSize(int size) | vlVG::VectorGraphics | [inline]
setPointSmoothing(bool smooth) | vlVG::VectorGraphics | [inline]
setPolygonSmoothing(bool smooth) | vlVG::VectorGraphics | [inline]
setPolygonStipple(EPolygonStipple stipple) | vlVG::VectorGraphics | [inline]
setPolygonStipple(unsigned char *stipple) | vlVG::VectorGraphics | [inline]
setScissor(int x, int y, int width, int height) | vlVG::VectorGraphics | [inline]
setStencilFunc(vl::EFunction func, int refval, unsigned int mask) | vlVG::VectorGraphics | [inline]
setStencilMask(unsigned int mask) | vlVG::VectorGraphics | [inline]
setStencilOp(vl::EStencilOp sfail, vl::EStencilOp dpfail, vl::EStencilOp dppass) | vlVG::VectorGraphics | [inline]
setStencilTestEnabled(bool enabled) | vlVG::VectorGraphics | [inline]
setTextureMode(ETextureMode mode) | vlVG::VectorGraphics | [inline]
setTransform(vl::Transform *transform) | vlVG::VectorGraphics | [inline]
startDrawing() | vlVG::VectorGraphics | [inline]
stencilMask() const | vlVG::VectorGraphics | [inline]
stencilTestEnabled() const | vlVG::VectorGraphics | [inline]
textureMode() const | vlVG::VectorGraphics | [inline]
translate(double x, double y, double z=0.0) | vlVG::VectorGraphics | [inline]
VectorGraphics() | vlVG::VectorGraphics | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: Member List

vlVolume::MarchingCubes Member List

This is the complete list of members for vlVolume::MarchingCubes, including all inherited members.

computeEdges(Volume *, float threshold) | vlVolume::MarchingCubes | [protected]
highQualityNormals() const | vlVolume::MarchingCubes | [inline]
MarchingCubes() | vlVolume::MarchingCubes |
mColorArray | vlVolume::MarchingCubes |
mCubeEdgeFlags | vlVolume::MarchingCubes | [protected, static]
mDrawElements | vlVolume::MarchingCubes |
mNormsArray | vlVolume::MarchingCubes |
mTriangleConnectionTable | vlVolume::MarchingCubes | [protected, static]
mVertsArray | vlVolume::MarchingCubes |
processCube(int x, int y, int z, Volume *vol, float threshold) | vlVolume::MarchingCubes | [protected]
reset() | vlVolume::MarchingCubes |
run(bool generate_colors) | vlVolume::MarchingCubes |
setHighQualityNormals(bool hq) | vlVolume::MarchingCubes | [inline]
updateAlpha(float alpha, int volume_index) | vlVolume::MarchingCubes |
updateColor(const vl::fvec3 &color, int volume_index) | vlVolume::MarchingCubes |
updateColor(const vl::fvec4 &color, int volume_index) | vlVolume::MarchingCubes |
volumeInfo() const | vlVolume::MarchingCubes | [inline]
volumeInfo() | vlVolume::MarchingCubes | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlVolume::SlicedVolume Member List

This is the complete list of members for vlVolume::SlicedVolume, including all inherited members.

Actor(Renderable *renderable=NULL, Effect *effect=NULL, Transform *transform=NULL, int block=0, int rank=0) | vl::Actor | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boundingBox() const | vl::Actor | [inline]
boundingSphere() const | vl::Actor | [inline]
box() const | vlVolume::SlicedVolume | [inline]
className() | vl::Actor | [inline, virtual]
computeBounds() | vl::Actor |
createOcclusionQuery() | vl::Actor |
decReference() | vl::Object | [inline]
deleteOcclusionQuery() | vl::Actor |
effect() | vlVolume::SlicedVolume | [inline]
effect() const | vlVolume::SlicedVolume | [inline]
enableMask() const | vl::Actor | [inline]
eraseAllUniforms() | vl::Actor | [inline]
eraseUniform(const std::string &name) | vl::Actor | [inline]
eraseUniform(const Uniform *uniform) | vl::Actor | [inline]
evaluateLOD(Camera *camera) | vl::Actor |
executeRenderingCallbacks(const Camera *camera, Renderable *renderable, const Shader *shader, int pass) | vl::Actor | [inline]
generateTextureCoordinates(const vl::ivec3 &size) | vlVolume::SlicedVolume |
generateTextureCoordinates(int width, int height, int depth) | vlVolume::SlicedVolume | [inline]
genRGBAVolume(vl::Image *data, vl::Image *trfunc, const vl::fvec3 &light_dir, bool alpha_from_data=true) | vlVolume::SlicedVolume | [static]
genRGBAVolume(vl::Image *data, vl::Image *trfunc, bool alpha_from_data=true) | vlVolume::SlicedVolume | [static]
geometry() | vlVolume::SlicedVolume | [inline]
geometry() const | vlVolume::SlicedVolume | [inline]
getUniform(const std::string &name) | vl::Actor | [inline]
getUniform(const std::string &name) const | vl::Actor | [inline]
glslProgram() const | vlVolume::SlicedVolume | [inline]
glslProgram() | vlVolume::SlicedVolume | [inline]
gocUniform(const std::string &name) | vl::Actor | [inline]
incReference() | vl::Object | [inline]
isOccludee() const | vl::Actor | [inline]
lastUpdateTime() const | vl::Actor | [inline]
light() const | vlVolume::SlicedVolume | [inline]
light() | vlVolume::SlicedVolume | [inline]
lod(int lod_index) | vl::Actor | [inline]
lod(int lod_index) const | vl::Actor | [inline]
lodEvaluator() | vl::Actor | [inline]
lodEvaluator() const | vl::Actor | [inline]
mAABB | vl::Actor | [protected]
mBoundsUpdateTick | vl::Actor | [protected]
mBox | vlVolume::SlicedVolume | [protected]
mCache | vlVolume::SlicedVolume | [protected]
mEffect | vlVolume::SlicedVolume | [protected]
mEnableMask | vl::Actor | [protected]
mGeometry | vlVolume::SlicedVolume | [protected]
mGLSLProgram | vlVolume::SlicedVolume | [protected]
mIsOccludee | vl::Actor | [protected]
mLastUpdateTime | vl::Actor | [protected]
mLight | vlVolume::SlicedVolume | [protected]
mLODEvaluator | vl::Actor | [protected]
mName | vl::Object | [protected]
mOcclusionQuery | vl::Actor | [protected]
mOcclusionQueryTick | vl::Actor | [protected]
mRenderables | vl::Actor | [protected]
mRenderBlock | vl::Actor | [protected]
mRenderingCallbacks | vl::Actor | [protected]
mRenderRank | vl::Actor | [protected]
mScissor | vl::Actor | [protected]
mSliceCount | vlVolume::SlicedVolume | [protected]
mSphere | vl::Actor | [protected]
mTexCoord | vlVolume::SlicedVolume | [protected]
mTransferFunction | vlVolume::SlicedVolume | [protected]
mTransform | vl::Actor | [protected]
mTransformUpdateTick | vl::Actor | [protected]
mUniformSet | vl::Actor | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
occlusionQuery() const | vl::Actor | [inline]
occlusionQueryTick() const | vl::Actor | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
renderBlock() const | vl::Actor | [inline]
renderingCallbacks() const | vl::Actor | [inline]
renderingCallbacks() | vl::Actor | [inline]
renderRank() const | vl::Actor | [inline]
scissor() const | vl::Actor | [inline]
scissor() | vl::Actor | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setBox(const vl::AABB &box) | vlVolume::SlicedVolume |
setEffect(Effect *effect) | vl::Actor | [inline]
setEnableMask(unsigned int mask) | vl::Actor | [inline]
setLastUpdateTime(Real time) | vl::Actor | [inline]
setLight(vl::Light *light) | vlVolume::SlicedVolume | [inline]
setLODEvaluator(LODEvaluator *lod_evaluator) | vl::Actor | [inline]
setLODs(Renderable *lod0, Renderable *lod1=NULL, Renderable *lod2=NULL, Renderable *lod3=NULL, Renderable *lod4=NULL, Renderable *lod5=NULL) | vl::Actor | [inline]
setName(const std::string &name) | vl::Object | [inline]
setOccludee(bool is_occludee) | vl::Actor | [inline]
setOcclusionQueryTick(unsigned tick) | vl::Actor | [inline]
setRenderBlock(int block) | vl::Actor | [inline]
setRenderRank(int rank) | vl::Actor | [inline]
setScissor(Scissor *scissor) | vl::Actor | [inline]
setSliceCount(int count) | vlVolume::SlicedVolume | [inline]
setTransferFunction(vl::Image *tfunc) | vlVolume::SlicedVolume |
setTransform(Transform *transform) | vl::Actor | [inline]
setUniform(Uniform *uniform) | vl::Actor | [inline]
setUniformSet(UniformSet *uniforms) | vl::Actor | [inline]
setVolumeImage(vl::Image *volume) | vlVolume::SlicedVolume |
sliceCount() const | vlVolume::SlicedVolume | [inline]
SlicedVolume() | vlVolume::SlicedVolume |
texCoords() const | vlVolume::SlicedVolume | [inline]
texCoords() | vlVolume::SlicedVolume | [inline]
transferFunction() const | vlVolume::SlicedVolume | [inline]
transferFunction() | vlVolume::SlicedVolume | [inline]
transform() | vl::Actor | [inline]
transform() const | vl::Actor | [inline]
uniforms() const | vl::Actor | [inline]
uniformSet() const | vl::Actor | [inline]
update(int, vl::Camera *camera, vl::Real) | vlVolume::SlicedVolume | [virtual]
updateUniforms(vl::Camera *camera) | vlVolume::SlicedVolume | [virtual]
~Actor() | vl::Actor | [virtual]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlVolume::Volume Member List

This is the complete list of members for vlVolume::Volume, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
average() const | vlVolume::Volume | [inline]
bottomLeft() const | vlVolume::Volume | [inline]
cellSize() const | vlVolume::Volume | [inline]
className() | vlVolume::Volume | [inline, virtual]
computeAverage() const | vlVolume::Volume |
computeMaximum() const | vlVolume::Volume |
computeMinimum() const | vlVolume::Volume |
coordinate(int x, int y, int z) const | vlVolume::Volume | [inline]
cube(int x, int y, int z) const | vlVolume::Volume | [inline]
dataIsDirty() const | vlVolume::Volume | [inline]
decReference() | vl::Object | [inline]
downsample() const | vlVolume::Volume |
incReference() | vl::Object | [inline]
mAverage | vlVolume::Volume | [protected]
maximum() const | vlVolume::Volume | [inline]
mBottomLeft | vlVolume::Volume | [protected]
mCellSize | vlVolume::Volume | [protected]
mCubes | vlVolume::Volume | [protected]
mDataIsDirty | vlVolume::Volume | [protected]
minimum() const | vlVolume::Volume | [inline]
mMaximum | vlVolume::Volume | [protected]
mMinimum | vlVolume::Volume | [protected]
mName | vl::Object | [protected]
mSize | vlVolume::Volume | [protected]
mSlices | vlVolume::Volume | [protected]
mTopRight | vlVolume::Volume | [protected]
mValues | vlVolume::Volume | [protected]
name() const | vl::Object | [inline]
normalHQ(vl::fvec3 &normal, const vl::fvec3 &v, float dx, float dy, float dz) | vlVolume::Volume |
normalLQ(vl::fvec3 &normal, const vl::fvec3 &v, float dx, float dy, float dz) | vlVolume::Volume |
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
sampleNearest(float x, float y, float z) const | vlVolume::Volume |
sampleSmooth(float x, float y, float z) const | vlVolume::Volume |
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setDataDirty() | vlVolume::Volume | [inline]
setName(const std::string &name) | vl::Object | [inline]
setup(float *data, const vl::fvec3 &bottom_left, const vl::fvec3 &top_right, const vl::ivec3 &slices) | vlVolume::Volume |
setup(const Volume &) | vlVolume::Volume |
setupInternalData() | vlVolume::Volume |
size() const | vlVolume::Volume | [inline]
slices() const | vlVolume::Volume | [inline]
topRight() const | vlVolume::Volume | [inline]
value(int i) const | vlVolume::Volume | [inline]
value(int i) | vlVolume::Volume | [inline]
value(int x, int y, int z) const | vlVolume::Volume | [inline]
value(int x, int y, int z) | vlVolume::Volume | [inline]
values() const | vlVolume::Volume | [inline]
values() | vlVolume::Volume | [inline]
Volume() | vlVolume::Volume |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlVolume::VolumeInfo Member List

This is the complete list of members for vlVolume::VolumeInfo, including all inherited members.

as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vlVolume::VolumeInfo | [inline, virtual]
color() const | vlVolume::VolumeInfo | [inline]
decReference() | vl::Object | [inline]
incReference() | vl::Object | [inline]
mColor | vlVolume::VolumeInfo | [protected]
mName | vl::Object | [protected]
mThreshold | vlVolume::VolumeInfo | [protected]
mVert0 | vlVolume::VolumeInfo | [protected]
mVertC | vlVolume::VolumeInfo | [protected]
mVolume | vlVolume::VolumeInfo | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
referenceCount() const | vl::Object | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setColor(const vl::fvec4 &col) | vlVolume::VolumeInfo | [inline]
setName(const std::string &name) | vl::Object | [inline]
setThreshold(float t) | vlVolume::VolumeInfo | [inline]
setVert0(int index) | vlVolume::VolumeInfo | [inline]
setVertC(int count) | vlVolume::VolumeInfo | [inline]
setVolume(Volume *vol) | vlVolume::VolumeInfo | [inline]
threshold() const | vlVolume::VolumeInfo | [inline]
vert0() const | vlVolume::VolumeInfo | [inline]
vertC() const | vlVolume::VolumeInfo | [inline]
volume() const | vlVolume::VolumeInfo | [inline]
VolumeInfo(Volume *vol, float threshold, const vl::fvec4 &color) | vlVolume::VolumeInfo | [inline]
VolumeInfo(Volume *vol, float threshold) | vlVolume::VolumeInfo | [inline]
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlVolume::VolumePlot Member List

This is the complete list of members for vlVolume::VolumePlot, including all inherited members.

actorTreeMulti() | vlVolume::VolumePlot | [inline]
actorTreeMulti() const | vlVolume::VolumePlot | [inline]
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
boxEffect() const | vlVolume::VolumePlot | [inline]
boxEffect() | vlVolume::VolumePlot | [inline]
className() | vl::Object | [inline, virtual]
compute(const Function &func, float threshold) | vlVolume::VolumePlot |
decReference() | vl::Object | [inline]
evaluateFunction(float *scalar, const vl::fvec3 &min_corner, const vl::fvec3 &max_corner, const Function &func) | vlVolume::VolumePlot | [protected]
incReference() | vl::Object | [inline]
isosurfaceActor() const | vlVolume::VolumePlot | [inline]
isosurfaceActor() | vlVolume::VolumePlot | [inline]
isosurfaceEffect() const | vlVolume::VolumePlot | [inline]
isosurfaceEffect() | vlVolume::VolumePlot | [inline]
isosurfaceGeometry() const | vlVolume::VolumePlot | [inline]
isosurfaceGeometry() | vlVolume::VolumePlot | [inline]
labelFont() const | vlVolume::VolumePlot | [inline]
labelFormat() const | vlVolume::VolumePlot | [inline]
mActors | vlVolume::VolumePlot | [protected]
mActorTreeMulti | vlVolume::VolumePlot | [protected]
maxCorner() const | vlVolume::VolumePlot | [inline]
mBoxEffect | vlVolume::VolumePlot | [protected]
minCorner() const | vlVolume::VolumePlot | [inline]
mIsosurfaceActor | vlVolume::VolumePlot | [protected]
mIsosurfaceEffect | vlVolume::VolumePlot | [protected]
mIsosurfaceGeometry | vlVolume::VolumePlot | [protected]
mLabelFont | vlVolume::VolumePlot | [protected]
mLabelFormat | vlVolume::VolumePlot | [protected]
mMaxCorner | vlVolume::VolumePlot | [protected]
mMinCorner | vlVolume::VolumePlot | [protected]
mName | vl::Object | [protected]
mPlotTransform | vlVolume::VolumePlot | [protected]
mSamplingResolution | vlVolume::VolumePlot | [protected]
mTextTemplate | vlVolume::VolumePlot | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
operator=(const Object &other) | vl::Object | [inline]
plotTransform() const | vlVolume::VolumePlot | [inline]
referenceCount() const | vl::Object | [inline]
samplingResolution() const | vlVolume::VolumePlot | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setLabelFont(vl::Font *font) | vlVolume::VolumePlot | [inline]
setLabelFormat(const vl::String &format) | vlVolume::VolumePlot | [inline]
setMaxCorner(const vl::fvec3 &max_corner) | vlVolume::VolumePlot | [inline]
setMinCorner(const vl::fvec3 &min_corner) | vlVolume::VolumePlot | [inline]
setName(const std::string &name) | vl::Object | [inline]
setPlotTransform(vl::Transform *tr) | vlVolume::VolumePlot | [inline]
setSamplingResolution(const vl::ivec3 &size) | vlVolume::VolumePlot | [inline]
setupLabels(const vl::String &format, const vl::fvec3 &min_corner, const vl::fvec3 &max_corner, vl::Font *font, vl::Transform *root_tr) | vlVolume::VolumePlot | [protected]
textTemplate() const | vlVolume::VolumePlot | [inline]
textTemplate() | vlVolume::VolumePlot | [inline]
VolumePlot() | vlVolume::VolumePlot |
~Object() | vl::Object | [protected, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlVolume::VolumePlot::Function Member List

This is the complete list of members for vlVolume::VolumePlot::Function, including all inherited members.

operator()(float x, float y, float z) const =0 vlVolume::VolumePlot::Function [pure virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlWX::vlWXGLCanvas Member List

This is the complete list of members for vlWX::vlWXGLCanvas, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vl::OpenGLContext | [inline, virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlWX::vlWXGLCanvas | [virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
height() const | vl::OpenGLContext | [inline]
hide() | vlWX::vlWXGLCanvas | [virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
initExtensions(bool log=true) | vl::OpenGLContext |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlWX::vlWXGLCanvas | [virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OnDropFiles(wxDropFilesEvent &ev) | vlWX::vlWXGLCanvas |
OnEraseBackground(wxEraseEvent &ev) | vlWX::vlWXGLCanvas |
OnIdle(wxIdleEvent &ev) | vlWX::vlWXGLCanvas |
OnKeyDown(wxKeyEvent &ev) | vlWX::vlWXGLCanvas |
OnKeyUp(wxKeyEvent &ev) | vlWX::vlWXGLCanvas |
OnMouseDown(wxMouseEvent &ev) | vlWX::vlWXGLCanvas |
OnMouseEnter(wxMouseEvent &ev) | vlWX::vlWXGLCanvas |
OnMouseMotion(wxMouseEvent &ev) | vlWX::vlWXGLCanvas |
OnMouseUp(wxMouseEvent &ev) | vlWX::vlWXGLCanvas |
OnMouseWheel(wxMouseEvent &ev) | vlWX::vlWXGLCanvas |
OnPaint(wxPaintEvent &ev) | vlWX::vlWXGLCanvas |
OnSize(wxSizeEvent &ev) | vlWX::vlWXGLCanvas |
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vlWX::vlWXGLCanvas | [virtual]
quitApplication() | vlWX::vlWXGLCanvas | [virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool fullscreen) | vlWX::vlWXGLCanvas | [virtual]
setMousePosition(int x, int y) | vlWX::vlWXGLCanvas | [virtual]
setMouseVisible(bool visible) | vlWX::vlWXGLCanvas | [virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlWX::vlWXGLCanvas | [virtual]
setSize(int w, int h) | vlWX::vlWXGLCanvas | [virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowTitle(const vl::String &text) | vlWX::vlWXGLCanvas | [virtual]
show() | vlWX::vlWXGLCanvas | [virtual]
size() const | vl::OpenGLContext | [inline, virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlWX::vlWXGLCanvas | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vlWX::vlWXGLCanvas | [virtual]
vlWXGLCanvas(wxWindow *parent, const wxGLContext *shared, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, int *attribList=0, const wxString &name=wxT("vlWXGLCanvas"), const wxPalette &palette=wxNullPalette) | vlWX::vlWXGLCanvas |
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]
~vlWXGLCanvas() | vlWX::vlWXGLCanvas | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Member List

vlWin32::Win32Context Member List

This is the complete list of members for vlWin32::Win32Context, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vl::OpenGLContext | [inline, virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlWin32::Win32Context | [virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
hdc() const | vlWin32::Win32Context | [inline]
height() const | vl::OpenGLContext | [inline]
hglrc() const | vlWin32::Win32Context | [inline]
hide() | vlWin32::Win32Context | [virtual]
hwnd() const =0 | vlWin32::Win32Context | [pure virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
init(HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x, int y, int width, int height) | vlWin32::Win32Context | [protected]
initExtensions(bool log=true) | vl::OpenGLContext |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlWin32::Win32Context | [virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mHDC | vlWin32::Win32Context | [protected]
mHGLRC | vlWin32::Win32Context | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mNormFlags | vlWin32::Win32Context | [protected]
mNormPosit | vlWin32::Win32Context | [protected]
mNormSize | vlWin32::Win32Context | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vlWin32::Win32Context | [virtual]
quitApplication() | vlWin32::Win32Context | [virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setFullscreen(bool fullscreen_on) | vlWin32::Win32Context | [virtual]
setMousePosition(int x, int y) | vlWin32::Win32Context | [virtual]
setMouseVisible(bool visible) | vlWin32::Win32Context | [virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlWin32::Win32Context | [virtual]
setSize(int w, int h) | vlWin32::Win32Context | [virtual]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowSize(int w, int h) | vlWin32::Win32Context |
setWindowTitle(const vl::String &title) | vlWin32::Win32Context | [virtual]
shareOpenGLResources(HGLRC hGLRC) | vlWin32::Win32Context |
show() | vlWin32::Win32Context | [virtual]
size() const | vlWin32::Win32Context | [virtual]
sortEventListeners() | vl::OpenGLContext |
swapBuffers() | vlWin32::Win32Context | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vlWin32::Win32Context | [virtual]
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
Win32Context() | vlWin32::Win32Context | [inline]
Win32Context(int w, int h) | vlWin32::Win32Context | [inline]
windowSize() const | vlWin32::Win32Context |
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:25 2009.


Visualization Library: Member List

vlWin32::Win32Window Member List

This is the complete list of members for vlWin32::Win32Window, including all inherited members.

addEventListener(UIEventListener *el) | vl::OpenGLContext |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
className() | vl::OpenGLContext | [inline, virtual]
continuousUpdate() const | vl::OpenGLContext | [inline]
createFBORenderTarget(int width, int height) | vl::OpenGLContext | [inline]
createFBORenderTarget() | vl::OpenGLContext | [inline]
decReference() | vl::Object | [inline]
destroy() | vlWin32::Win32Window | [virtual]
destroyAllFBORenderTargets() | vl::OpenGLContext | [inline]
destroyFBORenderTarget(FBORenderTarget *fbort) | vl::OpenGLContext | [inline]
destroyWindow() | vlWin32::Win32Window |
dispatchDestroyEvent() | vl::OpenGLContext | [inline]
dispatchFileDroppedEvent(const std::vector< String > &files) | vl::OpenGLContext | [inline]
dispatchInitEvent() | vl::OpenGLContext | [inline]
dispatchKeyPressEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchKeyReleaseEvent(unsigned short unicode_ch, EKey key) | vl::OpenGLContext | [inline]
dispatchMouseDownEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseMoveEvent(int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseUpEvent(EMouseButton button, int x, int y) | vl::OpenGLContext | [inline]
dispatchMouseWheelEvent(int n) | vl::OpenGLContext | [inline]
dispatchResizeEvent(int w, int h) | vl::OpenGLContext | [inline]
dispatchRunEvent() | vl::OpenGLContext | [inline]
dispatchVisibilityEvent(bool visible) | vl::OpenGLContext | [inline]
eraseAllEventListeners() | vl::OpenGLContext |
eventListener(int i) const | vl::OpenGLContext | [inline]
eventListenerCount() const | vl::OpenGLContext | [inline]
eventListeners() const | vl::OpenGLContext | [inline]
exStyle() const | vlWin32::Win32Window | [inline]
fullscreen() const | vl::OpenGLContext | [inline, virtual]
getFocus() | vlWin32::Win32Context | [virtual]
getProcAddress(const char *function_name) | vl::OpenGLContext |
getWindow(HWND hWnd) | vlWin32::Win32Window | [static]
hdc() const | vlWin32::Win32Context | [inline]
height() const | vl::OpenGLContext | [inline]
hglrc() const | vlWin32::Win32Context | [inline]
hide() | vlWin32::Win32Context | [virtual]
hwnd() const | vlWin32::Win32Window | [inline, virtual]
ignoreNextMouseMoveEvent() | vl::OpenGLContext | [inline]
incReference() | vl::Object | [inline]
init(HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x, int y, int width, int height) | vlWin32::Win32Context | [protected]
initExtensions(bool log=true) | vl::OpenGLContext |
initWin32Window(HWND parent, HGLRC share_context, const vl::String &title, const vl::OpenGLContextFormat &fmt, int x=0, int y=0, int width=640, int height=480) | vlWin32::Win32Window |
isExtensionSupported(const char *ext_name) | vl::OpenGLContext |
isKeyPressed(EKey key) const | vl::OpenGLContext | [inline]
keyboard() const | vl::OpenGLContext | [inline]
keyPress(EKey key) | vl::OpenGLContext | [inline]
keyRelease(EKey key) | vl::OpenGLContext | [inline]
logOpenGLInfo() | vl::OpenGLContext |
makeCurrent() | vlWin32::Win32Context | [virtual]
mContinuousUpdate | vl::OpenGLContext | [protected]
mEventListeners | vl::OpenGLContext | [protected]
mExStyle | vlWin32::Win32Window | [protected]
mFBORenderTarget | vl::OpenGLContext | [protected]
mFullscreen | vl::OpenGLContext | [protected]
mGLContextInfo | vl::OpenGLContext | [protected]
mHDC | vlWin32::Win32Context | [protected]
mHGLRC | vlWin32::Win32Context | [protected]
mHWND | vlWin32::Win32Window | [protected]
mIgnoreNextMouseMoveEvent | vl::OpenGLContext | [protected]
mKeyboard | vl::OpenGLContext | [protected]
mMouseDownCount | vlWin32::Win32Window | [protected]
mMouseVisible | vl::OpenGLContext | [protected]
mName | vl::Object | [protected]
mNormFlags | vlWin32::Win32Context | [protected]
mNormPosit | vlWin32::Win32Context | [protected]
mNormSize | vlWin32::Win32Context | [protected]
mouseVisible() const | vl::OpenGLContext | [inline, virtual]
mRenderTarget | vl::OpenGLContext | [protected]
mStyle | vlWin32::Win32Window | [protected]
mTextureUnitCount | vl::OpenGLContext | [protected]
mWindowClassName | vlWin32::Win32Window | [protected]
mWinMap | vlWin32::Win32Window | [protected, static]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
OpenGLContext(int w=0, int h=0) | vl::OpenGLContext | [inline]
openglContextInfo() const | vl::OpenGLContext | [inline]
operator=(const Object &other) | vl::Object | [inline]
position() const | vlWin32::Win32Context | [virtual]
quitApplication() | vlWin32::Win32Context | [virtual]
referenceCount() const | vl::Object | [inline]
removeEventListener(UIEventListener *el) | vl::OpenGLContext |
renderTarget() | vl::OpenGLContext | [inline]
renderTarget() const | vl::OpenGLContext | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setContinuousUpdate(bool continuous) | vl::OpenGLContext | [inline, virtual]
setExStyle(DWORD ex_style) | vlWin32::Win32Window | [inline]
setFullscreen(bool fullscreen_on) | vlWin32::Win32Context | [virtual]
setMousePosition(int x, int y) | vlWin32::Win32Context | [virtual]
setMouseVisible(bool visible) | vlWin32::Win32Context | [virtual]
setName(const std::string &name) | vl::Object | [inline]
setOpenGLContextInfo(const OpenGLContextFormat &info) | vl::OpenGLContext | [inline]
setPosition(int x, int y) | vlWin32::Win32Context | [virtual]
setSize(int w, int h) | vlWin32::Win32Context | [virtual]
setStyle(DWORD style) | vlWin32::Win32Window | [inline]
setVSyncEnabled(bool enable) | vl::OpenGLContext |
setWindowClassName(const wchar_t *name) | vlWin32::Win32Window | [inline]
setWindowSize(int w, int h) | vlWin32::Win32Context |
setWindowTitle(const vl::String &title) | vlWin32::Win32Context | [virtual]
shareOpenGLResources(HGLRC hGLRC) | vlWin32::Win32Context |
show() | vlWin32::Win32Context | [virtual]
size() const | vlWin32::Win32Context | [virtual]
sortEventListeners() | vl::OpenGLContext |
style() const | vlWin32::Win32Window | [inline]
swapBuffers() | vlWin32::Win32Context | [virtual]
textureUnitCount() const | vl::OpenGLContext | [inline]
update() | vlWin32::Win32Context | [virtual]
vsyncEnabled() const | vl::OpenGLContext |
width() const | vl::OpenGLContext | [inline]
Win32Context() | vlWin32::Win32Context | [inline]
Win32Context(int w, int h) | vlWin32::Win32Context | [inline]
Win32Window() | vlWin32::Win32Window |
Win32WindowClassName | vlWin32::Win32Window | [static]
windowClassName() const | vlWin32::Win32Window | [inline]
WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) | vlWin32::Win32Window | [static]
windowSize() const | vlWin32::Win32Context |
winMap() | vlWin32::Win32Window | [inline, static]
~Object() | vl::Object | [protected, virtual]
~OpenGLContext() | vl::OpenGLContext | [inline]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Member List

vlut::Applet Member List

This is the complete list of members for vlut::Applet, including all inherited members.

Applet() | vlut::Applet |
as() | vl::Object | [inline]
as() const | vl::Object | [inline]
automaticDelete() const | vl::Object | [inline]
bindManipulators(vl::Rendering *rendering) | vlut::Applet | [protected]
className() | vlut::Applet | [inline, virtual]
decReference() | vl::Object | [inline]
destroyEvent() | vlut::Applet | [virtual]
fileDroppedEvent(const std::vector< String > &) | vl::UIEventListener | [inline, virtual]
fps() const | vlut::Applet | [inline]
ghostCamera() | vlut::Applet | [inline]
incReference() | vl::Object | [inline]
initEvent()=0 | vlut::Applet | [pure virtual]
initialize() | vlut::Applet |
isEnabled() const | vl::UIEventListener | [inline]
keyPressEvent(unsigned short, EKey) | vl::UIEventListener | [inline, virtual]
keyReleaseEvent(unsigned short, vl::EKey key) | vlut::Applet | [virtual]
mEnabled | vl::UIEventListener | [protected]
mFly | vlut::Applet | [protected]
mFPS | vlut::Applet | [protected]
mFrameCount | vlut::Applet | [protected]
mName | vl::Object | [protected]
mOpenGLContext | vl::UIEventListener | [protected]
mouseDownEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseMoveEvent(int, int) | vl::UIEventListener | [inline, virtual]
mouseUpEvent(EMouseButton, int, int) | vl::UIEventListener | [inline, virtual]
mouseWheelEvent(int) | vl::UIEventListener | [inline, virtual]
mRank | vl::UIEventListener | [protected]
mSceneManagerActorTree | vlut::Applet | [protected]
mStartTime | vlut::Applet | [protected]
mTrackball | vlut::Applet | [protected]
name() const | vl::Object | [inline]
Object() | vl::Object | [inline]
Object(const Object &other) | vl::Object | [inline]
openglContext() | vl::UIEventListener |
openglContextBoundEvent(vl::OpenGLContext *openglContext) | vlut::Applet | [virtual]
operator<(const UIEventListener &other) const | vl::UIEventListener | [inline]
operator=(const Object &other) | vl::Object | [inline]
prepareToReconnect() | vl::UIEventListener | [inline, virtual]
rank() const | vl::UIEventListener |
referenceCount() const | vl::Object | [inline]
resizeEvent(int w, int h) | vlut::Applet | [virtual]
run()=0 | vlut::Applet | [pure virtual]
runEvent() | vlut::Applet | [virtual]
sceneManager() | vlut::Applet | [inline]
sceneManager() const | vlut::Applet | [inline]
setAutomaticDelete(bool autodel_on) | vl::Object | [inline]
setEnabled(bool enabled) | vl::UIEventListener | [inline, virtual]
setName(const std::string &name) | vl::Object | [inline]
setRank(int rank) | vl::UIEventListener |
shutdown()=0 | vlut::Applet | [pure virtual]
trackball() | vlut::Applet | [inline]
UIEventListener() | vl::UIEventListener | [inline]
visibilityEvent(bool) | vl::UIEventListener | [inline, virtual]
~Applet() | vlut::Applet | [inline]
~Object() | vl::Object | [protected, virtual]
~UIEventListener() | vl::UIEventListener | [inline, virtual]

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:24 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- k -

  • ka() : vl::ObjMaterial
  • kd() : vl::ObjMaterial
  • kdtreeFromNonLeafyActors() : vl::ActorKdTree
  • keepAromaticCycles() : vlMolecule::RingExtractor
  • keepMinimalCycles() : vlMolecule::RingExtractor
  • keepPlanarCycles() : vlMolecule::RingExtractor
  • kerningEnabled() : vl::Text
  • keyboard() : vl::OpenGLContext
  • keyPress() : vl::OpenGLContext
  • keyPressEvent()
: vlQt4::Qt4Widget
, vl::UIEventListener
  • keyRelease() : vl::OpenGLContext
  • keyReleaseEvent()
: vlut::Applet
, vlQt4::Qt4Widget
, vl::UIEventListener
  • keyValueMap() : vl::KeyValues
  • ks() : vl::ObjMaterial
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- l -

  • labelFont() : vlVolume::VolumePlot
  • labelFormat() : vlVolume::VolumePlot
  • lastChild() : vl::Transform
  • lastUpdateTime()
: vl::Actor
, vl::Shader
  • layer()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • layout() : vl::Text
  • left()
: vl::Glyph
, vl::Rect< T >
, vl::String
  • length()
: vl::Vector4< scalar_type >
, vl::quat
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
  • lengthSquared()
: vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • less() : vl::Collection< T >
  • level()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
  • light() : vlVolume::SlicedVolume
  • Light() : vl::Light
  • lightIndex() : vl::Light
  • LightModel() : vl::LightModel
  • linearAttenuation() : vl::Light
  • linearFilteringEnabled() : vl::BlitFramebuffer
  • LinearInterpolator() : vl::LinearInterpolator< T >
  • LinearInterpolatorDouble() : vl::LinearInterpolatorDouble
  • LinearInterpolatorDVec2() : vl::LinearInterpolatorDVec2
  • LinearInterpolatorDVec3() : vl::LinearInterpolatorDVec3
  • LinearInterpolatorDVec4() : vl::LinearInterpolatorDVec4
  • LinearInterpolatorFloat() : vl::LinearInterpolatorFloat
  • LinearInterpolatorFVec2() : vl::LinearInterpolatorFVec2
  • LinearInterpolatorFVec3() : vl::LinearInterpolatorFVec3
  • LinearInterpolatorFVec4() : vl::LinearInterpolatorFVec4
  • lineCount()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • lineSmoothHint() : vl::Hint
  • lineSmoothing() : vlVG::VectorGraphics
  • LineStipple() : vl::LineStipple
  • lineStipple() : vlVG::VectorGraphics
  • lineWidth()
: vl::LineWidth
, vlVG::VectorGraphics
, vlMolecule::Molecule
  • LineWidth() : vl::LineWidth
  • lineWidth() : vl::EdgeRenderer
  • linked() : vl::GLSLProgram
  • linkProgram() : vl::GLSLProgram
  • linkStatus() : vl::GLSLProgram
  • listFiles()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • listFilesRecursive()
: vl::DiskDirectory
, vl::FileSystem
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • listFilesRecursive_internal() : vl::DiskDirectory
  • listSubDirs()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • littleEndian() : vl::PlyLoader
  • load() : vl::VirtualFile
  • loadAscii() : vl::STLLoader
  • loadBinary() : vl::STLLoader
  • loadCallbacks() : vl::LoadWriterManager
  • loadExtensions() : vl::ResourceLoadWriter
  • loadFont() : vl::Font
  • loadOBJ() : vl::ObjLoader
  • loadObjMaterials() : vl::ObjLoader
  • loadPly() : vl::PlyLoader
  • loadResource()
: vl::LoadWriter3DS
, vl::LoadWriterOBJ
, vl::LoadWriterTGA
, vl::LoadWriterTIFF
, vl::LoadWriterMD2
, vl::LoadWriterDDS
, vl::LoadWriterBMP
, vl::LoadWriterTGA
, vl::LoadWriterManager
, vl::ResourceLoadWriter
, vl::LoadWriter3DS
, vl::LoadWriterAC3D
, vl::LoadWriterBMP
, vl::LoadWriterDAT
, vl::LoadWriterPNG
, vl::LoadWriterPLY
, vl::LoadWriterDDS
, vl::LoadWriterSTL
, vl::LoadWriterJPG
, vl::LoadWriterDICOM
, vl::LoadWriterJPG
, vl::LoadWriterSTL
, vl::LoadWriterPNG
, vl::LoadWriterOBJ
, vl::LoadWriterPLY
  • loadSTL() : vl::STLLoader
  • loadText() : vl::String
  • loadWriter() : vl::LoadWriterManager
  • LoadWriter3DS() : vl::LoadWriter3DS
  • LoadWriterAC3D() : vl::LoadWriterAC3D
  • LoadWriterBMP() : vl::LoadWriterBMP
  • LoadWriterDAT() : vl::LoadWriterDAT
  • LoadWriterDDS() : vl::LoadWriterDDS
  • LoadWriterDICOM() : vl::LoadWriterDICOM
  • LoadWriterJPG() : vl::LoadWriterJPG
  • loadWriterManager() : vl::VisualizationLibrary
  • LoadWriterManager() : vl::LoadWriterManager
  • LoadWriterMD2() : vl::LoadWriterMD2
  • LoadWriterOBJ() : vl::LoadWriterOBJ
  • LoadWriterPLY() : vl::LoadWriterPLY
  • LoadWriterPNG() : vl::LoadWriterPNG
  • loadWriters() : vl::LoadWriterManager
  • LoadWriterSTL() : vl::LoadWriterSTL
  • LoadWriterTGA() : vl::LoadWriterTGA
  • LoadWriterTIFF() : vl::LoadWriterTIFF
  • localMatrix() : vl::Transform
  • localViewer() : vl::LightModel
  • locateDirectory() : vl::FileSystem
  • locateFile() : vl::FileSystem
  • lod()
: vl::Effect
, vl::Actor
, vl::Effect
, vl::Actor
  • lodBias() : vl::TexEnv
  • lodEvaluator()
: vl::Actor
, vl::Effect
  • LODEvaluator() : vl::LODEvaluator
  • lodEvaluator()
: vl::Effect
, vl::Actor
  • Log() : vl::Log
  • logFile() : vl::StandardLog
  • logger()
: vl::Log
, vl::VisualizationLibrary
  • logicOp()
: vl::LogicOp
, vlVG::VectorGraphics
  • LogicOp() : vl::LogicOp
  • logOpenGLInfo() : vl::OpenGLContext
  • longestSideLength() : vl::AABB
  • lookAt() : vl::Matrix4< scalar_type >
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- m -

  • mA : vl::A3DSTriFace
  • mAABB
: vl::Actor
, vl::SceneManager
, vl::ActorTreeAbstract
  • mAccumRGBABits : vl::OpenGLContextFormat
  • mActive : vl::Camera
  • mActor : vl::RenderToken , vl::RayIntersection
  • mActorAnimationEnabled : vl::Rendering
  • mActorCache : vl::EdgeRenderer
  • mActorQueue : vl::Rendering
  • mActorRenderRankStart : vlVG::SceneManagerVectorGraphics
  • mActors
: vlVolume::VolumePlot
, vl::ActorTreeAbstract
, vl::RayIntersector
, vl::Sector
  • mActorTree : vlMolecule::Molecule
  • mActorTreeMulti : vlVolume::VolumePlot
  • mAdjacentAtoms : vlMolecule::Atom
  • mAdjacentVerts : vl::PolygonSimplifier::Vertex
  • mAdvance : vl::Glyph
  • magFilter() : vl::TexParameter
  • makeColorSpectrum() : vl::Image
  • makeCurrent()
: vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
  • makeNonUniformColorSpectrum() : vl::Image
  • mAlign : vl::DrawPixels::Pixels
  • mAlignment : vl::Buffer , vl::Text
  • mAlpha : vl::ColorMask
  • mAlphaBias : vl::PixelTransfer
  • mAlphaFunc : vl::AlphaFunc
  • mAlphaScale : vl::PixelTransfer , vl::TexEnv
  • mAlreadyProcessed : vl::PolygonSimplifier::Vertex
  • mAmbient : vl::Light , vl::A3DSMaterial
  • mAmbientColor : vl::LightModel
  • mAnim_t : vl::MorphingActor
  • mAnim_t_Binding : vl::MorphingActor
  • mAnimationEnd : vl::MorphingActor
  • mAnimationPeriod : vl::MorphingActor
  • mAnimationStart : vl::MorphingActor
  • mAnimationStarted : vl::MorphingActor
  • mAnimationStartTime : vl::MorphingActor
  • mAnisotropy : vl::TexParameter
  • map_Bump() : vl::ObjMaterial
  • map_d() : vl::ObjMaterial
  • map_Decal() : vl::ObjMaterial
  • map_Disp() : vl::ObjMaterial
  • map_Ka() : vl::ObjMaterial
  • map_Kd() : vl::ObjMaterial
  • map_Ks() : vl::ObjMaterial
  • map_Ns() : vl::ObjMaterial
  • mapAsciiKey() : vlGLUT::GLUTWindow
  • mapColor() : vl::PixelTransfer
  • mapGPUBuffer() : vl::GLBufferObject
  • mapNewToOld() : vl::DoubleVertexRemover
  • mapOldToNew() : vl::DoubleVertexRemover
  • mapSpecialKey() : vlGLUT::GLUTWindow
  • mapStencil() : vl::PixelTransfer
  • MarchingCubes() : vlVolume::MarchingCubes
  • margin() : vl::Text
  • mAromaticRingColor : vlMolecule::Molecule
  • mask() : vl::PolygonStipple
  • mask_Back()
: vl::StencilFunc
, vl::StencilMask
  • mask_Front()
: vl::StencilFunc
, vl::StencilMask
  • mAssumeIdentityWorldMatrix : vl::Transform
  • Material() : vl::Material
  • material() : vl::ObjMesh
  • materials() : vl::ObjLoader
  • mAtom1 : vlMolecule::Bond
  • mAtom2 : vlMolecule::Bond
  • mAtomDetail : vlMolecule::Molecule
  • mAtomicMass : vlMolecule::AtomInfo
  • mAtomicNumber : vlMolecule::AtomInfo
  • mAtomLabelEffect : vlMolecule::Molecule
  • mAtomLabelTemplate : vlMolecule::Molecule
  • mAtomName : vlMolecule::Atom
  • mAtoms : vlMolecule::Molecule
  • mAtomType : vlMolecule::Atom
  • matrix()
: vl::PolygonSimplifier::QErr
, vl::TextureMatrix
, vl::Text
, vlVG::VectorGraphics
  • Matrix2() : vl::Matrix2< scalar_type >
  • Matrix3() : vl::Matrix3< scalar_type >
  • Matrix4() : vl::Matrix4< scalar_type >
  • matrixStack() : vlVG::VectorGraphics
  • mAttribIndex : vl::VertexAttributeArray
  • mAutomaticResourceInit : vl::Rendering
  • mAverage : vlVolume::Volume
  • maxCorner()
: vl::AABB
, vlVolume::VolumePlot
  • maximum() : vlVolume::Volume
  • mAxis : vl::Billboard
  • maxVertexAttributes() : vl::GLSLProgram
  • mB : vl::A3DSTriFace
  • mBackAmbient : vl::Material
  • mBackDiffuse : vl::Material
  • mBackEmission : vl::Material
  • mBackFace : vl::PolygonMode
  • mBackgroundColor : vl::Text
  • mBackgroundEnabled : vl::Text
  • mBackShininess : vl::Material
  • mBackSpecular : vl::Material
  • mBinary : vl::PlyLoader
  • mBlendColor : vl::BlendColor
  • mBlendingEnabled : vl::EnableSet
  • mBlendU : vl::ObjTexture
  • mBlendV : vl::ObjTexture
  • mBlue : vl::ColorMask
  • mBlueBias : vl::PixelTransfer
  • mBlueScale : vl::PixelTransfer
  • mBM : vl::ObjTexture
  • mBoilingPoint : vlMolecule::AtomInfo
  • mBondDetail : vlMolecule::Molecule
  • mBonds : vlMolecule::Molecule
  • mBorder : vl::Texture::SetupParams , vl::Texture
  • mBorderColor : vl::Text , vl::TexParameter
  • mBorderEnabled : vl::Text
  • mBottomLeft : vlVolume::Volume
  • mBoundaryOnly : vl::Tessellator
  • mBoundingVolumeTree : vl::SceneManagerBVH< T >
  • mBoundsDirty : vl::SceneManager
  • mBoundsUpdateTick : vl::Actor
  • mBox : vlVolume::SlicedVolume
  • mBoxEffect : vlVolume::VolumePlot
  • mBuffer : vl::BufferedStream< Element_Type, Chunk_Size > , vl::MemoryFile
  • mBufferGPU : vl::ArrayAbstract
  • mBufferMask : vl::BlitFramebuffer
  • mByteAlign : vl::Image
  • mByteCount : vl::Buffer
  • mByteCountGPU : vl::GLBufferObject
  • mC : vl::A3DSTriFace
  • mCache : vlVolume::SlicedVolume
  • mCacheMatrix : vl::DepthSortCallback
  • mCalculatedRadius : vlMolecule::AtomInfo
  • mCallbacks : vl::Sector
  • mCamera
: vl::GhostCameraManipulator
, vl::Rendering
, vl::TrackballManipulator
  • mCameraDistance : vl::RenderToken
  • mCatmullRomSpline : vl::CatmullRomInterpolator< T >
  • mCC : vl::ObjTexture
  • mCellSize : vlVolume::Volume
  • mCenter : vl::Sphere
  • mChar : vl::PlyLoader::PlyScalar
  • mChildN : vl::ActorKdTree
  • mChildP : vl::ActorKdTree
  • mChildren : vl::ActorTree , vl::Transform
  • mChunkId : vl::A3DSLoader
  • mChunkLen : vl::A3DSLoader
  • mChunks : vl::Terrain
  • mClamp : vl::ObjTexture
  • mClassName : vlMFC::MFCWindow
  • mClearColor : vl::Viewport
  • mClearColorBuffer : vl::Clear
  • mClearColorInt : vl::Viewport
  • mClearColorMode : vl::Clear , vl::Viewport
  • mClearColorUInt : vl::Viewport
  • mClearColorValue : vl::Clear
  • mClearColorValueInt : vl::Clear
  • mClearColorValueUInt : vl::Clear
  • mClearDepth : vl::Viewport
  • mClearDepthBuffer : vl::Clear
  • mClearDepthValue : vl::Clear
  • mClearFlags : vl::Rendering , vl::Viewport
  • mClearStencil : vl::Viewport
  • mClearStencilBuffer : vl::Clear
  • mClearStencilValue : vl::Clear
  • mCollapseCost : vl::PolygonSimplifier::Vertex
  • mCollapsePosition : vl::PolygonSimplifier::Vertex
  • mCollapseVertex : vl::PolygonSimplifier::Vertex
  • mCollectStatistics : vl::Renderer
  • mColor
: vl::Fog
, vl::TexEnv
, vl::Text
, vl::PlyLoader::PlyElement
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
  • mColorArray : vlVolume::MarchingCubes
  • mColorControl : vl::LightModel
  • mColorMaterial : vl::Material
  • mColorMaterialEnabled : vl::Material
  • mColorMaterialFace : vl::Material
  • mColorPath : vl::Extrusion
  • mColors : vl::PlyLoader
  • mCombineAlpha : vl::TexEnv
  • mCombinedVertices : vl::Tessellator
  • mCombineRGB : vl::TexEnv
  • mCompareFunc : vl::TexParameter
  • mCompareMode : vl::TexParameter
  • mCompiled : vl::GLSLShader
  • mCompressedSize : vl::ZippedFileInfo
  • mCompression : vl::LoadWriterPNG
  • mCompressionLevel : vl::GZipCodec
  • mCompressionMethod : vl::ZippedFileInfo
  • mComputeNormals : vl::GeometryLoadCallback
  • mConstantAttenuation : vl::Light
  • mContinuousUpdate : vl::OpenGLContext
  • mContours : vl::Tessellator
  • mContourVerts : vl::Tessellator
  • mControlPoints : vl::BezierPatch
  • mConvertToDrawArrays : vl::GeometryLoadCallback
  • mCoordinates : vlMolecule::Atom
  • mCoords : vl::ObjLoader
  • mCoordSystem : vl::A3DSObject
  • mCorrupted : vl::A3DSLoader
  • mCount : vl::DrawArrays
  • mCountType : vl::PlyLoader::PlyScalarList
  • mCovalentRadius : vlMolecule::AtomInfo
  • mCPKColor : vlMolecule::AtomInfo
  • mCRC32 : vl::CRC32CheckSum , vl::ZippedFileInfo
  • mCreaseAngle : vl::EdgeExtractor , vl::EdgeRenderer
  • mCubeEdgeFlags : vlVolume::MarchingCubes
  • mCubes : vlVolume::Volume
  • mCullingEnabled : vl::Rendering , vl::SceneManager
  • mCurrentEnable : vl::Renderer
  • mCurrentRenderState : vl::Renderer
  • mCurrentUniform : vl::Renderer
  • mCycles : vlMolecule::Molecule
  • md5()
: vl::VirtualFile
, vl::MD5CheckSum
  • MD5CheckSum() : vl::MD5CheckSum
  • mData : vl::VertexAttributeArray , vl::PlyLoader::PlyScalar
  • mDataIsDirty : vlVolume::Volume
  • mDay : vl::ZippedFileInfo
  • mDayOfMonth : vl::Time
  • mDayOfWeek : vl::Time
  • mDefaultLineColor : vl::EdgeRenderer
  • mDefaultRenderStates : vl::Renderer
  • mDensity : vl::Fog
  • mDepth
: vl::Image
, vl::Terrain
, vl::Texture
  • mDepthBias : vl::PixelTransfer
  • mDepthFunc : vl::DepthFunc
  • mDepthMask : vl::DepthMask
  • mDepthScale : vl::PixelTransfer
  • mDepthSortMode : vl::RenderQueueSorterStandard , vl::RenderQueueSorterAggressive
  • mDepthTextureMode : vl::TexParameter
  • mDetail : vl::BezierSurface
  • mDetailRepetitionCount : vl::Terrain
  • mDetailTexture : vl::Terrain
  • mDetailTextureFormat : vl::Terrain
  • mDiffuse : vl::Light , vl::A3DSMaterial
  • mDimension : vl::Texture::SetupParams , vl::Texture
  • mDirection : vl::Ray
  • mDirectories : vl::FileSystem
  • mDirty : vl::TexParameter
  • mDiscardOriginalNormals : vl::GeometryLoadCallback
  • mDistance : vl::RayIntersection , vl::RayIntersectionGeometry
  • mDistanceAttenuation : vl::PointParameter
  • mDistanceRangeSet : vl::DistanceLODEvaluator
  • mDouble : vl::PlyLoader::PlyScalar
  • mDoubleSided : vl::A3DSMaterial
  • mDpFail_Back : vl::StencilOp
  • mDpFail_Front : vl::StencilOp
  • mDpPass_Back : vl::StencilOp
  • mDpPass_Front : vl::StencilOp
  • mDrawBuffers : vl::RenderTarget
  • mDrawElements : vlVolume::MarchingCubes
  • mDrawFramebuffer : vl::BlitFramebuffer
  • mDraws : vl::DrawPixels
  • mDstAlpha : vl::BlendFunc
  • mDstRect : vl::BlitFramebuffer
  • mDstRGB : vl::BlendFunc
  • mEdges : vl::EdgeExtractor
  • mEffect : vl::Actor , vlVolume::SlicedVolume
  • mEffectRenderRank : vl::RenderToken
  • mElapsedTime : vl::MorphingActor
  • mElectronAffinity : vlMolecule::AtomInfo
  • mElectronegativity : vlMolecule::AtomInfo
  • mElemCount : vl::PlyLoader::PlyElement
  • mElements : vl::PlyLoader
  • meltingPoint() : vlMolecule::AtomInfo
  • MemoryDirectory() : vl::MemoryDirectory
  • memoryFile() : vl::MemoryDirectory
  • MemoryFile() : vl::MemoryFile
  • memorySubDir() : vl::MemoryDirectory
  • mEmpiricalRadius : vlMolecule::AtomInfo
  • mEnabled : vl::Primitives , vl::UIEventListener
  • mEnableMask
: vl::Actor
, vl::Effect
, vl::RenderingAbstract
, vl::SceneManager
  • mEnables : vl::EnableSet , vl::ShaderNode
  • mEnables_Final : vl::ShaderNode
  • mEnableSet : vl::Shader
  • mEnableTable : vl::Renderer
  • mEnd : vl::Fog
  • mergeTriangleStrips() : vl::Geometry
  • meshes() : vl::ObjLoader
  • mEvaluateLOD : vl::Rendering
  • mEventListeners : vl::OpenGLContext
  • mExStyle : vlWin32::Win32Window
  • mExternalSector : vl::SceneManagerPortals
  • mExtraFieldLength : vl::ZippedFileInfo
  • mEyePlaneQ : vl::TexGen
  • mEyePlaneR : vl::TexGen
  • mEyePlaneS : vl::TexGen
  • mEyePlaneT : vl::TexGen
  • mEyeSpaceVerts : vl::DepthSortCallback
  • mFace_icoords : vl::ObjMesh
  • mFace_inormals : vl::ObjMesh
  • mFace_itexcoords : vl::ObjMesh
  • mFace_type : vl::ObjMesh
  • mFaceList : vl::A3DSObject
  • mFaceMode : vl::CullFace
  • mFactor : vl::PolygonOffset , vl::LineStipple
  • mFadeThresholdSize : vl::PointParameter
  • mFans : vl::Tessellator
  • mFarPlane : vl::Camera
  • mFBOAttachments : vl::FBORenderTarget
  • mFBORenderTarget : vl::OpenGLContext
  • mFBORenderTargets : vl::FBOAttachmentAbstract
  • MFCWindow() : vlMFC::MFCWindow
  • mFileName
: vl::A3DSTexture
, vl::ObjTexture
, vl::ZippedFileInfo
  • mFileNameLength : vl::ZippedFileInfo
  • mFilePath : vl::Font
  • mFiles : vl::MemoryDirectory , vl::ZippedDirectory
  • mFillBottom : vl::Extrusion
  • mFillTop : vl::Extrusion
  • mFlags : vl::A3DSTriFace
  • mFloat : vl::PlyLoader::PlyScalar
  • mFloatData : vl::Uniform
  • mFly : vlut::Applet
  • mFogHint : vl::Hint
  • mFollowedTransform : vl::ClipPlane , vl::Light
  • mFollowTransform : vl::Camera
  • mFont : vl::Glyph , vl::Text
  • mFonts : vl::FontManager
  • mFormat
: vl::Image
, vl::Texture::SetupParams
, vl::Texture
  • mFOV : vl::Camera
  • mFPS : vlut::Applet
  • mFragDataLocation : vl::GLSLProgram
  • mFragmentShader : vl::Terrain
  • mFrame1 : vl::MorphingActor
  • mFrame2 : vl::MorphingActor
  • mFrameCount : vlut::Applet
  • mFrontAmbient : vl::Material
  • mFrontDiffuse : vl::Material
  • mFrontEmission : vl::Material
  • mFrontFace : vl::FrontFace , vl::PolygonMode
  • mFrontShininess : vl::Material
  • mFrontSpecular : vl::Material
  • mFrustum : vl::Camera , vl::RayIntersector
  • mFrustumStack : vl::SceneManagerPortals
  • mFT_Face : vl::Font
  • mFullscreen : vl::OpenGLContextFormat , vl::OpenGLContext
  • mFunction_Back : vl::StencilFunc
  • mFunction_Front : vl::StencilFunc
  • mGeneralPurposeFlag : vl::ZippedFileInfo
  • mGenerateMipmap : vl::TexParameter
  • mGenerateMipmapHint : vl::Hint
  • mGenModeQ : vl::TexGen
  • mGenModeR : vl::TexGen
  • mGenModeS : vl::TexGen
  • mGenModeT : vl::TexGen
  • mGeometry
: vl::MorphingActor
, vl::RayIntersectionGeometry
, vlVolume::SlicedVolume
  • mGeometryInputType : vl::GLSLProgram
  • mGeometryOutputType : vl::GLSLProgram
  • mGeometryVerticesOut : vl::GLSLProgram
  • mGLContextInfo : vl::OpenGLContext
  • mGLSLProgram : vl::RenderStateSet , vlVolume::SlicedVolume
  • mGLSLVertexBlendEnabled : vl::MorphingActor
  • mGlyphIndex : vl::Glyph
  • mGlyphMap : vl::Font
  • mGreen : vl::ColorMask
  • mGreenBias : vl::PixelTransfer
  • mGreenScale : vl::PixelTransfer
  • mHandle
: vl::DiskFile
, vl::FBORenderbufferAttachment
, vl::FBORenderTarget
, vl::GLBufferObject
, vl::GLSLShader
, vl::GLSLProgram
, vl::Texture
, vlGLUT::GLUTWindow
  • mHasDoubleBuffer : vl::OpenGLContextFormat
  • mHasMipmaps : vl::Texture::SetupParams , vl::Texture
  • mHasMultisample : vl::OpenGLContextFormat
  • mHDC : vlWin32::Win32Context
  • mHeight
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::Font
, vl::FBORenderbufferAttachment
, vl::Image
, vl::ReadPixels
, vl::Rect< T >
, vl::RenderTarget
, vl::Terrain
, vl::Texture
, vl::Viewport
  • mHeightmapTexture : vl::Terrain
  • mHeightmapTextureFormat : vl::Terrain
  • mHGLRC : vlWin32::Win32Context
  • mHour : vl::Time , vl::ZippedFileInfo
  • mHWND : vlWin32::Win32Window
  • microsecond() : vl::Time
  • mId
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • mightNeedZCameraDistance()
: vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
, vl::RenderQueueSorterAggressive
  • mIgnoreNextMouseMoveEvent : vl::OpenGLContext
  • mIllum : vl::ObjMaterial
  • mImage
: vl::DrawPixels::Pixels
, vl::ReadPixels
, vl::Texture::SetupParams
  • mImagePath : vl::Texture::SetupParams
  • mImfchan : vl::ObjTexture
  • mIncidentTriangles : vl::PolygonSimplifier::Vertex
  • minCorner()
: vl::AABB
, vlVolume::VolumePlot
  • mIndex : vl::A3DSVertex
  • mIndexBuffer : vl::DrawElements< index_type, Tgltype, arr_type >
  • mIndexOffset : vl::PixelTransfer
  • mIndexShift : vl::PixelTransfer
  • mIndices : vl::PlyLoader
  • minFilter() : vl::TexParameter
  • minimum() : vlVolume::Volume
  • mInited : vlGLUT::GLUTWindow
  • mInputFile : vl::BufferedStream< Element_Type, Chunk_Size > , vl::A3DSLoader
  • mInstances : vl::Primitives
  • mInt : vl::PlyLoader::PlyScalar
  • mIntData : vl::Uniform
  • mInterlineSpacing : vl::Text
  • mInterpolator
: vl::CatmullRomInterpolatorFVec4
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • mIntersectionPoint : vl::RayIntersection , vl::RayIntersectionGeometry
  • mIntersections : vl::RayIntersector
  • minute()
: vl::Time
, vl::ZippedFileInfo
  • mInverseViewMatrix : vl::Camera
  • mInvert : vl::SampleCoverage
  • mipmapLevel()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • mipmaps() : vl::Image
  • mIsCrease : vl::EdgeExtractor::Edge
  • mIsCubemap : vl::Image
  • mIsOccludee : vl::Actor
  • mIsOpen : vl::MemoryFile , vl::Portal
  • mIsosurfaceActor : vlVolume::VolumePlot
  • mIsosurfaceEffect : vlVolume::VolumePlot
  • mIsosurfaceGeometry : vlVolume::VolumePlot
  • mKa : vl::ObjMaterial
  • mKd : vl::ObjMaterial
  • mKerningEnabled : vl::Text
  • mKeyboard : vl::OpenGLContext
  • mKeymap : vlGLUT::GLUTWindow
  • mKeysBackward : vl::GhostCameraManipulator
  • mKeysDown : vl::GhostCameraManipulator
  • mKeysForward : vl::GhostCameraManipulator
  • mKeysLeft : vl::GhostCameraManipulator
  • mKeysRight : vl::GhostCameraManipulator
  • mKeysUp : vl::GhostCameraManipulator
  • mKeyValues : vl::KeyValues
  • mKs : vl::ObjMaterial
  • mLabelFont : vlVolume::VolumePlot
  • mLabelFormat : vlVolume::VolumePlot
  • mLastTime : vl::GhostCameraManipulator
  • mLastUpdate : vl::MorphingActor
  • mLastUpdateTime : vl::Actor , vl::Shader
  • mLayer : vl::FBOTexture3DAttachment , vl::FBOTextureLayerAttachment
  • mLayout : vl::Text
  • mLeft : vl::Glyph
  • mLevel
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
  • mLight : vlVolume::SlicedVolume
  • mLightIndex : vl::Light
  • mLinearAttenuation : vl::Light
  • mLinearFilteringEnabled : vl::BlitFramebuffer
  • mLinearSpline : vl::LinearInterpolator< T >
  • mLineLoops : vl::Tessellator
  • mLineSmoothHint : vl::Hint
  • mLineWidth
: vl::EdgeRenderer
, vl::LineWidth
, vlMolecule::Molecule
  • mList : vl::RenderQueue
  • mListMP : vl::RenderQueue
  • mLittleEndian : vl::PlyLoader
  • mLoadCallbacks : vl::LoadWriterManager
  • mLoadExtensions : vl::ResourceLoadWriter
  • mLoadWriters : vl::LoadWriterManager
  • mLocalMatrix : vl::Transform
  • mLocalViewer : vl::LightModel
  • mLodBias : vl::TexEnv
  • mLODEvaluator : vl::Actor , vl::Effect
  • mLODShaders : vl::Effect
  • mLogFile : vl::StandardLog
  • mLogger : vl::Log
  • mLogicOp : vl::LogicOp
  • mm_Base() : vl::ObjTexture
  • mm_Gain() : vl::ObjTexture
  • mMagfilter : vl::TexParameter
  • mMap_Bump : vl::ObjMaterial
  • mMap_d : vl::ObjMaterial
  • mMap_Decal : vl::ObjMaterial
  • mMap_Disp : vl::ObjMaterial
  • mMap_Ka : vl::ObjMaterial
  • mMap_Kd : vl::ObjMaterial
  • mMap_Ks : vl::ObjMaterial
  • mMap_Ns : vl::ObjMaterial
  • mMapColor : vl::PixelTransfer
  • mMapNewToOld : vl::DoubleVertexRemover
  • mMapOldToNew : vl::DoubleVertexRemover
  • mMappedFace : vl::A3DSMaterialFaceMapping
  • mMapStencil : vl::PixelTransfer
  • mMargin : vl::Text
  • mMask : vl::PolygonStipple
  • mMask_Back : vl::StencilFunc , vl::StencilMask
  • mMask_Front : vl::StencilFunc , vl::StencilMask
  • mMaterial : vl::ObjMesh
  • mMaterialIndex : vl::A3DSTriFace
  • mMaterialName
: vl::A3DSObject
, vl::A3DSMaterial
, vl::A3DSMaterialFaceMapping
  • mMaterials : vl::A3DSLoader , vl::ObjLoader
  • mMatFaceMap : vl::A3DSObject
  • mMatrix
: vl::GeometryLoadCallback
, vl::TextureMatrix
, vl::Text
  • mMax : vl::AABB
  • mMaxCorner : vlVolume::VolumePlot
  • mMaximum : vlVolume::Volume
  • mMD5 : vl::MD5CheckSum
  • mMeltingPoint : vlMolecule::AtomInfo
  • mMemoryFile : vl::Font
  • mMeshes : vl::ObjLoader
  • mMicrosecond : vl::Time
  • mMin : vl::AABB
  • mMinCorner : vlVolume::VolumePlot
  • mMinFilter : vl::TexParameter
  • mMinimum : vlVolume::Volume
  • mMinute : vl::Time , vl::ZippedFileInfo
  • mMipmapLevel : vl::FBOTexture3DAttachment , vl::FBOTextureLayerAttachment
  • mMipmaps : vl::Image
  • mMM_Base : vl::ObjTexture
  • mMM_Gain : vl::ObjTexture
  • mMode
: vl::TexEnv
, vl::GZipCodec
, vl::Fog
, vl::Text
, vl::TrackballManipulator
  • mModeAlpha : vl::BlendEquation
  • mModeRGB : vl::BlendEquation
  • mMolecule : vlMolecule::RingExtractor
  • mMoleculeName : vlMolecule::Molecule
  • mMoleculeStyle : vlMolecule::Molecule
  • mMonth : vl::Time , vl::ZippedFileInfo
  • mMouseDownCount : vlWin32::Win32Window , vlMFC::MFCWindow
  • mMouseStart : vl::TrackballManipulator
  • mMouseVisible : vl::OpenGLContext
  • mMovementSpeed : vl::GhostCameraManipulator
  • mMultisampleSamples : vl::OpenGLContextFormat
  • mName
: vl::Object
, vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyElement
, vlMolecule::AtomInfo
  • mNearFarClippingPlanesOptimized : vl::Camera
  • mNearPlane : vl::Camera
  • mNextPass : vl::RenderToken
  • mNi : vl::ObjMaterial
  • mNodes : vl::ShaderNode
  • mNormal
: vl::Portal
, vl::Billboard
, vl::Plane
, vl::PolygonSimplifier::Triangle
, vl::PlyLoader::PlyElement
  • mNormal1 : vl::EdgeExtractor::Edge
  • mNormal2 : vl::EdgeExtractor::Edge
  • mNormal2_Binding : vl::MorphingActor
  • mNormalFrames : vl::MorphingActor
  • mNormalize : vl::VertexAttributeArray
  • mNormals
: vl::ObjLoader
, vl::MorphingActor
, vl::PlyLoader
  • mNormFlags : vlWin32::Win32Context
  • mNormPosit : vlWin32::Win32Context
  • mNormsArray : vlVolume::MarchingCubes
  • mNormSize : vlWin32::Win32Context
  • mNs : vl::ObjMaterial
  • mO_UVW : vl::ObjTexture
  • mObject : vl::ref< T >
  • mObjectPlaneQ : vl::TexGen
  • mObjectPlaneR : vl::TexGen
  • mObjectPlaneS : vl::TexGen
  • mObjectPlaneT : vl::TexGen
  • mObjects : vl::A3DSLoader
  • mOcclusionCullingEnabled : vl::Renderer
  • mOcclusionQuery : vl::Actor
  • mOcclusionQueryTick : vl::Renderer , vl::Actor
  • mOcclusionQueryTickPrev : vl::Renderer
  • mOcclusionShader : vl::Renderer
  • mOcclusionThreshold : vl::Renderer
  • mode()
: vl::Fog
, vl::TexEnv
, vl::Text
, vl::TrackballManipulator
  • modeAlpha() : vl::BlendEquation
  • modeRGB() : vl::BlendEquation
  • molecule() : vlMolecule::RingExtractor
  • Molecule() : vlMolecule::Molecule
  • moleculeName() : vlMolecule::Molecule
  • moleculeStyle() : vlMolecule::Molecule
  • month()
: vl::ZippedFileInfo
, vl::Time
  • mOpenGLContext
: vl::Renderer
, vl::RenderTarget
, vl::UIEventListener
  • mOperand0Alpha : vl::TexEnv
  • mOperand0RGB : vl::TexEnv
  • mOperand1Alpha : vl::TexEnv
  • mOperand1RGB : vl::TexEnv
  • mOperand2Alpha : vl::TexEnv
  • mOperand2RGB : vl::TexEnv
  • mOpt_decal : vl::A3DSTexture
  • mOpt_ignore_alpha : vl::A3DSTexture
  • mOpt_mirror : vl::A3DSTexture
  • mOpt_negative : vl::A3DSTexture
  • mOpt_one_channel_tint : vl::A3DSTexture
  • mOpt_rgb_tint : vl::A3DSTexture
  • mOpt_summed_area : vl::A3DSTexture
  • mOpt_tile : vl::A3DSTexture
  • mOpt_use_alpha : vl::A3DSTexture
  • mOrigin
: vl::Plane
, vl::Ray
, vl::Terrain
  • mOriginalIndex : vl::PolygonSimplifier::Vertex
  • MorphingActor() : vl::MorphingActor
  • MorphingCallback : vl::MorphingActor
  • mouseDownEvent()
: vl::TrackballManipulator
, vl::UIEventListener
  • mouseMoveEvent()
: vl::TrackballManipulator
, vl::UIEventListener
, vlQt4::Qt4Widget
, vl::GhostCameraManipulator
  • mousePressEvent() : vlQt4::Qt4Widget
  • mouseReleaseEvent() : vlQt4::Qt4Widget
  • mouseUpEvent()
: vl::TrackballManipulator
, vl::UIEventListener
  • mouseVisible() : vl::OpenGLContext
  • mouseWheelEvent() : vl::UIEventListener
  • mOutlineColor : vl::Text
  • mOutlineEnabled : vl::Text
  • movementSpeed() : vl::GhostCameraManipulator
  • mParent
: vl::ActorTreeAbstract
, vl::ShaderNode
, vl::Transform
  • mPatches : vl::BezierSurface
  • mPath
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::VirtualDirectory
, vl::VirtualFile
  • mPattern : vl::LineStipple
  • mPerspectiveCorrectionHint : vl::Hint
  • mPitch : vl::Image
  • mPivot : vl::TrackballManipulator
  • mPivotPoint : vl::A3DSObject
  • mPixelRangeSet : vl::PixelLODEvaluator
  • mPixels : vl::Image
  • mPlane : vl::ClipPlane , vl::ActorKdTree
  • mPlaneIndex : vl::ClipPlane
  • mPlanes : vl::Frustum
  • mPlotTransform : vlVolume::VolumePlot
  • mPointSize : vl::PointSize
  • mPointSmoothHint : vl::Hint
  • mPointSpriteCoordReplace : vl::TexEnv
  • mPolygonOffsetFactor : vl::EdgeRenderer
  • mPolygonOffsetUnits : vl::EdgeRenderer
  • mPolygonSmoothHint : vl::Hint
  • mPortalActorMap : vl::SceneManagerPortals
  • mPortalGeometry : vl::Portal
  • mPortals : vl::Sector
  • mPos : vl::A3DSVertex
  • mPosition
: vl::DrawPixels::Pixels
, vl::Light
, vl::PolygonSimplifier::Vertex
, vl::GhostCameraManipulator
  • mPositionPath : vl::Extrusion
  • mPostColorMatrixAlphaBias : vl::PixelTransfer
  • mPostColorMatrixAlphaScale : vl::PixelTransfer
  • mPostColorMatrixBlueBias : vl::PixelTransfer
  • mPostColorMatrixBlueScale : vl::PixelTransfer
  • mPostColorMatrixGreenBias : vl::PixelTransfer
  • mPostColorMatrixGreenScale : vl::PixelTransfer
  • mPostColorMatrixRedBias : vl::PixelTransfer
  • mPostColorMatrixRedScale : vl::PixelTransfer
  • mPostConvolutionAlphaBias : vl::PixelTransfer
  • mPostConvolutionAlphaScale : vl::PixelTransfer
  • mPostConvolutionBlueBias : vl::PixelTransfer
  • mPostConvolutionBlueScale : vl::PixelTransfer
  • mPostConvolutionGreenBias : vl::PixelTransfer
  • mPostConvolutionGreenScale : vl::PixelTransfer
  • mPostConvolutionRedBias : vl::PixelTransfer
  • mPostConvolutionRedScale : vl::PixelTransfer
  • mPrimitiveIndex : vl::RayIntersectionGeometry
  • mPrimitives : vl::RayIntersectionGeometry
  • mPrimitiveType : vl::Tessellator
  • mPrimitiveZ : vl::DepthSortCallback
  • mProjectionMatrix : vl::Camera
  • mProperties : vl::PlyLoader::PlyElement
  • mProtected : vl::PolygonSimplifier::Vertex
  • mProtectedVerts : vl::PolygonSimplifier
  • mPtr
: vl::Buffer
, vl::BufferedStream< Element_Type, Chunk_Size >
, vl::MemoryFile
  • mPureInteger : vl::VertexAttributeArray
  • mQErr : vl::PolygonSimplifier::Vertex
  • mQuadraticAttenuation : vl::Light
  • mQuality : vl::LoadWriterJPG
  • mQuick : vl::PolygonSimplifier
  • mRadius
: vl::Sphere
, vlMolecule::Atom
, vlMolecule::Bond
  • mRank : vl::UIEventListener , vl::RenderingCallback
  • mRasMolColor : vlMolecule::AtomInfo
  • mRay : vl::RayIntersector
  • mReadBuffer : vl::ReadPixels , vl::CopyTexSubImage
  • mReadBytes : vl::GZipCodec , vl::ZippedFile
  • mReadFramebuffer : vl::BlitFramebuffer
  • mReallocateRenderbuffer : vl::FBORenderbufferAttachment
  • mRed : vl::ColorMask
  • mRedBias : vl::PixelTransfer
  • mRedScale : vl::PixelTransfer
  • mRefValue : vl::AlphaFunc
  • mRefValue_Back : vl::StencilFunc
  • mRefValue_Front : vl::StencilFunc
  • mRemoveAfterCall : vl::RenderingCallback
  • mRemoved : vl::PolygonSimplifier::Triangle , vl::PolygonSimplifier::Vertex
  • mRemoveDoubles : vl::GeometryLoadCallback , vl::PolygonSimplifier
  • mRemoveOrder : vl::PolygonSimplifier::Vertex
  • mRenderable : vl::RenderToken
  • mRenderables : vl::Actor
  • mRenderBlock : vl::Actor
  • mRenderedLineCount : vl::Renderer
  • mRenderedPointCount : vl::Renderer
  • mRenderedRenderableCount : vl::Renderer
  • mRenderedTriangleCount : vl::Renderer
  • mRenderer : vl::Rendering
  • mRenderingCallbacks : vl::Actor , vl::RenderingAbstract
  • mRenderQueue : vl::Rendering
  • mRenderQueueSorter : vl::Rendering
  • mRenderRank : vl::Actor , vl::Effect
  • mRenderStates : vl::ShaderNode , vl::RenderStateSet
  • mRenderStates_Final : vl::ShaderNode
  • mRenderStateSet : vl::Shader
  • mRenderStateTable : vl::Renderer
  • mRenderTarget : vl::OpenGLContext , vl::Rendering
  • mResources : vl::ResourceDatabase
  • mRGBABits : vl::OpenGLContextFormat
  • mRGBScale : vl::TexEnv
  • mRingOffset : vlMolecule::Molecule
  • mRotation : vl::A3DSTexture
  • mRotationButton : vl::TrackballManipulator
  • mRotationPath : vl::Extrusion
  • mRotationSpeed : vl::GhostCameraManipulator , vl::TrackballManipulator
  • mS0 : vl::Glyph
  • mS1 : vl::Glyph
  • mS_UVW : vl::ObjTexture
  • mSamples : vl::FBORenderbufferAttachment
  • mSamplingResolution : vlVolume::VolumePlot
  • mSavePath : vl::ReadPixels
  • mScalar
: vl::Vector3< scalar_type >
, vl::Vector2< scalar_type >
, vl::Vector4< scalar_type >
  • mScalars : vl::PlyLoader::PlyScalarList
  • mScalarType : vl::PlyLoader::PlyScalarList , vl::PlyLoader::PlyScalar
  • mScalingPath : vl::Extrusion
  • mSceneBoundingSphere : vl::Camera
  • mSceneManagerActorTree : vlut::Applet
  • mSceneManagers : vl::Rendering
  • mScheduleLink : vl::GLSLProgram
  • mScissor
: vl::Shader
, vl::Actor
, vl::Scissor
  • mScissorBox : vl::Clear
  • mScreen : vlSDL::SDLWindow
  • mSecond : vl::ZippedFileInfo , vl::Time
  • mSectors : vl::SceneManagerPortals
  • mSetupParams : vl::Texture
  • mSFail_Back : vl::StencilOp
  • mSFail_Front : vl::StencilOp
  • mShadeModel : vl::ShadeModel
  • mShader : vl::RenderToken , vl::ShaderNode
  • mShaderAnimationEnabled : vl::Rendering
  • mShaderNode : vl::Terrain
  • mShaders : vl::GLSLProgram
  • mShadowColor : vl::Text
  • mShadowEnabled : vl::Text
  • mShadowVector : vl::Text
  • mShininess : vl::A3DSMaterial
  • mShininessStrength : vl::A3DSMaterial
  • mShort : vl::PlyLoader::PlyScalar
  • mShowAtomName : vlMolecule::Atom
  • mShowAtomNames : vlMolecule::Molecule
  • mShowCreases : vl::EdgeRenderer
  • mShowHiddenLines : vl::EdgeRenderer
  • mShowPortals : vl::SceneManagerPortals
  • mSilhouette : vl::Extrusion
  • mSilhouetteMode : vl::Extrusion
  • mSimplifiedIndex : vl::PolygonSimplifier::Vertex
  • mSimplifiedTriangles : vl::PolygonSimplifier
  • mSimplifiedVertices : vl::PolygonSimplifier
  • mSize
: vl::RenderQueue
, vl::Font
, vl::DrawPixels::Pixels
, vl::BufferedStream< Element_Type, Chunk_Size >
, vlVolume::Volume
  • mSizeMax : vl::PointParameter
  • mSizeMin : vl::PointParameter
  • mSizeMP : vl::RenderQueue
  • mSliceCount : vlVolume::SlicedVolume
  • mSlices : vlVolume::Volume
  • mSmooth : vl::Font , vl::Extrusion
  • mSmoothingGroup : vl::A3DSTriFace , vl::A3DSVertex
  • mSmoothLines : vlMolecule::Molecule , vl::EdgeRenderer
  • mSortedLinesUByte : vl::DepthSortCallback
  • mSortedLinesUInt : vl::DepthSortCallback
  • mSortedLinesUShort : vl::DepthSortCallback
  • mSortedPointsUByte : vl::DepthSortCallback
  • mSortedPointsUInt : vl::DepthSortCallback
  • mSortedPointsUShort : vl::DepthSortCallback
  • mSortedQuadsUByte : vl::DepthSortCallback
  • mSortedQuadsUInt : vl::DepthSortCallback
  • mSortedQuadsUShort : vl::DepthSortCallback
  • mSortedTrianglesUByte : vl::DepthSortCallback
  • mSortedTrianglesUInt : vl::DepthSortCallback
  • mSortedTrianglesUShort : vl::DepthSortCallback
  • mSortMode : vl::DepthSortCallback
  • mSortTriangles : vl::GeometryLoadCallback
  • mSortVertices : vl::GeometryLoadCallback
  • mSource : vl::GLSLShader
  • mSource0Alpha : vl::TexEnv
  • mSource0RGB : vl::TexEnv
  • mSource1Alpha : vl::TexEnv
  • mSource1RGB : vl::TexEnv
  • mSource2Alpha : vl::TexEnv
  • mSource2RGB : vl::TexEnv
  • mSourceZipFile : vl::ZippedFileInfo , vl::ZippedDirectory
  • mSpecular : vl::Light , vl::A3DSMaterial
  • mSphere : vl::Actor , vl::SceneManager
  • mSpotCutoff : vl::Light
  • mSpotDirection : vl::Light
  • mSpotExponent : vl::Light
  • mSrcAlpha : vl::BlendFunc
  • mSrcRect : vl::BlitFramebuffer
  • mSrcRGB : vl::BlendFunc
  • mStart
: vl::Time
, vl::DrawArrays
, vl::DrawPixels::Pixels
, vl::Fog
  • mStartCameraPos : vl::TrackballManipulator
  • mStartMatrix : vl::TrackballManipulator
  • mStartPivot : vl::TrackballManipulator
  • mStartTime : vlut::Applet
  • mStencilBufferBits : vl::OpenGLContextFormat
  • mStereo : vl::OpenGLContextFormat
  • mStoreInPixelBufferObject : vl::ReadPixels
  • mStream : vl::GZipCodec
  • mStreamSize : vl::GZipCodec
  • mStripfy : vl::GeometryLoadCallback
  • mStyle : vlWin32::Win32Window
  • mSubRendering : vl::RenderingTree
  • mSymbol : vlMolecule::AtomInfo
  • mT0 : vl::Glyph
  • mT1 : vl::Glyph
  • mT_UVW : vl::ObjTexture
  • mTags : vlMolecule::Molecule , vl::Image
  • mTarget : vl::CopyTexSubImage2D
  • mTargetSector : vl::Portal
  • mTempActors : vl::SceneManagerPortals
  • mTerrainTexture : vl::Terrain
  • mTerrainTextureFormat : vl::Terrain
  • mTessellatedTris : vl::Tessellator
  • mTessellateIntoSinglePolygon : vl::Tessellator
  • mTessNormal : vl::Tessellator
  • mTexCoord : vlVolume::SlicedVolume
  • mTexCoords : vl::ObjLoader
  • mTexParameter : vl::Texture
  • mTexres_Value : vl::ObjTexture
  • mText : vl::Text
  • mTextAlignment : vl::Text
  • mTextTemplate : vlVolume::VolumePlot
  • mTexture
: vl::FBOTextureAttachment
, vl::FBOTexture1DAttachment
, vl::FBOTextureLayerAttachment
, vl::TextureUnit
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::FBOTexture2DAttachment
, vl::CopyTexSubImage2D
, vl::FBOTexture3DAttachment
  • mTexture1 : vl::A3DSMaterial
  • mTexture2 : vl::A3DSMaterial
  • mTextureHandle : vl::Glyph
  • mTextureTarget : vl::FBOTexture2DAttachment
  • mTextureUnit : vl::RenderState
  • mTextureUnitCount : vl::OpenGLContext
  • mThreshold : vlVolume::VolumeInfo
  • mTmpStdStr : vl::TextStream
  • mTmpStr : vl::TextStream
  • mTolerance : vl::Tessellator
  • mTop : vl::Glyph
  • mTopRight : vlVolume::Volume
  • mTr : vl::ObjMaterial
  • mTrackball : vlut::Applet
  • mTransferFunction : vlVolume::SlicedVolume
  • mTransform
: vl::Actor
, vl::TrackballManipulator
, vl::Rendering
  • mTransformGeometry : vl::GeometryLoadCallback
  • mTransformTree : vlMolecule::Molecule
  • mTransformUpdateTick : vl::Actor
  • mTranslationButton : vl::TrackballManipulator
  • mTranslationSpeed : vl::TrackballManipulator
  • mTransparency : vl::A3DSMaterial
  • mTriangleConnectionTable : vlVolume::MarchingCubes
  • mTriStrips : vl::Tessellator
  • mTwoSide : vl::LightModel
  • mType
: vl::Image
, vlMolecule::Bond
, vl::FBOColorBufferAttachment
, vlMolecule::AtomInfo
, vl::Primitives
, vl::FBODepthStencilBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::Uniform
, vl::FBODepthBufferAttachment
, vl::Billboard
, vl::GLSLShader
  • mUChar : vl::PlyLoader::PlyScalar
  • mUInt : vl::PlyLoader::PlyScalar
  • mUIntData : vl::Uniform
  • multisample() : vl::OpenGLContextFormat
  • multisampleSamples() : vl::OpenGLContextFormat
  • mUncompressedBuffer : vl::ZippedFile , vl::GZipCodec
  • mUncompressedBufferPtr : vl::ZippedFile , vl::GZipCodec
  • mUncompressedSize : vl::GZipCodec , vl::ZippedFileInfo
  • mUngetBuffer : vl::BufferedStream< Element_Type, Chunk_Size >
  • mUniformLocation : vl::GLSLProgram
  • mUniforms : vl::ShaderNode , vl::UniformSet
  • mUniforms_Final : vl::ShaderNode
  • mUniformSet
: vl::GLSLProgram
, vl::Actor
, vl::Shader
  • mUnits : vl::PolygonOffset
  • mUOffset : vl::A3DSTexture
  • mUpdateTime : vl::RenderingAbstract
  • mUpdateTimer : vlQt4::Qt4Widget
  • mUsage : vl::GLBufferObject
  • mUScale : vl::A3DSTexture
  • mUseAtomColors : vlMolecule::Bond
  • mUseCameraRotationInverse : vl::TextureMatrix
  • mUseDisplayLists : vl::GeometryLoadCallback
  • mUseGLSL : vl::Terrain
  • mUsePixelBufferObject : vl::DrawPixels
  • mUseVBOs : vl::GeometryLoadCallback
  • mUShort : vl::PlyLoader::PlyScalar
  • mUV : vl::A3DSVertex
  • mValence : vlMolecule::AtomInfo
  • mValue : vl::SampleCoverage
  • mValues : vlVolume::Volume
  • mVanDerWaalsRadius : vlMolecule::AtomInfo
  • mVBODirty : vl::ArrayAbstract
  • mVBOUsage : vl::ArrayAbstract
  • mVec
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
  • mVector : vl::Collection< T >
  • mVectorGraphicObjects : vlVG::SceneManagerVectorGraphics
  • mVerbose : vl::PolygonSimplifier
  • mVersionNeeded : vl::ZippedFileInfo
  • mVert0 : vlVolume::VolumeInfo
  • mVertC : vlVolume::VolumeInfo
  • mVertex : vl::PlyLoader::PlyElement
  • mVertex1 : vl::EdgeExtractor::Edge
  • mVertex2 : vl::EdgeExtractor::Edge
  • mVertex2_Binding : vl::MorphingActor
  • mVertexFrames : vl::MorphingActor
  • mVertexIndex : vl::PlyLoader
  • mVertexShader : vl::Terrain
  • mVertices
: vl::A3DSObject
, vl::PolygonSimplifier::Triangle
, vl::MorphingActor
  • mVerts : vl::PlyLoader
  • mVertsArray : vlVolume::MarchingCubes
  • mViewMatrix : vl::Camera
  • mViewport : vl::Camera
  • mViewportAlignment : vl::Text
  • mVisible : vlMolecule::Bond , vlMolecule::Atom
  • mVisibleActors : vl::EdgeRenderer
  • mVisited : vlMolecule::Atom
  • mVisitTick : vl::SceneManagerPortals , vl::Portal
  • mVOffset : vl::A3DSTexture
  • mVolume : vlVolume::VolumeInfo
  • mVolumes : vl::Sector
  • mVScale : vl::A3DSTexture
  • mVSync : vl::OpenGLContextFormat
  • mWarnNonManifold : vl::EdgeExtractor
  • mWarnOnSeek : vl::GZipCodec
  • mWidth
: vl::Glyph
, vl::Terrain
, vl::ReadPixels
, vl::Viewport
, vl::CopyTexSubImage2D
, vl::RenderTarget
, vl::FBORenderbufferAttachment
, vl::CopyTexSubImage3D
, vl::Texture
, vl::Image
, vl::CopyTexSubImage1D
, vl::Rect< T >
  • mWindingRule : vl::Tessellator
  • mWindowClassName : vlWin32::Win32Window
  • mWinMap : vlGLUT::GLUTWindow , vlWin32::Win32Window
  • mWorldMatrix : vl::Transform
  • mWorldMatrixUpdateTick : vl::Transform
  • mWrapR : vl::TexParameter
  • mWrapS : vl::TexParameter
  • mWrapT : vl::TexParameter
  • mWriteCallbacks : vl::LoadWriterManager
  • mWriteExtensions : vl::ResourceLoadWriter
  • mWrittenBytes : vl::GZipCodec
  • mX
: vl::Rect< T >
, vl::CopyTexSubImage3D
, vl::Viewport
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::ReadPixels
, vl::BezierPatch
  • mXDegrees : vl::GhostCameraManipulator
  • mXOffset
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • mXYZW : vl::quat
  • mY
: vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::ReadPixels
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
, vl::Viewport
, vl::BezierPatch
  • mYDegrees : vl::GhostCameraManipulator
  • mYear : vl::ZippedFileInfo , vl::Time
  • mYOffset : vl::CopyTexSubImage3D , vl::CopyTexSubImage2D
  • mZBufferBits : vl::OpenGLContextFormat
  • mZFar : vl::DepthRange
  • mZipBufferIn : vl::ZippedFile , vl::GZipCodec
  • mZipBufferOut : vl::ZippedFile , vl::GZipCodec
  • mZippedFileInfo : vl::ZippedFile
  • mZippedFileOffset : vl::ZippedFileInfo
  • mZNear : vl::DepthRange
  • mZOffset : vl::CopyTexSubImage3D
  • mZoomButton : vl::TrackballManipulator
  • mZoomSpeed : vl::TrackballManipulator
  • mZStream : vl::ZippedFile , vl::GZipCodec
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- n -

  • name()
: vl::Object
, vl::PlyLoader::PlyPropertyAbstract
, vlMolecule::AtomInfo
, vl::PlyLoader::PlyElement
  • nearFarClippingPlanesOptimized() : vl::Camera
  • nearPlane() : vl::Camera
  • newElement() : vl::PlyLoader
  • newToken() : vl::RenderQueue
  • next() : vl::ResourceDatabase
  • ni() : vl::ObjMaterial
  • nlerp() : vl::quat
  • NO_TYPE : vl::SayArg
  • NoMode : vl::TrackballManipulator
  • NONE : vl::Uniform
  • normal()
: vl::Plane
, vl::PolygonSimplifier::Triangle
, vl::Portal
, vl::Billboard
  • normal1() : vl::EdgeExtractor::Edge
  • normal2() : vl::EdgeExtractor::Edge
  • normalArray()
: vl::ObjLoader
, vl::Geometry
, vl::ObjLoader
  • normalHQ() : vlVolume::Volume
  • normalize()
: vl::ArrayAbstract
, vl::VertexAttributeArray
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • normalizeSlashes() : vl::String
  • normalLQ() : vlVolume::Volume
  • ns() : vl::ObjMaterial
  • null()
: vl::String
, vl::Viewport
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- o -

  • o_UVW() : vl::ObjTexture
  • Object() : vl::Object
  • objectPlaneQ() : vl::TexGen
  • objectPlaneR() : vl::TexGen
  • objectPlaneS() : vl::TexGen
  • objectPlaneT() : vl::TexGen
  • ObjMaterial() : vl::ObjMaterial
  • ObjTexture() : vl::ObjTexture
  • occlusionCullingEnabled() : vl::Renderer
  • occlusionQuery() : vl::Actor
  • occlusionQueryTick() : vl::Actor
  • occlusionThreshold() : vl::Renderer
  • offset() : vl::PolygonSimplifier::QErr
  • OnClose() : vlMFC::MFCWindow
  • OnCreate() : vlMFC::MFCWindow
  • OnDropFiles()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnEraseBackground() : vlWX::vlWXGLCanvas
  • OnIdle() : vlWX::vlWXGLCanvas
  • OnKeyDown()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnKeyUp()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnLButtonDblClk() : vlMFC::MFCWindow
  • OnLButtonDown() : vlMFC::MFCWindow
  • OnLButtonUp() : vlMFC::MFCWindow
  • OnMButtonDblClk() : vlMFC::MFCWindow
  • OnMButtonDown() : vlMFC::MFCWindow
  • OnMButtonUp() : vlMFC::MFCWindow
  • OnMouseDown() : vlWX::vlWXGLCanvas
  • OnMouseEnter() : vlWX::vlWXGLCanvas
  • OnMouseMotion() : vlWX::vlWXGLCanvas
  • OnMouseMove() : vlMFC::MFCWindow
  • OnMouseUp() : vlWX::vlWXGLCanvas
  • OnMouseWheel()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnPaint()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnRButtonDblClk() : vlMFC::MFCWindow
  • OnRButtonDown() : vlMFC::MFCWindow
  • OnRButtonUp() : vlMFC::MFCWindow
  • OnSize()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnTimer() : vlMFC::MFCWindow
  • open()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • openglContext()
: vl::Renderer
, vl::RenderTarget
, vl::UIEventListener
  • OpenGLContext
: vl::FBORenderTarget
, vl::RenderTarget
, vl::UIEventListener
, vl::OpenGLContext
  • openglContextBoundEvent()
: vl::UIEventListener
, vlut::Applet
  • OpenGLContextFormat() : vl::OpenGLContextFormat
  • openglContextInfo() : vl::OpenGLContext
  • operand0Alpha() : vl::TexEnv
  • operand0RGB() : vl::TexEnv
  • operand1Alpha() : vl::TexEnv
  • operand1RGB() : vl::TexEnv
  • operand2Alpha() : vl::TexEnv
  • operand2RGB() : vl::TexEnv
  • operator bool() : vl::ref< T >
  • operator std::vector< ref< T > >() : vl::Collection< T >
  • operator String() : vl::Say
  • operator!=()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::MD5CheckSum
, vl::quat
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator()()
: vl::ActorRenderingCallback
, vl::DepthSortCallback
, vl::EdgeUpdateCallback
, vl::GeometryLoadCallback
, vl::LoadCallback
, vl::WriteCallback
, vl::MorphingCallback
, vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterBasic
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
, vl::RenderQueueSorterAggressive
, vl::Sector::VisibilityCallback
, vlVolume::VolumePlot::Function
  • operator*()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::ref< T >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator*=()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator+()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::PolygonSimplifier::QErr
, vl::quat
, vl::Sphere
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::AABB
  • operator+=()
: vl::AABB
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::PolygonSimplifier::QErr
, vl::quat
, vl::Sphere
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator-()
: vl::Vector4< scalar_type >
, vl::Vector2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator-=()
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector2< scalar_type >
  • operator->() : vl::ref< T >
  • operator/()
: vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Vector2< scalar_type >
  • operator/=()
: vl::Vector3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Vector2< scalar_type >
, vl::quat
, vl::Vector4< scalar_type >
  • operator<()
: vl::ref< T >
, vl::Rect< T >
, vl::Vector4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::String
, vl::A3DSVertex
, vl::Font
, vl::UIEventListener
, vl::EdgeExtractor::Edge
, vl::MD5CheckSum
, vl::Scissor
, vl::Vector3< scalar_type >
  • operator<<() : vl::Say
  • operator=()
: vl::RectI
, vl::Rendering
, vl::RenderingTree
, vl::DrawPixels::Pixels
, vl::String
, vl::Vector4< scalar_type >
, vlMolecule::Atom
, vl::RenderingAbstract
, vlMolecule::Molecule
, vl::ZippedFile
, vl::RectF
, vl::Geometry
, vl::Matrix4< scalar_type >
, vl::MemoryFile
, vl::Matrix2< scalar_type >
, vl::DiskFile
, vl::GZipCodec
, vl::Object
, vl::Collection< T >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::ref< T >
, vl::RectI
, vl::GLBufferObject
, vl::Buffer
, vl::VirtualFile
, vl::ref< T >
, vl::Vector3< scalar_type >
, vl::Sphere
, vl::String
, vl::Matrix3< scalar_type >
, vl::Vector2< scalar_type >
, vl::String
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::String
, vl::Vector2< scalar_type >
, vl::Image
, vl::String
, vl::ArrayAbstract
, vl::RectF
, vl::ref< T >
  • operator==()
: vl::Matrix3< scalar_type >
, vl::Vector2< scalar_type >
, vl::EdgeExtractor::Edge
, vl::String
, vl::Matrix2< scalar_type >
, vl::String
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::String
, vl::MD5CheckSum
, vl::String
, vl::quat
, vl::String
, vl::Matrix4< scalar_type >
  • operator[]()
: vl::Matrix3< scalar_type >
, vl::Vector2< scalar_type >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::String
, vl::Matrix4< scalar_type >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::String
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Collection< T >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Matrix2< scalar_type >
  • origin()
: vl::Terrain
, vl::Ray
, vl::Plane
  • originalIndex() : vl::PolygonSimplifier::Vertex
  • ortho() : vl::Matrix4< scalar_type >
  • ortho2D() : vl::Matrix4< scalar_type >
  • outlineColor() : vl::Text
  • outlineEnabled() : vl::Text
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- z -

  • z()
: vl::quat
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • ZCompress : vl::GZipCodec
  • ZDecompress : vl::GZipCodec
  • zFar() : vl::DepthRange
  • ZippedDirectory : vl::ZippedFileInfo , vl::ZippedDirectory
  • zippedFile() : vl::ZippedDirectory
  • ZippedFile : vl::ZippedFileInfo , vl::ZippedFile
  • zippedFileCount() : vl::ZippedDirectory
  • zippedFileInfo() : vl::ZippedFile
  • ZippedFileInfo() : vl::ZippedFileInfo
  • zippedFileOffset() : vl::ZippedFileInfo
  • zippedSubDir() : vl::ZippedDirectory
  • zNear() : vl::DepthRange
  • ZNone : vl::GZipCodec
  • zoffset() : vl::CopyTexSubImage3D
  • zoomButton() : vl::TrackballManipulator
  • ZoomMode : vl::TrackballManipulator
  • zoomSpeed() : vl::TrackballManipulator
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- ~ -

  • ~Actor() : vl::Actor
  • ~Applet() : vlut::Applet
  • ~Buffer() : vl::Buffer
  • ~DiskFile() : vl::DiskFile
  • ~Effect() : vl::Effect
  • ~FBOAttachmentAbstract() : vl::FBOAttachmentAbstract
  • ~FBORenderTarget() : vl::FBORenderTarget
  • ~Font() : vl::Font
  • ~Geometry() : vl::Geometry
  • ~GLBufferObject() : vl::GLBufferObject
  • ~GLSLProgram() : vl::GLSLProgram
  • ~GLSLShader() : vl::GLSLShader
  • ~GLUTWindow() : vlGLUT::GLUTWindow
  • ~Glyph() : vl::Glyph
  • ~GZipCodec() : vl::GZipCodec
  • ~Image() : vl::Image
  • ~MFCWindow() : vlMFC::MFCWindow
  • ~Molecule() : vlMolecule::Molecule
  • ~Object() : vl::Object
  • ~OpenGLContext() : vl::OpenGLContext
  • ~Pixels() : vl::DrawPixels::Pixels
  • ~Primitives() : vl::Primitives
  • ~ref() : vl::ref< T >
  • ~Renderable() : vl::Renderable
  • ~Renderer() : vl::Renderer
  • ~RenderState() : vl::RenderState
  • ~SDLWindow() : vlSDL::SDLWindow
  • ~Shader() : vl::Shader
  • ~Tessellator() : vl::Tessellator
  • ~TextStream() : vl::TextStream
  • ~Texture() : vl::Texture
  • ~Transform() : vl::Transform
  • ~UIEventListener() : vl::UIEventListener
  • ~VirtualFile() : vl::VirtualFile
  • ~vlWXGLCanvas() : vlWX::vlWXGLCanvas
  • ~ZippedFile() : vl::ZippedFile
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- b -

  • b()
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • b2 : vl::PolygonSimplifier::QErr
  • back() : vl::Collection< T >
  • backAmbient() : vl::Material
  • backDiffuse() : vl::Material
  • backEmission() : vl::Material
  • backFace() : vl::PolygonMode
  • backgroundColor() : vl::Text
  • backgroundEnabled() : vl::Text
  • backShininess() : vl::Material
  • backSpecular() : vl::Material
  • ballAndStickStyle() : vlMolecule::Molecule
  • bc : vl::PolygonSimplifier::QErr
  • bd : vl::PolygonSimplifier::QErr
  • begin() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • BezierPatch() : vl::BezierPatch
  • BezierSurface() : vl::BezierSurface
  • Billboard() : vl::Billboard
  • binary() : vl::PlyLoader
  • bindAttachment()
: vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
, vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
, vl::FBOAttachmentAbstract
, vl::FBOColorBufferAttachment
, vl::FBODepthBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::FBODepthStencilBufferAttachment
, vl::FBOTexture1DAttachment
  • bindAttribLocation() : vl::GLSLProgram
  • bindDrawBuffers() : vl::RenderTarget
  • bindFragDataLocation() : vl::GLSLProgram
  • bindFramebuffer()
: vl::FBORenderTarget
, vl::RenderTarget
  • bindManipulators() : vlut::Applet
  • bitsPerPixel()
: vl::Image
, vl::OpenGLContextFormat
  • BlendColor() : vl::BlendColor
  • blendColor() : vl::BlendColor
  • BlendEquation() : vl::BlendEquation
  • blendFrames() : vl::MorphingActor
  • BlendFunc() : vl::BlendFunc
  • blendingEnabled()
: vl::EnableSet
, vl::Shader
  • blendU() : vl::ObjTexture
  • blendV() : vl::ObjTexture
  • BlitFramebuffer() : vl::BlitFramebuffer
  • blue() : vl::ColorMask
  • blueBias() : vl::PixelTransfer
  • blueScale() : vl::PixelTransfer
  • bm() : vl::ObjTexture
  • boilingPoint() : vlMolecule::AtomInfo
  • bond() : vlMolecule::Molecule
  • Bond() : vlMolecule::Bond
  • bond() : vlMolecule::Molecule
  • bondCount() : vlMolecule::Molecule
  • bondDetail() : vlMolecule::Molecule
  • bonds() : vlMolecule::Molecule
  • bondType() : vlMolecule::Bond
  • bootstrap() : vlMolecule::RingExtractor
  • border()
: vl::Texture::SetupParams
, vl::Texture
  • borderColor()
: vl::Text
, vl::TexParameter
  • borderEnabled() : vl::Text
  • bottom() : vl::Rect< T >
  • bottomLeft()
: vlVolume::Volume
, vl::RectI
, vl::RectF
  • boundaryOnly() : vl::Tessellator
  • boundingBox()
: vl::SceneManager
, vl::Actor
, vl::Renderable
  • boundingRect() : vl::Text
  • boundingRectTransformed() : vl::Text
  • boundingSphere()
: vl::Actor
, vl::Renderable
, vl::SceneManager
  • boundsDirty()
: vl::SceneManager
, vl::Renderable
  • boundsUpdateTick() : vl::Renderable
  • box() : vlVolume::SlicedVolume
  • boxEffect() : vlVolume::VolumePlot
  • buffer() : vl::MemoryFile
  • Buffer() : vl::Buffer
  • BufferedStream() : vl::BufferedStream< Element_Type, Chunk_Size >
  • bufferEmpty() : vl::BufferedStream< Element_Type, Chunk_Size >
  • bufferMask() : vl::BlitFramebuffer
  • bug() : vl::Log
  • byteAlignment() : vl::Image
  • byteCountGPU() : vl::GLBufferObject
  • bytesPerVector() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • bytesUsed()
: vl::Buffer
, vl::ArrayAbstract
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- c -

  • c2 : vl::PolygonSimplifier::QErr
  • calculatedRadius() : vlMolecule::AtomInfo
  • callbacks() : vl::Sector
  • camera() : vl::Rendering
  • Camera() : vl::Camera
  • camera()
: vl::TrackballManipulator
, vl::GhostCameraManipulator
  • canLoad()
: vl::LoadWriterManager
, vl::ResourceLoadWriter
  • canWrite()
: vl::ResourceLoadWriter
, vl::LoadWriterManager
  • capacity() : vl::Collection< T >
  • CatmullRomInterpolator() : vl::CatmullRomInterpolator< T >
  • CatmullRomInterpolatorDouble() : vl::CatmullRomInterpolatorDouble
  • CatmullRomInterpolatorDVec2() : vl::CatmullRomInterpolatorDVec2
  • CatmullRomInterpolatorDVec3() : vl::CatmullRomInterpolatorDVec3
  • CatmullRomInterpolatorDVec4() : vl::CatmullRomInterpolatorDVec4
  • CatmullRomInterpolatorFloat() : vl::CatmullRomInterpolatorFloat
  • CatmullRomInterpolatorFVec2() : vl::CatmullRomInterpolatorFVec2
  • CatmullRomInterpolatorFVec3() : vl::CatmullRomInterpolatorFVec3
  • CatmullRomInterpolatorFVec4() : vl::CatmullRomInterpolatorFVec4
  • cc() : vl::ObjTexture
  • cd : vl::PolygonSimplifier::QErr
  • cellSize() : vlVolume::Volume
  • center()
: vl::AABB
, vl::Sphere
, vl::Viewport
  • checkConnectivity() : vl::PolygonSimplifier::Vertex
  • checkDrawBuffers() : vl::RenderTarget
  • checkFramebufferStatus() : vl::FBORenderTarget
  • checkTriangle() : vl::PolygonSimplifier::Triangle
  • checkTriangles() : vl::PolygonSimplifier::Vertex
  • child()
: vl::ActorKdTree
, vl::ActorTree
, vl::ActorTreeAbstract
, vl::ShaderNode
, vl::Transform
  • childCount() : vl::Transform
  • childN() : vl::ActorKdTree
  • childP() : vl::ActorKdTree
  • childrenCount()
: vl::ShaderNode
, vl::ActorKdTree
, vl::ActorTree
, vl::ActorTreeAbstract
  • chunk() : vl::Terrain
  • CHUNK_SIZE : vl::GZipCodec , vl::ZippedFile
  • chunkCount() : vl::Terrain
  • chunks() : vl::Terrain
  • clamp() : vl::ObjTexture
  • classify() : vl::Plane
  • className()
: vl::GLSLVertexShader
, vlVolume::Volume
, vlVolume::VolumeInfo
, vl::GLSLFragmentShader
, vl::GLSLGeometryShader
, vl::GLSLProgram
, vl::GZipCodec
, vl::Image
, vl::Light
, vl::LoadWriterManager
, vl::LODEvaluator
, vl::Log
, vl::StandardLog
, vl::MD5CheckSum
, vl::MemoryDirectory
, vl::MemoryFile
, vl::MorphingCallback
, vl::MorphingActor
, vl::Object
, vl::OpenGLContextFormat
, vl::Actor
, vl::OpenGLContext
, vl::PixelLODEvaluator
, vl::ActorKdTree
, vl::Plane
, vl::PolygonSimplifier
, vl::ActorTree
, vl::Primitives
, vl::RayIntersection
, vl::ActorTreeAbstract
, vl::RayIntersectionGeometry
, vl::RayIntersector
, vl::ArrayAbstract
, vl::ReadPixels
, vl::Rect< T >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::RectI
, vl::RectF
, vl::BezierPatch
, vl::Renderable
, vl::Renderer
, vl::BezierSurface
, vl::Rendering
, vl::RenderingCallback
, vl::Billboard
, vl::RenderingTree
, vl::RenderQueue
, vl::BlitFramebuffer
, vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::Buffer
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterBasic
, vl::BufferedStream< Element_Type, Chunk_Size >
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
, vl::Camera
, vl::RenderQueueSorterAggressive
, vl::RenderState
, vl::Clear
, vl::RenderTarget
, vl::RenderToken
, vl::ClipPlane
, vl::ResourceDatabase
, vl::ResourceLoadWriter
, vl::Collection< T >
, vl::SceneManager
, vl::SceneManagerActorKdTree
, vl::CopyTexSubImage1D
, vl::SceneManagerActorTree
, vl::SceneManagerBVH< T >
, vl::CopyTexSubImage2D
, vl::Scissor
, vl::PixelTransfer
, vl::CopyTexSubImage3D
, vl::Hint
, vl::CullFace
, vl::DepthSortCallback
, vl::FrontFace
, vl::DepthFunc
, vl::DiskDirectory
, vl::DepthMask
, vl::PolygonMode
, vl::DiskFile
, vl::ShadeModel
, vl::BlendFunc
, vl::DistanceLODEvaluator
, vl::BlendEquation
, vl::SampleCoverage
, vl::VertexMapper
, vl::AlphaFunc
, vl::Material
, vl::DoubleVertexRemover
, vl::LightModel
, vl::Fog
, vl::DrawArrays
, vl::PolygonOffset
, vl::LogicOp
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::DepthRange
, vl::LineWidth
, vl::DrawPixels
, vl::PointSize
, vl::PolygonStipple
, vl::EdgeExtractor
, vl::LineStipple
, vl::PointParameter
, vl::EdgeRenderer
, vl::StencilFunc
, vl::StencilOp
, vl::EdgeUpdateCallback
, vl::StencilMask
, vl::BlendColor
, vl::ShaderSequence
, vl::ColorMask
, vl::TextureMatrix
, vl::Effect
, vl::TexEnv
, vl::TexGen
, vl::FileSystem
, vl::TextureUnit
, vl::RenderStateSet
, vl::Glyph
, vl::EnableSet
, vl::Shader
, vl::Font
, vl::ShaderNode
, vl::Terrain
, vl::FontManager
, vl::Text
, vl::TextStream
, vl::FBOAttachmentAbstract
, vl::TexParameter
, vl::Texture
, vl::FBORenderbufferAttachment
, vl::Time
, vl::TrackballManipulator
, vl::FBOColorBufferAttachment
, vl::Transform
, vl::TriangleStripGenerator
, vl::FBODepthBufferAttachment
, vl::UIEventListener
, vl::Uniform
, vl::FBOStencilBufferAttachment
, vl::UniformSet
, vl::VertexAttributeArray
, vl::FBODepthStencilBufferAttachment
, vl::Viewport
, vl::VirtualDirectory
, vl::FBOTexture1DAttachment
, vl::VirtualFile
, vl::LoadWriter3DS
, vl::FBOTexture2DAttachment
, vl::LoadWriterAC3D
, vl::LoadWriterBMP
, vl::FBOTextureAttachment
, vl::LoadWriterDAT
, vl::LoadWriterDDS
, vl::FBOTexture3DAttachment
, vl::LoadWriterDICOM
, vl::LoadWriterJPG
, vl::FBOTextureLayerAttachment
, vl::LoadWriterMD2
, vl::LoadWriterOBJ
, vl::FBORenderTarget
, vl::ObjMaterial
, vl::ObjMesh
, vl::Frustum
, vl::LoadWriterPLY
, vl::LoadWriterPNG
, vlVG::VectorGraphics
, vlVG::SceneManagerVectorGraphics
, vlut::Applet
, vl::Geometry
, vl::ZippedFileInfo
, vl::ZippedDirectory
, vl::LoadWriterSTL
, vl::STLLoader
, vl::GeometryLoadCallback
, vl::LoadWriterTGA
, vl::LoadWriterTIFF
, vl::GhostCameraManipulator
, vl::GLBufferObject
, vl::ZippedFile
, vl::GLSLShader
  • clear()
: vl::ArrayAbstract
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Buffer
, vl::Collection< T >
, vl::Image
, vl::KeyValues
, vl::RenderQueue
, vl::String
, vlVG::VectorGraphics
  • Clear() : vl::Clear
  • clearArrays() : vl::Geometry
  • clearCache() : vl::EdgeRenderer
  • clearColor()
: vl::Viewport
, vlVG::VectorGraphics
  • clearColorInt() : vl::Viewport
  • clearColorMode()
: vl::Clear
, vl::Viewport
  • clearColorUInt() : vl::Viewport
  • clearDepth() : vl::Viewport
  • clearDistanceRangeSet() : vl::DistanceLODEvaluator
  • clearFlags()
: vl::Rendering
, vl::Viewport
  • clearLocalBuffer() : vl::DrawElements< index_type, Tgltype, arr_type >
  • clearMipmaps() : vl::Image
  • clearPixelRangeSet() : vl::PixelLODEvaluator
  • clearStencil()
: vlVG::VectorGraphics
, vl::Viewport
  • clearTrianglesAndVertices() : vl::PolygonSimplifier
  • clip() : vl::AABB
  • ClipPlane() : vl::ClipPlane
  • clone()
: vl::ArrayAbstract
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::DiskFile
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::GZipCodec
, vl::MemoryFile
, vl::Primitives
, vl::VirtualFile
, vl::ZippedFile
, vl::MemoryDirectory
  • close()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::ZippedFile
, vl::VirtualFile
  • collapse() : vl::PolygonSimplifier
  • collapseCost() : vl::PolygonSimplifier::Vertex
  • collapsePosition() : vl::PolygonSimplifier::Vertex
  • collapseVertex() : vl::PolygonSimplifier::Vertex
  • Collection() : vl::Collection< T >
  • collectStatistics() : vl::Renderer
  • color()
: vl::Fog
, vl::TexEnv
, vl::Text
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
, vlVG::VectorGraphics
  • colorArray() : vl::Geometry
  • colorControl() : vl::LightModel
  • colorizePrimitives() : vl::Geometry
  • ColorMask() : vl::ColorMask
  • colorMask() : vlVG::VectorGraphics
  • colorMaterial() : vl::Material
  • colorMaterialEnabled() : vl::Material
  • colorMaterialFace() : vl::Material
  • colorPath() : vl::Extrusion
  • combineAlpha() : vl::TexEnv
  • combineRGB() : vl::TexEnv
  • compare() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::String
  • compareFunc() : vl::TexParameter
  • compareMode() : vl::TexParameter
  • compile() : vl::GLSLShader
  • compileDisplayList() : vl::Renderable
  • compileKdTree() : vl::ActorKdTree
  • compileStatus() : vl::GLSLShader
  • compressedSize()
: vl::ZippedFileInfo
, vl::GZipCodec
  • compression() : vl::LoadWriterPNG
  • compressionLevel() : vl::GZipCodec
  • compressionMethod() : vl::ZippedFileInfo
  • compressionRatio() : vl::GZipCodec
  • compute()
: vl::CRC32CheckSum
, vl::MD5CheckSum
, vl::CRC32CheckSum
, vlVolume::VolumePlot
, vl::MD5CheckSum
  • computeAABB() : vl::ActorTreeAbstract
  • computeAdjacentVertices() : vl::PolygonSimplifier::Vertex
  • computeArea() : vl::PolygonSimplifier::Triangle
  • computeAtomAdjacency() : vlMolecule::Molecule
  • computeAverage() : vlVolume::Volume
  • computeBoundingBox() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::ArrayAbstract , vl::Sector
  • computeBoundingSphere() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • computeBounds()
: vl::Actor
, vl::Renderable
, vl::SceneManager
  • computeBounds_Implementation()
: vl::Geometry
, vl::Text
, vl::DrawPixels
, vl::Renderable
, vl::Clear
  • computeCollapseInfo() : vl::PolygonSimplifier
  • computeEdgePenalty() : vl::PolygonSimplifier::Vertex
  • computeEdges() : vlVolume::MarchingCubes
  • computeFrustumPlanes() : vl::Camera
  • computeMaximum() : vlVolume::Volume
  • computeMinimum() : vlVolume::Volume
  • computeNormal()
: vl::PolygonSimplifier::Triangle
, vl::Portal
  • computeNormals()
: vl::Geometry
, vl::GeometryLoadCallback
  • computePoint()
: vl::LinearInterpolatorFloat
, vl::InterpolatorDouble
, vl::CatmullRomInterpolatorDVec3
, vl::LinearInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::InterpolatorDVec3
, vl::CatmullRomInterpolatorDVec4
, vl::LinearInterpolatorDouble
, vl::CatmullRomInterpolatorDouble
, vl::InterpolatorFVec2
, vl::LinearInterpolator< T >
, vl::InterpolatorDVec2
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolator< T >
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorDVec2
, vl::InterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::InterpolatorFVec3
, vl::CatmullRomInterpolatorFVec4
, vl::InterpolatorDVec4
, vl::InterpolatorFloat
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec2
  • computePortalNormals() : vl::SceneManagerPortals
  • computePotentialArea() : vl::PolygonSimplifier::Triangle
  • computePotentialNormal() : vl::PolygonSimplifier::Triangle
  • computeQErr() : vl::PolygonSimplifier::Triangle
  • computeRay() : vl::Camera
  • computeRayFrustum() : vl::Camera
  • computeStartingSector() : vl::SceneManagerPortals
  • computeVector() : vl::TrackballManipulator
  • computeWorldMatrix()
: vl::Transform
, vl::Billboard
  • computeWorldMatrixRecursive() : vl::Transform
  • confirmZCameraDistanceNeed()
: vl::RenderQueueSorterByShader
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorter
, vl::RenderQueueSorterAggressive
, vl::RenderQueueSorterBasic
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
  • conjugate() : vl::quat
  • constantAttenuation() : vl::Light
  • contains() : vl::String
  • continueCRC32() : vl::CRC32CheckSum
  • continueDrawing() : vlVG::VectorGraphics
  • continuousUpdate() : vl::OpenGLContext
  • contours() : vl::Tessellator
  • contourVerts() : vl::Tessellator
  • contrast() : vl::Image
  • contrastHounsfield() : vl::Image
  • contrastHounsfieldAuto() : vl::Image
  • convertFormat() : vl::Image
  • convertPrimitivesToDrawArrays() : vl::Geometry
  • convertToDrawArrays() : vl::GeometryLoadCallback
  • convertType() : vl::Image
  • coordinate() : vlVolume::Volume
  • coordinates() : vlMolecule::Atom
  • copy() : vl::MemoryFile
  • copyPixels()
: vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage
, vl::CopyTexSubImage2D
, vl::BlitFramebuffer
  • copySubImage() : vl::Image
  • CopyTexSubImage() : vl::CopyTexSubImage
  • CopyTexSubImage1D() : vl::CopyTexSubImage1D
  • CopyTexSubImage2D() : vl::CopyTexSubImage2D
  • CopyTexSubImage3D() : vl::CopyTexSubImage3D
  • count()
: vl::Uniform
, vl::String
, vl::DrawArrays
, vl::ResourceDatabase
  • CountAndCapture() : vlMFC::MFCWindow
  • CountAndRelease() : vlMFC::MFCWindow
  • countType() : vl::PlyLoader::PlyScalarList
  • covalentRadius() : vlMolecule::AtomInfo
  • cpkColor() : vlMolecule::AtomInfo
  • crc32()
: vl::VirtualFile
, vl::ZippedFileInfo
  • crc32_init() : vl::CRC32CheckSum
  • crc32_table : vl::CRC32CheckSum
  • CRC32CheckSum() : vl::CRC32CheckSum
  • creaseAngle()
: vl::EdgeRenderer
, vl::EdgeExtractor
  • create()
: vl::FBORenderbufferAttachment
, vl::FBORenderTarget
  • createCubemap() : vl::Image
  • createData() : vl::String
  • createFBORenderTarget() : vl::OpenGLContext
  • createGLBufferObject() : vl::GLBufferObject
  • createOcclusionQuery() : vl::Actor
  • createProgram() : vl::GLSLProgram
  • createShader() : vl::GLSLShader
  • createTexture() : vl::Texture
  • cube() : vlVolume::Volume
  • cull() : vl::Frustum
  • CullFace() : vl::CullFace
  • cullingEnabled()
: vl::Rendering
, vl::SceneManager
  • currentEffect() : vlVG::VectorGraphics
  • currentTime() : vl::Time
  • cycle() : vlMolecule::Molecule
  • cycles() : vlMolecule::Molecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- d -

  • d2 : vl::PolygonSimplifier::QErr
  • data() : vl::VertexAttributeArray
  • dataIsDirty() : vlVolume::Volume
  • day() : vl::ZippedFileInfo
  • dayOfMonth() : vl::Time
  • dayOfWeek() : vl::Time
  • debug() : vl::Log
  • declareActor() : vl::EdgeRenderer
  • decReference() : vl::Object
  • deepCopy() : vl::Geometry
  • defaultLineColor() : vl::EdgeRenderer
  • deleteDisplayList() : vl::Renderable
  • deleteGLBufferObject() : vl::GLBufferObject
  • deleteOcclusionQuery() : vl::Actor
  • deletePixelBufferObject() : vl::DrawPixels::Pixels
  • deletePixelBufferObjects() : vl::DrawPixels
  • deleteProgram() : vl::GLSLProgram
  • deleteShader() : vl::GLSLShader
  • deleteVBOs()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • density() : vl::Fog
  • depth()
: vl::AABB
, vl::Image
, vl::Terrain
, vl::Texture
  • depthBias() : vl::PixelTransfer
  • depthBufferBits() : vl::OpenGLContextFormat
  • depthFirstVisit() : vlMolecule::RingExtractor
  • DepthFunc() : vl::DepthFunc
  • depthFunc() : vl::DepthFunc
  • DepthMask() : vl::DepthMask
  • depthMask() : vl::DepthMask
  • DepthRange() : vl::DepthRange
  • depthScale() : vl::PixelTransfer
  • DepthSortCallback() : vl::DepthSortCallback
  • depthSortMode()
: vl::RenderQueueSorterStandard
, vl::RenderQueueSorterAggressive
  • depthTextureMode() : vl::TexParameter
  • destroy()
: vl::FBOAttachmentAbstract
, vl::FBORenderbufferAttachment
, vl::FBORenderTarget
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWin32::Win32Window
, vlMFC::MFCWindow
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • destroyAllFBORenderTargets() : vl::OpenGLContext
  • destroyEvent()
: vl::UIEventListener
, vlut::Applet
  • destroyFBORenderTarget() : vl::OpenGLContext
  • destroyWindow()
: vlWin32::Win32Window
, vlMFC::MFCWindow
  • detachAllShaders() : vl::GLSLProgram
  • detachShader() : vl::GLSLProgram
  • detail() : vl::BezierSurface
  • detailRepetitionMode() : vl::Terrain
  • detailTexture() : vl::Terrain
  • detailTextureFormat() : vl::Terrain
  • detectEncoding() : vl::String
  • diffuse() : vl::Light
  • dimension()
: vl::Image
, vl::Texture::SetupParams
, vl::Texture
  • direction() : vl::Ray
  • directories() : vl::FileSystem
  • dirty() : vl::TexParameter
  • disable()
: vl::ClipPlane
, vl::Light
, vl::RenderState
, vl::Scissor
, vl::TextureUnit
, vl::EnableSet
, vl::Shader
  • disableAll()
: vl::EnableSet
, vl::Shader
  • discardOriginalNormals() : vl::GeometryLoadCallback
  • discardRemovedTriangles() : vl::PolygonSimplifier::Vertex
  • DiskDirectory()
: vl::DiskDirectory
, vl::DiskFile
, vl::DiskDirectory
  • diskFile() : vl::DiskDirectory
  • DiskFile() : vl::DiskFile
  • diskSubDir() : vl::DiskDirectory
  • dispatchDestroyEvent() : vl::OpenGLContext
  • dispatchFileDroppedEvent() : vl::OpenGLContext
  • dispatchInitEvent() : vl::OpenGLContext
  • dispatchKeyPressEvent() : vl::OpenGLContext
  • dispatchKeyReleaseEvent() : vl::OpenGLContext
  • dispatchMouseDownEvent() : vl::OpenGLContext
  • dispatchMouseMoveEvent() : vl::OpenGLContext
  • dispatchMouseUpEvent() : vl::OpenGLContext
  • dispatchMouseWheelEvent() : vl::OpenGLContext
  • dispatchRenderingCallbacks() : vl::RenderingAbstract
  • dispatchResizeEvent() : vl::OpenGLContext
  • dispatchRunEvent() : vl::OpenGLContext
  • dispatchVisibilityEvent() : vl::OpenGLContext
  • displayList() : vl::Renderable
  • displayListDirty() : vl::Renderable
  • displayListEnabled() : vl::Renderable
  • distance()
: vl::RayIntersection
, vl::Plane
  • distanceAttenuation() : vl::PointParameter
  • DistanceLODEvaluator() : vl::DistanceLODEvaluator
  • distanceRange()
: vl::DistanceLODEvaluator
, vl::PixelLODEvaluator
  • distanceRangeCount()
: vl::PixelLODEvaluator
, vl::DistanceLODEvaluator
  • distanceRangeSet()
: vl::PixelLODEvaluator
, vl::DistanceLODEvaluator
  • dot() : vl::quat
  • doubleBuffer() : vl::OpenGLContextFormat
  • DoubleVertexRemover() : vl::DoubleVertexRemover
  • downloadGLBufferObject() : vl::GLBufferObject
  • downsample() : vlVolume::Volume
  • dpFail_Back() : vl::StencilOp
  • dpFail_Front() : vl::StencilOp
  • dpPass_Back() : vl::StencilOp
  • dpPass_Front() : vl::StencilOp
  • dragEnterEvent() : vlQt4::Qt4Widget
  • drawActor() : vlVG::VectorGraphics
  • drawActorCopy() : vlVG::VectorGraphics
  • DrawArrays() : vl::DrawArrays
  • DrawElements() : vl::DrawElements< index_type, Tgltype, arr_type >
  • drawEllipse() : vlVG::VectorGraphics
  • drawFramebuffer() : vl::BlitFramebuffer
  • drawLine() : vlVG::VectorGraphics
  • drawLineLoop() : vlVG::VectorGraphics
  • drawLines() : vlVG::VectorGraphics
  • drawLineStrip() : vlVG::VectorGraphics
  • DrawPixels : vl::DrawPixels::Pixels , vl::DrawPixels
  • drawPoint() : vlVG::VectorGraphics
  • drawPoints() : vlVG::VectorGraphics
  • drawQuad() : vlVG::VectorGraphics
  • draws() : vl::DrawPixels
  • drawText() : vlVG::VectorGraphics
  • dropEvent() : vlQt4::Qt4Widget
  • dstAlpha() : vl::BlendFunc
  • dstRect() : vl::BlitFramebuffer
  • dstRGB() : vl::BlendFunc
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- e -

  • e()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • Edge() : vl::EdgeExtractor::Edge
  • EdgeExtractor() : vl::EdgeExtractor
  • EdgeRenderer() : vl::EdgeRenderer
  • edges()
: vl::EdgeUpdateCallback
, vl::EdgeExtractor
, vl::EdgeUpdateCallback
  • EdgeUpdateCallback() : vl::EdgeUpdateCallback
  • effect()
: vl::Actor
, vlVolume::SlicedVolume
  • Effect() : vl::Effect
  • elapsed() : vl::Time
  • electronAffinity() : vlMolecule::AtomInfo
  • electronegativity() : vlMolecule::AtomInfo
  • elemCount() : vl::PlyLoader::PlyElement
  • elements() : vl::PlyLoader
  • empiricalRadius() : vlMolecule::AtomInfo
  • empty()
: vl::Collection< T >
, vl::Image
, vl::RenderQueue
, vl::String
, vl::Buffer
  • enable()
: vl::ClipPlane
, vl::Light
, vl::RenderState
, vl::Scissor
, vl::TextureUnit
, vl::EnableSet
, vl::Shader
  • enableMask()
: vl::Actor
, vl::Effect
, vl::RenderingAbstract
, vl::SceneManager
  • enables()
: vl::EnableSet
, vl::Shader
  • EnableSet() : vl::EnableSet
  • end() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::Fog
  • endDrawing() : vlVG::VectorGraphics
  • endOfFile() : vl::VirtualFile
  • endsWith() : vl::String
  • enlarge() : vl::AABB
  • envVars() : vl::VisualizationLibrary
  • equalize() : vl::Image
  • erase()
: vl::Collection< T >
, vl::KeyValues
  • eraseActor() : vl::ActorTreeAbstract
  • eraseAllAtoms() : vlMolecule::Molecule
  • eraseAllBonds() : vlMolecule::Molecule
  • eraseAllChildren()
: vl::ActorTree
, vl::Transform
  • eraseAllChildrenRecursive() : vl::Transform
  • eraseAllEventListeners() : vl::OpenGLContext
  • eraseAllFiles() : vl::MemoryDirectory
  • eraseAllRenderStates()
: vl::RenderStateSet
, vl::Shader
  • eraseAllUniforms()
: vl::Actor
, vl::Shader
, vl::UniformSet
  • eraseAt() : vl::Collection< T >
  • eraseAtom() : vlMolecule::Molecule
  • eraseBond() : vlMolecule::Molecule
  • eraseChild()
: vl::ActorTree
, vl::ShaderNode
, vl::Transform
  • eraseChildren()
: vl::Transform
, vl::ShaderNode
  • eraseEnable() : vl::ShaderNode
  • eraseRenderState()
: vl::RenderStateSet
, vl::Shader
, vl::ShaderNode
, vl::Shader
  • eraseUniform()
: vl::Actor
, vl::Shader
, vl::ShaderNode
, vl::UniformSet
, vl::Actor
  • eraseVertexAttributeByName() : vl::Geometry
  • error() : vl::Log
  • ETrackballMode : vl::TrackballManipulator
  • EType : vl::PlyLoader
  • EUniformType : vl::Uniform
  • euronotation() : vl::Say
  • evaluate()
: vl::PixelLODEvaluator
, vl::PolygonSimplifier::QErr
, vl::LODEvaluator
, vl::DistanceLODEvaluator
  • evaluateFunction() : vlVolume::VolumePlot
  • evaluateLOD()
: vl::Rendering
, vl::Actor
, vl::Effect
  • eventListener() : vl::OpenGLContext
  • eventListenerCount() : vl::OpenGLContext
  • eventListeners() : vl::OpenGLContext
  • executeCallbacks() : vl::Sector
  • executeRenderingCallbacks() : vl::Actor
  • exists()
: vl::VirtualFile
, vl::ZippedFile
, vl::GZipCodec
, vl::MemoryFile
, vl::DiskDirectory
, vl::DiskFile
  • exStyle() : vlWin32::Win32Window
  • externalSector() : vl::SceneManagerPortals
  • extract()
: vl::ZippedFile
, vl::ResourceDatabase
  • extractEdges() : vl::EdgeExtractor
  • extractFileExtension() : vl::String
  • extractFileName() : vl::String
  • extractPath() : vl::String
  • extraFieldLength() : vl::ZippedFileInfo
  • extrude() : vl::Extrusion
  • Extrusion() : vl::Extrusion
  • eyePlaneQ() : vl::TexGen
  • eyePlaneR() : vl::TexGen
  • eyePlaneS() : vl::TexGen
  • eyePlaneT() : vl::TexGen
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- f -

  • face_type() : vl::ObjMesh
  • faceMode() : vl::CullFace
  • faceNormalIndex() : vl::ObjMesh
  • facePositionIndex() : vl::ObjMesh
  • faceTexCoordIndex() : vl::ObjMesh
  • factor()
: vl::PolygonOffset
, vl::LineStipple
  • fadeThresholdSize() : vl::PointParameter
  • farPlane() : vl::Camera
  • FBOAttachmentAbstract() : vl::FBOAttachmentAbstract
  • fboAttachments() : vl::FBORenderTarget
  • FBOColorBufferAttachment() : vl::FBOColorBufferAttachment
  • FBODepthBufferAttachment() : vl::FBODepthBufferAttachment
  • FBODepthStencilBufferAttachment() : vl::FBODepthStencilBufferAttachment
  • FBORenderbufferAttachment() : vl::FBORenderbufferAttachment
  • FBORenderTarget : vl::FBOAttachmentAbstract , vl::FBORenderbufferAttachment
  • fboRenderTargets() : vl::FBOAttachmentAbstract
  • FBOStencilBufferAttachment() : vl::FBOStencilBufferAttachment
  • FBOTexture1DAttachment() : vl::FBOTexture1DAttachment
  • FBOTexture2DAttachment() : vl::FBOTexture2DAttachment
  • FBOTexture3DAttachment() : vl::FBOTexture3DAttachment
  • FBOTextureAttachment() : vl::FBOTextureAttachment
  • FBOTextureLayerAttachment() : vl::FBOTextureLayerAttachment
  • field() : vl::String
  • file()
: vl::VirtualDirectory
, vl::ZippedDirectory
, vl::DiskDirectory
, vl::MemoryDirectory
  • fileDroppedEvent() : vl::UIEventListener
  • fileExists() : vl::VirtualDirectory
  • fileNameLength() : vl::ZippedFileInfo
  • filePath() : vl::Font
  • fileSystem() : vl::VisualizationLibrary
  • FileSystem() : vl::FileSystem
  • fill() : vl::String
  • fillBottom() : vl::Extrusion
  • fillBuffer() : vl::BufferedStream< Element_Type, Chunk_Size >
  • fillEllipse() : vlVG::VectorGraphics
  • fillPolygon() : vlVG::VectorGraphics
  • fillQuad() : vlVG::VectorGraphics
  • fillQuads() : vlVG::VectorGraphics
  • fillQuadStrip() : vlVG::VectorGraphics
  • fillRenderQueue() : vl::Rendering
  • fillTop() : vl::Extrusion
  • fillTriangleFan() : vlVG::VectorGraphics
  • fillTriangles() : vlVG::VectorGraphics
  • fillTriangleStrip() : vlVG::VectorGraphics
  • fillUncompressedBuffer()
: vl::GZipCodec
, vl::ZippedFile
  • filterStrings() : vl::String
  • finalizeCRC32() : vl::CRC32CheckSum
  • find()
: vl::Collection< T >
, vl::String
  • findBackwards() : vl::String
  • findChild() : vl::ShaderNode
  • findLoader() : vl::LoadWriterManager
  • findVertexAttribute() : vl::Geometry
  • findWriter() : vl::LoadWriterManager
  • flipVertically() : vl::Image
  • float64 : vl::SayArg
  • FLOAT64 : vl::SayArg
  • Fog() : vl::Fog
  • fogCoordArray() : vl::Geometry
  • fogHint() : vl::Hint
  • followedTransform()
: vl::Camera
, vl::ClipPlane
, vl::Light
, vl::ClipPlane
  • followTransform()
: vl::Camera
, vl::ClipPlane
, vl::Light
  • font()
: vl::Glyph
, vl::Text
, vlVG::VectorGraphics
  • FontManager : vl::Font
  • fontManager() : vl::VisualizationLibrary
  • fonts() : vl::FontManager
  • format()
: vl::Texture::SetupParams
, vl::Say
, vl::Image
, vl::Say
  • format_string : vl::Say
  • fov() : vl::Camera
  • fps() : vlut::Applet
  • fragDataLocationBinding() : vl::GLSLProgram
  • fragmentShader() : vl::Terrain
  • freeCombinedVertices() : vl::Tessellator
  • freeTypeLibrary() : vl::VisualizationLibrary
  • fromAscii() : vl::String
  • fromAxisAngle() : vl::quat
  • fromDouble() : vl::String
  • fromEulerXYZ() : vl::quat
  • fromEulerZYX() : vl::quat
  • fromInt() : vl::String
  • fromLatin1() : vl::String
  • fromLongLong() : vl::String
  • fromMatrix() : vl::quat
  • fromStdString() : vl::String
  • fromStdWString() : vl::String
  • fromUInt() : vl::String
  • fromULongLong() : vl::String
  • fromUTF16() : vl::String
  • fromUTF16BE() : vl::String
  • fromUTF16LE() : vl::String
  • fromUTF8() : vl::String
  • fromVectors() : vl::quat
  • frontAmbient() : vl::Material
  • frontDiffuse() : vl::Material
  • frontEmission() : vl::Material
  • frontFace()
: vl::FrontFace
, vl::PolygonMode
  • FrontFace() : vl::FrontFace
  • frontShininess() : vl::Material
  • frontSpecular() : vl::Material
  • frustum()
: vl::RayIntersector
, vl::Matrix4< scalar_type >
, vl::Camera
  • frustumStack() : vl::SceneManagerPortals
  • fullscreen()
: vl::OpenGLContext
, vl::OpenGLContextFormat
  • function_Back() : vl::StencilFunc
  • function_Front() : vl::StencilFunc
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- g -

  • g()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • generalPurposeFlag() : vl::ZippedFileInfo
  • generateAtomLabel() : vlMolecule::Molecule
  • generateAtomLabels() : vlMolecule::Molecule
  • generateEdgeGeometry() : vl::EdgeExtractor
  • generateMipmap() : vl::TexParameter
  • generateMipmapHint() : vl::Hint
  • generatePixelBufferObject() : vl::DrawPixels::Pixels
  • generatePixelBufferObjects() : vl::DrawPixels
  • generateRings() : vlMolecule::Molecule
  • generateTextureCoordinates() : vlVolume::SlicedVolume
  • genModeQ() : vl::TexGen
  • genModeR() : vl::TexGen
  • genModeS() : vl::TexGen
  • genModeT() : vl::TexGen
  • genRGBAVolume() : vlVolume::SlicedVolume
  • geometry() : vlVolume::SlicedVolume
  • Geometry() : vl::Geometry
  • geometry()
: vl::MorphingActor
, vl::RayIntersectionGeometry
, vl::Portal
, vlVolume::SlicedVolume
  • geometryInputType() : vl::GLSLProgram
  • GeometryLoadCallback() : vl::GeometryLoadCallback
  • geometryOutputType() : vl::GLSLProgram
  • geometryVerticesOut() : vl::GLSLProgram
  • get()
: vl::ref< T >
, vl::ResourceDatabase
  • get2x2() : vl::Matrix3< scalar_type >
  • get3x3() : vl::Matrix4< scalar_type >
  • getAlphaFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getAsFloat() : vl::PlyLoader::PlyScalar
  • getAsInt() : vl::PlyLoader::PlyScalar
  • getAsLookAt() : vl::Matrix4< scalar_type >
  • getAttribLocation() : vl::GLSLProgram
  • getBlendColor() : vl::Shader
  • getBlendEquation()
: vl::Shader
, vlVG::VectorGraphics
  • getBlendFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getClipPlane() : vl::Shader
  • getColor() : vl::PlyLoader::PlyElement
  • getColorMask() : vl::Shader
  • getComputedWorldMatrix() : vl::Transform
  • getCullFace() : vl::Shader
  • getDepthFunc() : vl::Shader
  • getDepthMask() : vl::Shader
  • getDepthRange() : vl::Shader
  • getEnableSet() : vl::Shader
  • getFocus()
: vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • getFog() : vl::Shader
  • getFrontFace() : vl::Shader
  • getGLSLProgram() : vl::Shader
  • getHint() : vl::Shader
  • getKeys() : vl::KeyValues
  • getLight() : vl::Shader
  • getLightModel() : vl::Shader
  • getLineStipple() : vl::Shader
  • getLineWidth() : vl::Shader
  • getLogicOp() : vl::Shader
  • getLowerCase() : vl::String
  • getMaterial() : vl::Shader
  • getNormal() : vl::PlyLoader::PlyElement
  • getNormalized() : vl::quat
  • getPixelTransfer() : vl::Shader
  • getPointParameter() : vl::Shader
  • getPointSize() : vl::Shader
  • getPolygonMode() : vl::Shader
  • getPolygonOffset() : vl::Shader
  • getPolygonStipple() : vl::Shader
  • getProcAddress() : vl::OpenGLContext
  • getRenderStateSet() : vl::Shader
  • getSampleCoverage() : vl::Shader
  • getScissorBox() : vl::Clear
  • getShadeModel() : vl::Shader
  • getStencilFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getStencilMask() : vl::Shader
  • getStencilOp()
: vl::Shader
, vlVG::VectorGraphics
, vl::Shader
  • getT()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • getTexEnv() : vl::Shader
  • getTexGen() : vl::Shader
  • getTexParameter() : vl::Texture
  • getTextureMatrix() : vl::Shader
  • getTextureUnit() : vl::Shader
  • getTitleCase() : vl::String
  • getUniform()
: vl::GLSLProgram
, vl::Actor
, vl::GLSLProgram
, vl::Shader
, vl::Uniform
, vl::UniformSet
, vl::Uniform
  • getUniformfv() : vl::GLSLProgram
  • getUniformiv() : vl::GLSLProgram
  • getUniformLocation() : vl::GLSLProgram
  • getUniformSet() : vl::Shader
  • getUpperCase() : vl::String
  • getVertex() : vl::PlyLoader::PlyElement
  • getViewMatrixAsLookAt() : vl::Camera
  • getWindow() : vlWin32::Win32Window
  • getX()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • getY()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • getYXRotationAngles() : vl::Matrix4< scalar_type >
  • getZ() : vl::Matrix4< scalar_type >
  • ghostCamera() : vlut::Applet
  • GhostCameraManipulator() : vl::GhostCameraManipulator
  • GLBufferObject() : vl::GLBufferObject
  • glSize() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::ArrayAbstract
  • GLSLFragmentShader() : vl::GLSLFragmentShader
  • GLSLGeometryShader() : vl::GLSLGeometryShader
  • glslProgram() : vlVolume::SlicedVolume
  • GLSLProgram()
: vl::GLSLProgram
, vl::Uniform
  • glslProgram()
: vl::Shader
, vl::RenderStateSet
, vl::Shader
, vlVolume::SlicedVolume
, vl::RenderStateSet
  • GLSLShader() : vl::GLSLShader
  • glslVertexBlendEnabled() : vl::MorphingActor
  • GLSLVertexShader() : vl::GLSLVertexShader
  • glType() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::ArrayAbstract
  • glut_close_func() : vlGLUT::GLUTWindow
  • glut_display_func() : vlGLUT::GLUTWindow
  • glut_idle_func() : vlGLUT::GLUTWindow
  • glut_keyboard_func() : vlGLUT::GLUTWindow
  • glut_keyboard_up_func() : vlGLUT::GLUTWindow
  • glut_motion_func() : vlGLUT::GLUTWindow
  • glut_mouse_func() : vlGLUT::GLUTWindow
  • glut_mouse_wheel_func() : vlGLUT::GLUTWindow
  • glut_passive_motion_func() : vlGLUT::GLUTWindow
  • glut_reshape_func() : vlGLUT::GLUTWindow
  • glut_special_func() : vlGLUT::GLUTWindow
  • glut_special_up_func() : vlGLUT::GLUTWindow
  • glut_visibility_func() : vlGLUT::GLUTWindow
  • glut_wmclose_func() : vlGLUT::GLUTWindow
  • GLUTWindow() : vlGLUT::GLUTWindow
  • glyph() : vl::Font
  • Glyph() : vl::Glyph
  • glyphIndex() : vl::Glyph
  • gocAlphaFunc() : vl::Shader
  • gocBlendColor() : vl::Shader
  • gocBlendEquation() : vl::Shader
  • gocBlendFunc() : vl::Shader
  • gocClipPlane() : vl::Shader
  • gocColorMask() : vl::Shader
  • gocCullFace() : vl::Shader
  • gocDepthFunc() : vl::Shader
  • gocDepthMask() : vl::Shader
  • gocDepthRange() : vl::Shader
  • gocEnableSet() : vl::Shader
  • gocFog() : vl::Shader
  • gocFrontFace() : vl::Shader
  • gocGLSLProgram() : vl::Shader
  • gocHint() : vl::Shader
  • gocLight() : vl::Shader
  • gocLightModel() : vl::Shader
  • gocLineStipple() : vl::Shader
  • gocLineWidth() : vl::Shader
  • gocLogicOp() : vl::Shader
  • gocMaterial() : vl::Shader
  • gocPixelTransfer() : vl::Shader
  • gocPointParameter() : vl::Shader
  • gocPointSize() : vl::Shader
  • gocPolygonMode() : vl::Shader
  • gocPolygonOffset() : vl::Shader
  • gocPolygonStipple() : vl::Shader
  • gocRenderStateSet() : vl::Shader
  • gocSampleCoverage() : vl::Shader
  • gocShadeModel() : vl::Shader
  • gocStencilFunc() : vl::Shader
  • gocStencilMask() : vl::Shader
  • gocStencilOp() : vl::Shader
  • gocTexEnv() : vl::Shader
  • gocTexGen() : vl::Shader
  • gocTextureMatrix() : vl::Shader
  • gocTextureUnit() : vl::Shader
  • gocUniform()
: vl::Actor
, vl::UniformSet
, vl::Shader
, vl::GLSLProgram
  • gocUniformSet() : vl::Shader
  • gpuBuffer() : vl::ArrayAbstract
  • green() : vl::ColorMask
  • greenBias() : vl::PixelTransfer
  • greenScale() : vl::PixelTransfer
  • GZipCodec() : vl::GZipCodec
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- h -

  • handle()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::FBORenderTarget
, vl::Primitives
, vl::Texture
, vl::GLBufferObject
, vlGLUT::GLUTWindow
, vl::FBORenderbufferAttachment
, vl::GLSLShader
, vl::GLSLProgram
  • harvestNonLeafActors() : vl::ActorKdTree
  • has() : vl::KeyValues
  • hasMipmaps() : vl::Texture::SetupParams
  • hasMipMaps() : vl::Texture
  • hasPixelBufferObject() : vl::DrawPixels::Pixels
  • hasTexture() : vl::TextureUnit
  • hasVertex() : vl::PolygonSimplifier::Triangle
  • hdc() : vlWin32::Win32Context
  • height()
: vl::Viewport
, vl::AABB
, vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
, vl::OpenGLContext
, vl::ReadPixels
, vl::RenderTarget
, vl::Terrain
, vl::Texture
  • heightmapTexture() : vl::Terrain
  • heightmapTextureFormat() : vl::Terrain
  • hglrc() : vlWin32::Win32Context
  • hide()
: vl::OpenGLContext
, vlGLUT::GLUTWindow
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vlQt4::Qt4Widget
  • highQualityNormals() : vlVolume::MarchingCubes
  • Hint() : vl::Hint
  • hour()
: vl::ZippedFileInfo
, vl::Time
  • hwnd()
: vlWin32::Win32Context
, vlWin32::Win32Window
, vlMFC::MFCWindow
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- i -

  • id()
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • ignoreNextMouseMoveEvent() : vl::OpenGLContext
  • illum() : vl::ObjMaterial
  • image()
: vl::ReadPixels
, vl::Texture::SetupParams
, vlVG::VectorGraphics
, vl::DrawPixels::Pixels
, vlVG::VectorGraphics
  • Image() : vl::Image
  • image() : vl::DrawPixels::Pixels
  • Image() : vl::Image
  • imageBuffer() : vl::Image
  • imagePath() : vl::Texture::SetupParams
  • imfchan() : vl::ObjTexture
  • incidentBonds() : vlMolecule::Molecule
  • incidentTriangle() : vl::PolygonSimplifier::Vertex
  • incidentTrianglesCount() : vl::PolygonSimplifier::Vertex
  • includes() : vl::Sphere
  • incReference() : vl::Object
  • index()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
  • indexCount()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
  • indexCountGPU() : vl::DrawElements< index_type, Tgltype, arr_type >
  • indexOffset() : vl::PixelTransfer
  • indexShift() : vl::PixelTransfer
  • indices() : vl::DrawElements< index_type, Tgltype, arr_type >
  • info() : vl::Log
  • infoLog()
: vl::GLSLShader
, vl::GLSLProgram
  • inherit() : vl::ShaderNode
  • init()
: vl::MorphingActor
, vl::SayArg
, vl::Terrain
, vl::VisualizationLibrary
, vl::ZippedDirectory
, vlWin32::Win32Context
  • initEnvVars() : vl::VisualizationLibrary
  • initEvent()
: vl::UIEventListener
, vlut::Applet
  • initExtensions() : vl::OpenGLContext
  • initFloat() : vl::Uniform
  • initFrom() : vl::MorphingActor
  • initGLUTWindow() : vlGLUT::GLUTWindow
  • initialize()
: vl::SceneManagerPortals
, vlut::Applet
  • initialized() : vl::VisualizationLibrary
  • initializeGL() : vlQt4::Qt4Widget
  • initInt() : vl::Uniform
  • initKeymap() : vlGLUT::GLUTWindow
  • initMFCWindow() : vlMFC::MFCWindow
  • initQt4Widget() : vlQt4::Qt4Widget
  • initResources()
: vl::Shader
, vl::GLSLProgram
, vl::RenderState
, vl::TextureUnit
  • initSDLWindow() : vlSDL::SDLWindow
  • initStorage() : vl::FBORenderbufferAttachment
  • initUInt() : vl::Uniform
  • initWin32Window() : vlWin32::Win32Window
  • inputFile() : vl::BufferedStream< Element_Type, Chunk_Size >
  • insert()
: vl::Collection< T >
, vl::String
  • insertActor() : vl::ActorKdTree
  • instances() : vl::Primitives
  • interlineSpacing() : vl::Text
  • internalBindAttachment() : vl::FBORenderbufferAttachment
  • internalFormat() : vl::Texture
  • internalType()
: vl::FBORenderbufferAttachment
, vl::FBOColorBufferAttachment
, vl::FBODepthBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::FBODepthStencilBufferAttachment
  • interpolator()
: vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec3
, vl::CatmullRomInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • Interpolator() : vl::Interpolator
  • intersect() : vl::RayIntersector
  • intersected() : vl::Rect< T >
  • intersectGeometry() : vl::RayIntersector
  • intersectionPoint() : vl::RayIntersection
  • intersections() : vl::RayIntersector
  • intersectPolygon() : vl::RayIntersector
  • intersectQuad() : vl::RayIntersector
  • intersects() : vl::AABB
  • intersectTriangle() : vl::RayIntersector
  • invalidateCache() : vl::DepthSortCallback
  • inverse()
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
  • inverseViewMatrix() : vl::Camera
  • invert()
: vl::Matrix3< scalar_type >
, vl::SampleCoverage
, vl::Matrix4< scalar_type >
, vl::Matrix2< scalar_type >
  • isAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • isAtomAdjacent() : vlMolecule::Atom
  • isCompressedFormat()
: vl::Texture
, vl::Image
  • isCorrupted() : vl::ZippedDirectory
  • isCrease() : vl::EdgeExtractor::Edge
  • isCubemap() : vl::Image
  • isEnabled()
: vl::SceneManager
, vl::UIEventListener
, vl::RenderingAbstract
, vl::Shader
, vl::EnableSet
, vl::Primitives
  • isExtensionSupported() : vl::OpenGLContext
  • isIdentity()
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
  • isIncidentTriangle() : vl::PolygonSimplifier::Vertex
  • isInside() : vl::AABB
  • isKeyPressed() : vl::OpenGLContext
  • isNull()
: vl::Matrix4< scalar_type >
, vl::Vector2< scalar_type >
, vl::AABB
, vl::Vector3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Rect< T >
, vl::Vector4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Sphere
  • isOccludee() : vl::Actor
  • isOpen()
: vl::VirtualFile
, vl::Portal
, vl::MemoryFile
, vl::ZippedFile
, vl::GZipCodec
, vl::DiskFile
  • isosurfaceActor() : vlVolume::VolumePlot
  • isosurfaceEffect() : vlVolume::VolumePlot
  • isosurfaceGeometry() : vlVolume::VolumePlot
  • isOutside() : vl::Plane
  • isPoint()
: vl::AABB
, vl::Sphere
, vl::Rect< T >
  • isPointInside() : vl::Viewport
  • isProtected() : vl::PolygonSimplifier::Vertex
  • isStarted() : vl::Time
  • isValid()
: vl::Image
, vl::Texture
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- p -

  • p()
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • paintGL() : vlQt4::Qt4Widget
  • parent()
: vl::ShaderNode
, vl::Transform
, vl::ActorTreeAbstract
  • parentDir() : vl::DiskFile
  • parse() : vl::Say
  • parse3DS() : vl::A3DSLoader
  • parseLine() : vl::ObjTexture
  • patches() : vl::BezierSurface
  • path()
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::VirtualDirectory
, vl::VirtualFile
, vl::ObjTexture
, vl::ZippedFileInfo
  • pattern() : vl::LineStipple
  • peek() : vl::VirtualFile
  • perspective() : vl::Matrix4< scalar_type >
  • perspectiveCorrectionHint() : vl::Hint
  • pipeline() : vl::Say
  • pitch() : vl::Image
  • pivot() : vl::TrackballManipulator
  • PixelLODEvaluator() : vl::PixelLODEvaluator
  • Pixels() : vl::DrawPixels::Pixels
  • pixels() : vl::Image
  • pixelsXN() : vl::Image
  • pixelsXP() : vl::Image
  • pixelsYN() : vl::Image
  • pixelsYP() : vl::Image
  • pixelsZN() : vl::Image
  • pixelsZP() : vl::Image
  • pixelsZSlice() : vl::Image
  • PixelTransfer() : vl::PixelTransfer
  • Plane() : vl::Plane
  • plane()
: vl::ActorKdTree
, vl::ClipPlane
, vl::Frustum
  • planeIndex() : vl::ClipPlane
  • planes() : vl::Frustum
  • platformSlash() : vl::String
  • plotTransform() : vlVolume::VolumePlot
  • PlyChar : vl::PlyLoader
  • PlyDouble : vl::PlyLoader
  • PlyElement() : vl::PlyLoader::PlyElement
  • PlyError : vl::PlyLoader
  • PlyFloat : vl::PlyLoader
  • PlyInt : vl::PlyLoader
  • PlyLoader() : vl::PlyLoader
  • PlyScalar() : vl::PlyLoader::PlyScalar
  • PlyScalarList() : vl::PlyLoader::PlyScalarList
  • PlyShort : vl::PlyLoader
  • PlyUChar : vl::PlyLoader
  • PlyUInt : vl::PlyLoader
  • PlyUShort : vl::PlyLoader
  • pointCount()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • PointParameter() : vl::PointParameter
  • points() : vl::BezierPatch
  • Points : vl::BezierPatch
  • PointSize() : vl::PointSize
  • pointSize()
: vl::PointSize
, vlVG::VectorGraphics
  • pointSmoothHint() : vl::Hint
  • pointSmoothing() : vlVG::VectorGraphics
  • pointSpriteCoordReplace() : vl::TexEnv
  • PolygonMode() : vl::PolygonMode
  • PolygonOffset() : vl::PolygonOffset
  • polygonOffsetFactor() : vl::EdgeRenderer
  • polygonOffsetUnits() : vl::EdgeRenderer
  • PolygonSimplifier
: vl::PolygonSimplifier::Triangle
, vl::PolygonSimplifier::Vertex
, vl::PolygonSimplifier
  • polygonSmoohtHint() : vl::Hint
  • polygonSmoothing() : vlVG::VectorGraphics
  • polygonStipple() : vlVG::VectorGraphics
  • PolygonStipple() : vl::PolygonStipple
  • pop_back() : vl::Collection< T >
  • popMatrix() : vlVG::VectorGraphics
  • popScissor() : vlVG::VectorGraphics
  • popState() : vlVG::VectorGraphics
  • Portal() : vl::Portal
  • portals() : vl::Sector
  • position()
: vl::PolygonSimplifier::Vertex
, vl::DrawPixels::Pixels
, vl::Billboard
, vl::GhostCameraManipulator
, vl::Light
, vl::OpenGLContext
, vl::VirtualFile
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • position_Implementation()
: vl::MemoryFile
, vl::DiskFile
, vl::GZipCodec
, vl::VirtualFile
, vl::ZippedFile
  • positionPath() : vl::Extrusion
  • postColorMatrixAlphaBias() : vl::PixelTransfer
  • postColorMatrixAlphaScale() : vl::PixelTransfer
  • postColorMatrixBlueBias() : vl::PixelTransfer
  • postColorMatrixBlueScale() : vl::PixelTransfer
  • postColorMatrixGreenBias() : vl::PixelTransfer
  • postColorMatrixGreenScale() : vl::PixelTransfer
  • postColorMatrixRedBias() : vl::PixelTransfer
  • postColorMatrixRedScale() : vl::PixelTransfer
  • postConvolutionAlphaBias() : vl::PixelTransfer
  • postConvolutionAlphaScale() : vl::PixelTransfer
  • postConvolutionBlueBias() : vl::PixelTransfer
  • postConvolutionBlueScale() : vl::PixelTransfer
  • postConvolutionGreenBias() : vl::PixelTransfer
  • postConvolutionGreenScale() : vl::PixelTransfer
  • postConvolutionRedBias() : vl::PixelTransfer
  • postConvolutionRedScale() : vl::PixelTransfer
  • prepareActors() : vl::ActorTreeAbstract
  • prepareAtomInsert() : vlMolecule::Molecule
  • prepareBondInsert() : vlMolecule::Molecule
  • prepareForRendering() : vlMolecule::Molecule
  • prepareToReconnect()
: vl::GhostCameraManipulator
, vl::TrackballManipulator
, vl::UIEventListener
  • prepend() : vl::String
  • primitiveIndex() : vl::RayIntersectionGeometry
  • primitives()
: vl::Geometry
, vl::RayIntersectionGeometry
  • Primitives() : vl::Primitives
  • primitiveType()
: vl::Primitives
, vl::DrawElements< index_type, Tgltype, arr_type >
  • print()
: vl::Log
, vl::Image
, vl::Log
, vl::KeyValues
, vl::ObjTexture
  • printFormat() : vl::Image
  • printFramebufferError() : vl::FBORenderTarget
  • printImplementation()
: vl::StandardLog
, vl::Log
  • printType() : vl::Image
  • processCube() : vlVolume::MarchingCubes
  • project() : vl::Camera
  • projectionMatrix() : vl::Camera
  • properties() : vl::PlyLoader::PlyElement
  • ptr()
: vl::Buffer
, vl::String
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::ArrayAbstract
, vl::Vector2< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Matrix3< scalar_type >
, vl::String
, vl::MemoryFile
, vl::Buffer
, vl::Vector3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::ArrayAbstract
, vl::Matrix4< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Vector2< scalar_type >
, vl::Vector4< scalar_type >
  • pureInteger() : vl::VertexAttributeArray
  • push_back() : vl::Collection< T >
  • pushMatrix() : vlVG::VectorGraphics
  • pushScissor() : vlVG::VectorGraphics
  • pushState() : vlVG::VectorGraphics
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- q -

  • q() : vl::Vector4< scalar_type >
  • QErr() : vl::PolygonSimplifier::QErr
  • qerr() : vl::PolygonSimplifier::Vertex
  • Qt4Widget() : vlQt4::Qt4Widget
  • quadraticAttenuation() : vl::Light
  • quality() : vl::LoadWriterJPG
  • quat() : vl::quat
  • quick() : vl::PolygonSimplifier
  • quitApplication()
: vlQt4::Qt4Widget
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vl::OpenGLContext
, vlSDL::SDLWindow
, vlGLUT::GLUTWindow
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- r -

  • r()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • radius()
: vlMolecule::Atom
, vlMolecule::Bond
, vl::Sphere
  • rank() : vl::UIEventListener
  • rasmolColor() : vlMolecule::AtomInfo
  • rawboundingRect() : vl::Text
  • ray() : vl::RayIntersector
  • RayIntersection() : vl::RayIntersection
  • RayIntersectionGeometry() : vl::RayIntersectionGeometry
  • RayIntersector() : vl::RayIntersector
  • read()
: vl::VirtualFile
, vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
, vl::PlyLoader::PlyElement
  • read0x3D3D() : vl::A3DSLoader
  • read0x4000() : vl::A3DSLoader
  • read0x4100() : vl::A3DSLoader
  • read0xAFFF() : vl::A3DSLoader
  • read_Implementation()
: vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
, vl::DiskFile
, vl::GZipCodec
  • readBuffer()
: vl::CopyTexSubImage
, vl::ReadPixels
  • readChunk() : vl::A3DSLoader
  • readColByte3() : vl::A3DSLoader
  • readColChunk() : vl::A3DSLoader
  • readColFloat3() : vl::A3DSLoader
  • readDouble()
: vl::TextStream
, vl::VirtualFile
  • readElements() : vl::PlyLoader
  • readFloat() : vl::VirtualFile
  • readFloatPercent() : vl::A3DSLoader
  • readFramebuffer() : vl::BlitFramebuffer
  • readHeader() : vl::PlyLoader
  • readInt() : vl::TextStream
  • readLine()
: vl::TextStream
, vl::A3DSLoader
  • readLineCR() : vl::TextStream
  • readLineLF() : vl::TextStream
  • readMapChunk() : vl::A3DSLoader
  • readPercentChunk() : vl::A3DSLoader
  • ReadPixels() : vl::ReadPixels
  • readPixels() : vl::Image
  • readQuotedString() : vl::TextStream
  • readSByte() : vl::VirtualFile
  • readSInt16() : vl::VirtualFile
  • readSInt32() : vl::VirtualFile
  • readSInt64() : vl::VirtualFile
  • readStdString() : vl::TextStream
  • readString() : vl::TextStream
  • readToken() : vl::BufferedStream< Element_Type, Chunk_Size >
  • readUByte() : vl::VirtualFile
  • readUInt16() : vl::VirtualFile
  • readUInt32() : vl::VirtualFile
  • readUInt64() : vl::VirtualFile
  • readVec3() : vl::A3DSLoader
  • readWordPercent() : vl::A3DSLoader
  • Rect() : vl::Rect< T >
  • rect() : vl::Viewport
  • RectF() : vl::RectF
  • RectI() : vl::RectI
  • red() : vl::ColorMask
  • redBias() : vl::PixelTransfer
  • redScale() : vl::PixelTransfer
  • ref() : vl::ref< T >
  • referenceCount() : vl::Object
  • reflect() : vl::CRC32CheckSum
  • refValue() : vl::AlphaFunc
  • refValue_Back() : vl::StencilFunc
  • refValue_Front() : vl::StencilFunc
  • regenerate() : vl::VertexMapper
  • regenerateVertices() : vl::Geometry
  • registerLoadWriter()
: vl::LoadWriterManager
, vl::LoadWriterOBJ
  • releaseAllFonts() : vl::FontManager
  • releaseFont() : vl::FontManager
  • releaseFreeTypeData() : vl::Font
  • releaseImages() : vl::DrawPixels
  • remove() : vl::String
  • removeAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • removeAfterCall() : vl::RenderingCallback
  • removeAllAttachments() : vl::FBORenderTarget
  • removeAttachment() : vl::FBORenderTarget
  • removed()
: vl::PolygonSimplifier::Triangle
, vl::PolygonSimplifier::Vertex
  • removeDoubles()
: vlMolecule::RingExtractor
, vl::DoubleVertexRemover
, vl::GeometryLoadCallback
, vl::PolygonSimplifier
  • removeEventListener() : vl::OpenGLContext
  • removeFile() : vl::MemoryDirectory
  • removeIncidentTriangle() : vl::PolygonSimplifier::Vertex
  • removeOrder() : vl::PolygonSimplifier::Vertex
  • removeScissor() : vlVG::VectorGraphics
  • render()
: vl::Clear
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::DrawPixels
, vl::EdgeRenderer
, vl::Geometry
, vl::Primitives
, vl::Renderable
, vl::Renderer
, vl::Rendering
, vl::RenderingAbstract
, vl::RenderingTree
, vl::Text
  • Renderable() : vl::Renderable
  • renderBackground() : vl::Text
  • renderBlock() : vl::Actor
  • renderBorder() : vl::Text
  • renderBuffers() : vl::RenderTarget
  • renderbufferStorageReady() : vl::FBORenderbufferAttachment
  • renderedLinesCount() : vl::Renderer
  • renderedPointsCount() : vl::Renderer
  • renderedRenderablesCount() : vl::Renderer
  • renderedTrianglesCount() : vl::Renderer
  • Renderer()
: vl::Renderer
, vl::GLSLProgram
  • renderer() : vl::Rendering
  • Rendering() : vl::Rendering
  • rendering() : vl::VisualizationLibrary
  • RenderingAbstract() : vl::RenderingAbstract
  • RenderingCallback() : vl::RenderingCallback
  • renderingCallback()
: vl::CopyTexSubImage
, vl::ReadPixels
, vl::RenderingCallback
, vl::BlitFramebuffer
  • renderingCallbacks()
: vl::Actor
, vl::RenderingAbstract
, vl::Actor
  • RenderingTree() : vl::RenderingTree
  • renderLines() : vl::EdgeRenderer
  • renderPortal() : vl::SceneManagerPortals
  • renderQueue() : vl::Rendering
  • RenderQueue() : vl::RenderQueue
  • renderQueueSorter() : vl::Rendering
  • RenderQueueSorter() : vl::RenderQueueSorter
  • RenderQueueSorterAggressive() : vl::RenderQueueSorterAggressive
  • RenderQueueSorterBasic() : vl::RenderQueueSorterBasic
  • RenderQueueSorterByRenderable() : vl::RenderQueueSorterByRenderable
  • RenderQueueSorterByShader() : vl::RenderQueueSorterByShader
  • RenderQueueSorterOcclusion() : vl::RenderQueueSorterOcclusion
  • RenderQueueSorterStandard() : vl::RenderQueueSorterStandard
  • renderRank()
: vl::Actor
, vl::Effect
  • renderSolids() : vl::EdgeRenderer
  • renderState()
: vl::Shader
, vl::RenderStateSet
, vl::Shader
  • RenderState() : vl::RenderState
  • renderStates()
: vl::RenderStateSet
, vl::Shader
  • RenderStateSet() : vl::RenderStateSet
  • renderTarget() : vl::OpenGLContext
  • RenderTarget() : vl::RenderTarget
  • renderTarget() : vl::Rendering
  • renderText() : vl::Text
  • RenderToken() : vl::RenderToken
  • replace() : vl::String
  • replaceVertex() : vl::PolygonSimplifier::Triangle
  • requiredMemory() : vl::Image
  • requiredMemory1D() : vl::Image
  • requiredMemory2D() : vl::Image
  • requiredMemory3D() : vl::Image
  • requiredMemoryCubemap() : vl::Image
  • reserve() : vl::Collection< T >
  • reset()
: vl::Shader
, vl::ZippedDirectory
, vl::EdgeExtractor
, vlVolume::MarchingCubes
, vl::Image
, vlMolecule::Molecule
  • resetEnables() : vl::Renderer
  • resetGLSLBindings() : vl::MorphingActor
  • resetMatrix()
: vl::Text
, vlVG::VectorGraphics
  • resetRenderStates() : vl::Renderer
  • resetStates() : vl::Rendering
  • resetStream()
: vl::ZippedFile
, vl::GZipCodec
  • resize()
: vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Collection< T >
, vl::BezierPatch
, vl::Buffer
, vl::String
  • resizeEvent()
: vlut::Applet
, vl::UIEventListener
  • resizeGL() : vlQt4::Qt4Widget
  • ResourceLoadWriter() : vl::ResourceLoadWriter
  • resources() : vl::ResourceDatabase
  • reverse() : vl::String
  • rg() : vl::Vector4< scalar_type >
  • rgb() : vl::Vector4< scalar_type >
  • rgbaBits() : vl::OpenGLContextFormat
  • rgbScale() : vl::TexEnv
  • right()
: vl::String
, vl::Rect< T >
, vl::RectI
, vl::RectF
  • RingExtractor() : vlMolecule::RingExtractor
  • ringOffset() : vlMolecule::Molecule
  • rotate()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vlVG::VectorGraphics
, vl::Matrix4< scalar_type >
, vl::Text
, vl::Transform
  • rotateXYZ() : vl::Matrix4< scalar_type >
  • rotateZYX() : vl::Matrix4< scalar_type >
  • rotation()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
  • rotationButton() : vl::TrackballManipulator
  • RotationMode : vl::TrackballManipulator
  • rotationPath() : vl::Extrusion
  • rotationSpeed()
: vl::TrackballManipulator
, vl::GhostCameraManipulator
  • rotationXYZ() : vl::Matrix4< scalar_type >
  • rotationZYX() : vl::Matrix4< scalar_type >
  • run()
: vlVolume::MarchingCubes
, vlMolecule::RingExtractor
, vlut::Applet
  • runEvent()
: vlut::Applet
, vl::GhostCameraManipulator
, vl::UIEventListener
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- s -

  • s()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • s0() : vl::Glyph
  • s1() : vl::Glyph
  • s_UVW() : vl::ObjTexture
  • sample() : vl::Image
  • SampleCoverage() : vl::SampleCoverage
  • sampleLinear() : vl::Image
  • sampleNearest() : vlVolume::Volume
  • samples() : vl::FBORenderbufferAttachment
  • sampleSmooth() : vlVolume::Volume
  • samplingResolution() : vlVolume::VolumePlot
  • savePath() : vl::ReadPixels
  • Say : vl::SayArg , vl::Say
  • SayArg() : vl::SayArg
  • scalar_count
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • scalarCount() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • scalarCountGPU() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • scalars() : vl::PlyLoader::PlyScalarList
  • scalarType()
: vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
  • scale()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Transform
, vlVG::VectorGraphics
  • scaling()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • scalingPath() : vl::Extrusion
  • sceneBoundingSphere() : vl::Camera
  • SceneManager() : vl::SceneManager
  • sceneManager() : vlut::Applet
  • SceneManagerActorKdTree() : vl::SceneManagerActorKdTree
  • SceneManagerActorTree() : vl::SceneManagerActorTree
  • SceneManagerPortals : vl::Portal , vl::SceneManagerPortals
  • sceneManagers() : vl::Rendering
  • SceneManagerVectorGraphics() : vlVG::SceneManagerVectorGraphics
  • scheduleRelinking() : vl::GLSLProgram
  • Scissor() : vl::Scissor
  • scissor()
: vl::Actor
, vl::Shader
, vlVG::VectorGraphics
  • scissorRect() : vl::Scissor
  • scissorStack() : vlVG::VectorGraphics
  • sdlSurface() : vlSDL::SDLWindow
  • SDLWindow() : vlSDL::SDLWindow
  • second()
: vl::Time
, vl::ZippedFileInfo
  • secondaryColorArray() : vl::Geometry
  • Sector() : vl::Sector
  • sectors() : vl::SceneManagerPortals
  • seek() : vl::BufferedStream< Element_Type, Chunk_Size >
  • seekCur() : vl::VirtualFile
  • seekEnd() : vl::VirtualFile
  • seekSet() : vl::VirtualFile
  • seekSet_Implementation()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • set()
: vl::Collection< T >
, vl::KeyValues
, vl::CullFace
, vl::FrontFace
, vl::DepthFunc
, vl::DepthMask
, vl::PolygonMode
, vl::ShadeModel
, vl::BlendFunc
, vl::BlendEquation
, vl::SampleCoverage
, vl::AlphaFunc
, vl::Fog
, vl::PolygonOffset
, vl::LogicOp
, vl::DepthRange
, vl::LineWidth
, vl::PointSize
, vl::PolygonStipple
, vl::LineStipple
, vl::PointParameter
, vl::StencilFunc
, vl::StencilOp
, vl::StencilMask
, vl::BlendColor
, vl::ColorMask
, vl::Viewport
  • set2x2() : vl::Matrix3< scalar_type >
  • set3x3() : vl::Matrix4< scalar_type >
  • setAccumRGBABits() : vl::OpenGLContextFormat
  • setActive() : vl::Camera
  • setActor() : vl::RayIntersection
  • setActorAnimationEnabled() : vl::Rendering
  • setActorDirty() : vl::EdgeRenderer
  • setActorRenderRankStart() : vlVG::SceneManagerVectorGraphics
  • setAdvance() : vl::Glyph
  • setAlign() : vl::DrawPixels::Pixels
  • setAlignment() : vl::Text
  • setAlpha() : vl::ColorMask
  • setAlphaBias() : vl::PixelTransfer
  • setAlphaFunc() : vlVG::VectorGraphics
  • setAlphaScale()
: vl::PixelTransfer
, vl::TexEnv
  • setAlwaysIdentityWorldMatrix() : vl::Transform
  • setAmbient()
: vl::Light
, vl::Material
  • setAmbientColor() : vl::LightModel
  • setAnimation() : vl::MorphingActor
  • setAnisotropy() : vl::TexParameter
  • setAromaticBondsColor() : vlMolecule::Molecule
  • setAromaticRingColor() : vlMolecule::Molecule
  • setAtom1() : vlMolecule::Bond
  • setAtom2() : vlMolecule::Bond
  • setAtomColors() : vlMolecule::Molecule
  • setAtomDetail() : vlMolecule::Molecule
  • setAtomName() : vlMolecule::Atom
  • setAtomRadii() : vlMolecule::Molecule
  • setAtomType() : vlMolecule::Atom
  • setAtomTypeVisible() : vlMolecule::Molecule
  • setAttribIndex() : vl::VertexAttributeArray
  • setAutomaticDelete() : vl::Object
  • setAutomaticResourceInit() : vl::Rendering
  • setAxis() : vl::Billboard
  • setBackAmbient() : vl::Material
  • setBackDiffuse() : vl::Material
  • setBackEmission() : vl::Material
  • setBackFace() : vl::PolygonMode
  • setBackFlatColor() : vl::Material
  • setBackgroundColor() : vl::Text
  • setBackgroundEnabled() : vl::Text
  • setBackShininess() : vl::Material
  • setBackSpecular() : vl::Material
  • setBackTransparency() : vl::Material
  • setBlendEquation() : vlVG::VectorGraphics
  • setBlendFunc() : vlVG::VectorGraphics
  • setBlendU() : vl::ObjTexture
  • setBlendV() : vl::ObjTexture
  • setBlue() : vl::ColorMask
  • setBlueBias() : vl::PixelTransfer
  • setBlueScale() : vl::PixelTransfer
  • setBM() : vl::ObjTexture
  • setBondDetail() : vlMolecule::Molecule
  • setBondRadii() : vlMolecule::Molecule
  • setBondType() : vlMolecule::Bond
  • setBorder()
: vl::Texture::SetupParams
, vl::Texture
  • setBorderColor()
: vl::Text
, vl::TexParameter
  • setBorderEnabled() : vl::Text
  • setBoundaryOnly() : vl::Tessellator
  • setBoundingBox()
: vl::Renderable
, vl::SceneManager
  • setBoundingSphere()
: vl::Renderable
, vl::SceneManager
  • setBoundsDirty()
: vl::Renderable
, vl::SceneManager
  • setBox() : vlVolume::SlicedVolume
  • setBuffer() : vl::MemoryFile
  • setBufferData() : vl::GLBufferObject
  • setBufferMask() : vl::BlitFramebuffer
  • setBufferSubData() : vl::GLBufferObject
  • setByteAlignment() : vl::Image
  • setCalculatedAtomRadii() : vlMolecule::Molecule
  • setCamera()
: vl::GhostCameraManipulator
, vl::Rendering
, vl::TrackballManipulator
  • setCC() : vl::ObjTexture
  • setCenter() : vl::Sphere
  • setChild()
: vl::ActorTree
, vl::Transform
  • setClamp() : vl::ObjTexture
  • setClearColor() : vl::Viewport
  • setClearColorBuffer() : vl::Clear
  • setClearColorInt() : vl::Viewport
  • setClearColorMode()
: vl::Clear
, vl::Viewport
  • setClearColorUInt() : vl::Viewport
  • setClearColorValue() : vl::Clear
  • setClearColorValueInt() : vl::Clear
  • setClearColorValueUInt() : vl::Clear
  • setClearDepth() : vl::Viewport
  • setClearDepthBuffer() : vl::Clear
  • setClearDepthValue() : vl::Clear
  • setClearFlags()
: vl::Rendering
, vl::Viewport
  • setClearStencil() : vl::Viewport
  • setClearStencilBuffer() : vl::Clear
  • setClearStencilValue() : vl::Clear
  • setCollapsePosition() : vl::PolygonSimplifier::Vertex
  • setCollectStatistics() : vl::Renderer
  • setColor()
: vl::Fog
, vl::TexEnv
, vl::Text
, vlVG::VectorGraphics
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
  • setColorArray() : vl::Geometry
  • setColorControl() : vl::LightModel
  • setColorMask() : vlVG::VectorGraphics
  • setColorMaterial() : vl::Material
  • setColorMaterialEnabled() : vl::Material
  • setCombineAlpha() : vl::TexEnv
  • setCombineRGB() : vl::TexEnv
  • setCompression() : vl::LoadWriterPNG
  • setCompressionLevel() : vl::GZipCodec
  • setComputeNormals() : vl::GeometryLoadCallback
  • setConstantAttenuation() : vl::Light
  • setContinuousUpdate()
: vl::OpenGLContext
, vlQt4::Qt4Widget
  • setConvertToDrawArrays() : vl::GeometryLoadCallback
  • setCoordinates() : vlMolecule::Atom
  • setCount() : vl::DrawArrays
  • setCountType() : vl::PlyLoader::PlyScalarList
  • setCovalentAtomRadii() : vlMolecule::Molecule
  • setCPKAtomColors() : vlMolecule::Molecule
  • setCreaseAngle()
: vl::EdgeExtractor
, vl::EdgeRenderer
  • setCullingEnabled()
: vl::Rendering
, vl::SceneManager
  • setData() : vl::VertexAttributeArray
  • setDataDirty() : vlVolume::Volume
  • setDefaultFont() : vlVG::VectorGraphics
  • setDefaultLineColor() : vl::EdgeRenderer
  • setDensity() : vl::Fog
  • setDepth()
: vl::Image
, vl::Terrain
, vl::Texture
  • setDepthBias() : vl::PixelTransfer
  • setDepthBufferBits() : vl::OpenGLContextFormat
  • setDepthScale() : vl::PixelTransfer
  • setDepthSortMode()
: vl::RenderQueueSorterStandard
, vl::RenderQueueSorterAggressive
  • setDepthTextureMode() : vl::TexParameter
  • setDetail() : vl::BezierSurface
  • setDetailRepetitionCount() : vl::Terrain
  • setDetailTexture() : vl::Terrain
  • setDetailTextureFormat() : vl::Terrain
  • setDiffuse()
: vl::Light
, vl::Material
  • setDimension()
: vl::Texture::SetupParams
, vl::Texture
  • setDirection() : vl::Ray
  • setDiscardOriginalNormals() : vl::GeometryLoadCallback
  • setDisplayList() : vl::Renderable
  • setDisplayListDirty() : vl::Renderable
  • setDisplayListEnabled() : vl::Renderable
  • setDistance() : vl::RayIntersection
  • setDistanceAttenuation() : vl::PointParameter
  • setDistanceRange() : vl::DistanceLODEvaluator
  • setDistanceRangeSet() : vl::DistanceLODEvaluator
  • setDoubleBuffer() : vl::OpenGLContextFormat
  • setDrawBuffers() : vl::RenderTarget
  • setDrawFramebuffer() : vl::BlitFramebuffer
  • setDstAlpha() : vl::BlendFunc
  • setDstRect() : vl::BlitFramebuffer
  • setDstRGB() : vl::BlendFunc
  • setEffect() : vl::Actor
  • setElemCount() : vl::PlyLoader::PlyElement
  • setEmission() : vl::Material
  • setEmpiricalAtomRadii() : vlMolecule::Molecule
  • setEnable() : vl::ShaderNode
  • setEnabled()
: vl::Primitives
, vl::UIEventListener
  • setEnableMask()
: vl::Actor
, vl::Effect
, vl::RenderingAbstract
, vl::SceneManager
  • setEnableSet() : vl::Shader
  • setEnd() : vl::Fog
  • setEvaluateLOD() : vl::Rendering
  • setExStyle() : vlWin32::Win32Window
  • setEyePlaneQ() : vl::TexGen
  • setEyePlaneR() : vl::TexGen
  • setEyePlaneS() : vl::TexGen
  • setEyePlaneT() : vl::TexGen
  • setFactor()
: vl::PolygonOffset
, vl::LineStipple
  • setFadeThresholdSize() : vl::PointParameter
  • setFarPlane() : vl::Camera
  • setFillBottom() : vl::Extrusion
  • setFillTop() : vl::Extrusion
  • setFlatColor() : vl::Material
  • setFogCoordArray() : vl::Geometry
  • setFogHint() : vl::Hint
  • setFont()
: vl::Glyph
, vl::Text
, vlVG::VectorGraphics
  • setFormat()
: vl::Image
, vl::Texture::SetupParams
  • setFOV() : vl::Camera
  • setFragmentShader() : vl::Terrain
  • setFrontAmbient() : vl::Material
  • setFrontDiffuse() : vl::Material
  • setFrontEmission() : vl::Material
  • setFrontFace() : vl::PolygonMode
  • setFrontFlatColor() : vl::Material
  • setFrontShininess() : vl::Material
  • setFrontSpecular() : vl::Material
  • setFrontTransparency() : vl::Material
  • setFrustum()
: vl::Camera
, vl::RayIntersector
  • setFullscreen()
: vl::OpenGLContextFormat
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • setGenerateMipmap() : vl::TexParameter
  • setGenerateMipmapHint() : vl::Hint
  • setGenModeQ() : vl::TexGen
  • setGenModeR() : vl::TexGen
  • setGenModeS() : vl::TexGen
  • setGenModeT() : vl::TexGen
  • setGeometry() : vl::RayIntersectionGeometry
  • setGeometryInputType() : vl::GLSLProgram
  • setGeometryOutputType() : vl::GLSLProgram
  • setGeometryVerticesOut() : vl::GLSLProgram
  • setGLSLVertexBlendEnabled() : vl::MorphingActor
  • setGlyphIndex() : vl::Glyph
  • setGreen() : vl::ColorMask
  • setGreenBias() : vl::PixelTransfer
  • setGreenScale() : vl::PixelTransfer
  • setHandle() : vl::Texture
  • setHasMipmaps() : vl::Texture::SetupParams
  • setHeight()
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
, vl::ReadPixels
, vl::Rect< T >
, vl::RenderTarget
, vl::Terrain
, vl::Texture
, vl::Viewport
  • setHeightmapTexture() : vl::Terrain
  • setHeightmapTextureFormat() : vl::Terrain
  • setHighQualityNormals() : vlVolume::MarchingCubes
  • setId()
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • setIdentity()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • setIllum() : vl::ObjMaterial
  • setImage()
: vl::ReadPixels
, vl::Texture::SetupParams
, vlVG::VectorGraphics
  • setImageBuffer() : vl::Image
  • setImagePath() : vl::Texture::SetupParams
  • setImfchan() : vl::ObjTexture
  • setIndexOffset() : vl::PixelTransfer
  • setIndexShift() : vl::PixelTransfer
  • setInputFile() : vl::BufferedStream< Element_Type, Chunk_Size >
  • setInstances() : vl::Primitives
  • setInterlineSpacing() : vl::Text
  • setInternalFormat() : vl::Texture
  • setInterpolator()
: vl::CatmullRomInterpolatorFVec4
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • setIntersectionPoint() : vl::RayIntersection
  • setInverseViewMatrix() : vl::Camera
  • setInvert() : vl::SampleCoverage
  • setIsCrease() : vl::EdgeExtractor::Edge
  • setIsOpen() : vl::Portal
  • setKa() : vl::ObjMaterial
  • setKd() : vl::ObjMaterial
  • setKerningEnabled() : vl::Text
  • setKeysBackward() : vl::GhostCameraManipulator
  • setKeysDown() : vl::GhostCameraManipulator
  • setKeysForward() : vl::GhostCameraManipulator
  • setKeysLeft() : vl::GhostCameraManipulator
  • setKeysRight() : vl::GhostCameraManipulator
  • setKeysUp() : vl::GhostCameraManipulator
  • setKs() : vl::ObjMaterial
  • setLabelFont() : vlVolume::VolumePlot
  • setLabelFormat() : vlVolume::VolumePlot
  • setLastUpdateTime()
: vl::Actor
, vl::Shader
  • setLayer()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • setLayout() : vl::Text
  • setLeft() : vl::Glyph
  • setLevel()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • setLight() : vlVolume::SlicedVolume
  • setLightIndex() : vl::Light
  • setLinearAttenuation() : vl::Light
  • setLinearFilteringEnabled() : vl::BlitFramebuffer
  • setLineSmoothHint() : vl::Hint
  • setLineSmoothing() : vlVG::VectorGraphics
  • setLineStipple() : vlVG::VectorGraphics
  • setLineWidth()
: vl::EdgeRenderer
, vlVG::VectorGraphics
, vlMolecule::Molecule
  • setLoadExtensions() : vl::ResourceLoadWriter
  • setLocalMatrix() : vl::Transform
  • setLocalViewer() : vl::LightModel
  • setLOD() : vl::Effect
  • setLodBias() : vl::TexEnv
  • setLODEvaluator()
: vl::Actor
, vl::Effect
  • setLODs() : vl::Actor
  • setLogFile() : vl::StandardLog
  • setLogger() : vl::Log
  • setLogicOp() : vlVG::VectorGraphics
  • setMagFilter() : vl::TexParameter
  • setMap_Bump() : vl::ObjMaterial
  • setMap_d() : vl::ObjMaterial
  • setMap_Decal() : vl::ObjMaterial
  • setMap_Disp() : vl::ObjMaterial
  • setMap_Ka() : vl::ObjMaterial
  • setMap_Kd() : vl::ObjMaterial
  • setMap_Ks() : vl::ObjMaterial
  • setMap_Ns() : vl::ObjMaterial
  • setMapColor() : vl::PixelTransfer
  • setMapStencil() : vl::PixelTransfer
  • setMargin() : vl::Text
  • setMaterial() : vl::ObjMesh
  • setMatrix()
: vl::TextureMatrix
, vl::Text
, vlVG::VectorGraphics
  • setMaxCorner()
: vl::AABB
, vlVolume::VolumePlot
  • setMinCorner()
: vl::AABB
, vlVolume::VolumePlot
  • setMinFilter() : vl::TexParameter
  • setMipmapLevel()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • setMipmaps() : vl::Image
  • setMM_Base() : vl::ObjTexture
  • setMM_Gain() : vl::ObjTexture
  • setMode()
: vl::Fog
, vl::TexEnv
, vl::Text
  • setMolecule() : vlMolecule::RingExtractor
  • setMoleculeName() : vlMolecule::Molecule
  • setMoleculeStyle() : vlMolecule::Molecule
  • setMousePosition()
: vlSDL::SDLWindow
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • setMouseVisible()
: vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • setMovementSpeed() : vl::GhostCameraManipulator
  • setMultisample() : vl::OpenGLContextFormat
  • setMultisampleSamples() : vl::OpenGLContextFormat
  • setName()
: vl::Object
, vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyElement
  • setNearFarClippingPlanesOptimized() : vl::Camera
  • setNearPlane() : vl::Camera
  • setNi() : vl::ObjMaterial
  • setNormal()
: vl::Billboard
, vl::Plane
, vl::Portal
  • setNormal1() : vl::EdgeExtractor::Edge
  • setNormal2() : vl::EdgeExtractor::Edge
  • setNormalArray() : vl::Geometry
  • setNormalize() : vl::VertexAttributeArray
  • setNoRotation() : vl::quat
  • setNs() : vl::ObjMaterial
  • setNull()
: vl::AABB
, vl::Sphere
  • setO_UVW() : vl::ObjTexture
  • setObjectPlaneQ() : vl::TexGen
  • setObjectPlaneR() : vl::TexGen
  • setObjectPlaneS() : vl::TexGen
  • setObjectPlaneT() : vl::TexGen
  • setOccludee() : vl::Actor
  • setOcclusionCullingEnabled() : vl::Renderer
  • setOcclusionQueryTick() : vl::Actor
  • setOcclusionThreshold() : vl::Renderer
  • setOpenGLContext() : vl::Renderer
  • setOpenGLContextInfo() : vl::OpenGLContext
  • setOperand0Alpha() : vl::TexEnv
  • setOperand0RGB() : vl::TexEnv
  • setOperand1Alpha() : vl::TexEnv
  • setOperand1RGB() : vl::TexEnv
  • setOperand2Alpha() : vl::TexEnv
  • setOperand2RGB() : vl::TexEnv
  • setOrigin()
: vl::Plane
, vl::Ray
, vl::Terrain
  • setOutlineColor() : vl::Text
  • setOutlineEnabled() : vl::Text
  • setParent() : vl::ActorTreeAbstract
  • setPath()
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::VirtualFile
, vl::ObjTexture
, vl::ZippedDirectory
  • setPattern() : vl::LineStipple
  • setPerspectiveCorrectionHint() : vl::Hint
  • setPivot() : vl::TrackballManipulator
  • setPixelRange() : vl::PixelLODEvaluator
  • setPixelRangeSet() : vl::PixelLODEvaluator
  • setPlane()
: vl::Frustum
, vl::ClipPlane
  • setPlaneIndex() : vl::ClipPlane
  • setPlotTransform() : vlVolume::VolumePlot
  • setPoint()
: vl::Sphere
, vlVG::VectorGraphics
  • setPointSize() : vlVG::VectorGraphics
  • setPointSmoothHint() : vl::Hint
  • setPointSmoothing() : vlVG::VectorGraphics
  • setPointSpriteCoordReplace() : vl::TexEnv
  • setPolygonOffsetFactor() : vl::EdgeRenderer
  • setPolygonOffsetUnits() : vl::EdgeRenderer
  • setPolygonSmoohtHint() : vl::Hint
  • setPolygonSmoothing() : vlVG::VectorGraphics
  • setPolygonStipple() : vlVG::VectorGraphics
  • setPosition()
: vlGLUT::GLUTWindow
, vl::Billboard
, vl::DrawPixels::Pixels
, vl::GhostCameraManipulator
, vl::Light
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlSDL::SDLWindow
  • setPostColorMatrixAlphaBias() : vl::PixelTransfer
  • setPostColorMatrixAlphaScale() : vl::PixelTransfer
  • setPostColorMatrixBlueBias() : vl::PixelTransfer
  • setPostColorMatrixBlueScale() : vl::PixelTransfer
  • setPostColorMatrixGreenBias() : vl::PixelTransfer
  • setPostColorMatrixGreenScale() : vl::PixelTransfer
  • setPostColorMatrixRedBias() : vl::PixelTransfer
  • setPostColorMatrixRedScale() : vl::PixelTransfer
  • setPostConvolutionAlphaBias() : vl::PixelTransfer
  • setPostConvolutionAlphaScale() : vl::PixelTransfer
  • setPostConvolutionBlueBias() : vl::PixelTransfer
  • setPostConvolutionBlueScale() : vl::PixelTransfer
  • setPostConvolutionGreenBias() : vl::PixelTransfer
  • setPostConvolutionGreenScale() : vl::PixelTransfer
  • setPostConvolutionRedBias() : vl::PixelTransfer
  • setPostConvolutionRedScale() : vl::PixelTransfer
  • setPrimitiveIndex() : vl::RayIntersectionGeometry
  • setPrimitives() : vl::RayIntersectionGeometry
  • setPrimitiveType()
: vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
  • setProjectionAsFrustum() : vl::Camera
  • setProjectionAsOrtho() : vl::Camera
  • setProjectionAsOrtho2D() : vl::Camera
  • setProjectionAsPerspective() : vl::Camera
  • setProjectionMatrix() : vl::Camera
  • setProtectedVertices() : vl::PolygonSimplifier
  • setPureInteger() : vl::VertexAttributeArray
  • setQErr() : vl::PolygonSimplifier::Vertex
  • setQuadraticAttenuation() : vl::Light
  • setQuality() : vl::LoadWriterJPG
  • setQuick() : vl::PolygonSimplifier
  • setRadius()
: vl::Sphere
, vlMolecule::Atom
, vlMolecule::Bond
  • setRank() : vl::UIEventListener
  • setRay() : vl::RayIntersector
  • setReadBuffer()
: vl::CopyTexSubImage
, vl::ReadPixels
  • setReadFramebuffer() : vl::BlitFramebuffer
  • setRed() : vl::ColorMask
  • setRedBias() : vl::PixelTransfer
  • setRedScale() : vl::PixelTransfer
  • setRemoveAfterCall() : vl::RenderingCallback
  • setRemoveDoubles()
: vl::GeometryLoadCallback
, vl::PolygonSimplifier
  • setRenderBlock() : vl::Actor
  • setRenderer() : vl::Rendering
  • setRendering() : vl::VisualizationLibrary
  • setRenderQueueSorter() : vl::Rendering
  • setRenderRank()
: vl::Effect
, vl::Actor
  • setRenderState()
: vl::RenderStateSet
, vl::Shader
, vl::ShaderNode
  • setRenderStateSet() : vl::Shader
  • setRenderTarget() : vl::Rendering
  • setRGBABits() : vl::OpenGLContextFormat
  • setRGBScale() : vl::TexEnv
  • setRingOffset() : vlMolecule::Molecule
  • setRotationButton() : vl::TrackballManipulator
  • setRotationSpeed()
: vl::GhostCameraManipulator
, vl::TrackballManipulator
  • setS0() : vl::Glyph
  • setS1() : vl::Glyph
  • setS_UVW() : vl::ObjTexture
  • setSamples() : vl::FBORenderbufferAttachment
  • setSamplingResolution() : vlVolume::VolumePlot
  • setSavePath() : vl::ReadPixels
  • setScalarType()
: vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
  • setSceneBoundingSphere() : vl::Camera
  • setScissor()
: vl::Actor
, vl::Scissor
, vl::Shader
, vlVG::VectorGraphics
  • setScissorBox() : vl::Clear
  • setSecondaryColorArray() : vl::Geometry
  • setSetupParams() : vl::Texture
  • setShader() : vl::ShaderNode
  • setShaderAnimationEnabled() : vl::Rendering
  • setShadowColor() : vl::Text
  • setShadowEnabled() : vl::Text
  • setShadowVector() : vl::Text
  • setShininess() : vl::Material
  • setShowAtomName() : vlMolecule::Atom
  • setShowAtomNames() : vlMolecule::Molecule
  • setShowCreases()
: vl::EdgeRenderer
, vl::EdgeUpdateCallback
  • setShowHiddenLines() : vl::EdgeRenderer
  • setShowPortals() : vl::SceneManagerPortals
  • setSilhouette() : vl::Extrusion
  • setSilhouetteMode() : vl::Extrusion
  • setSize()
: vl::Font
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vl::DrawPixels::Pixels
, vlWX::vlWXGLCanvas
  • setSizeMax() : vl::PointParameter
  • setSizeMin() : vl::PointParameter
  • setSliceCount() : vlVolume::SlicedVolume
  • setSmooth()
: vl::Extrusion
, vl::Font
  • setSmoothLines()
: vl::EdgeRenderer
, vlMolecule::Molecule
  • setSortMode() : vl::DepthSortCallback
  • setSortTriangles() : vl::GeometryLoadCallback
  • setSortVertices() : vl::GeometryLoadCallback
  • setSource() : vl::GLSLShader
  • setSource0Alpha() : vl::TexEnv
  • setSource0RGB() : vl::TexEnv
  • setSource1Alpha() : vl::TexEnv
  • setSource1RGB() : vl::TexEnv
  • setSource2Alpha() : vl::TexEnv
  • setSource2RGB() : vl::TexEnv
  • setSourceZipFile()
: vl::ZippedDirectory
, vl::ZippedFileInfo
  • setSpecular()
: vl::Light
, vl::Material
  • setSpotCutoff() : vl::Light
  • setSpotDirection() : vl::Light
  • setSpotExponent() : vl::Light
  • setSrcAlpha() : vl::BlendFunc
  • setSrcRect() : vl::BlitFramebuffer
  • setSrcRGB() : vl::BlendFunc
  • setStart()
: vl::DrawArrays
, vl::Fog
, vl::DrawPixels::Pixels
  • setStencilBufferBits() : vl::OpenGLContextFormat
  • setStencilFunc() : vlVG::VectorGraphics
  • setStencilMask() : vlVG::VectorGraphics
  • setStencilOp() : vlVG::VectorGraphics
  • setStencilTestEnabled() : vlVG::VectorGraphics
  • setStereo() : vl::OpenGLContextFormat
  • setStoreInPixelBufferObject() : vl::ReadPixels
  • setStream() : vl::GZipCodec
  • setStripfy() : vl::GeometryLoadCallback
  • setStyle() : vlWin32::Win32Window
  • setT()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
  • setT0() : vl::Glyph
  • setT1() : vl::Glyph
  • setT_UVW() : vl::ObjTexture
  • setTags() : vl::Image
  • setTarget() : vl::CopyTexSubImage2D
  • setTargetSector() : vl::Portal
  • setTerrainTexture() : vl::Terrain
  • setTerrainTextureFormat() : vl::Terrain
  • setTessellateIntoSinglePolygon() : vl::Tessellator
  • setTessNormal() : vl::Tessellator
  • setTexCompareFunc() : vl::TexParameter
  • setTexCompareMode() : vl::TexParameter
  • setTexCoordArray() : vl::Geometry
  • setTexres_Value() : vl::ObjTexture
  • setText() : vl::Text
  • setTextAlignment() : vl::Text
  • setTexture()
: vl::FBOTexture2DAttachment
, vl::TextureUnit
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • setTextureHandle() : vl::Glyph
  • setTextureMode() : vlVG::VectorGraphics
  • setTextureTarget() : vl::FBOTexture2DAttachment
  • setThreshold() : vlVolume::VolumeInfo
  • setTolerance() : vl::Tessellator
  • setTop() : vl::Glyph
  • setTr() : vl::ObjMaterial
  • setTransferFunction() : vlVolume::SlicedVolume
  • setTransform()
: vl::Actor
, vl::TrackballManipulator
, vlVG::VectorGraphics
, vl::Rendering
  • setTransformGeometry() : vl::GeometryLoadCallback
  • setTransformMatrix() : vl::GeometryLoadCallback
  • setTranslationButton() : vl::TrackballManipulator
  • setTranslationSpeed() : vl::TrackballManipulator
  • setTransparency() : vl::Material
  • setTree() : vl::SceneManagerBVH< T >
  • setTwoSide() : vl::LightModel
  • setType()
: vl::Image
, vl::FBODepthStencilBufferAttachment
, vl::FBOColorBufferAttachment
, vl::Billboard
, vl::FBOStencilBufferAttachment
, vl::FBODepthBufferAttachment
  • setUniform()
: vl::UniformSet
, vl::Actor
, vl::Uniform
, vl::GLSLProgram
, vl::ShaderNode
, vl::Uniform
, vl::Shader
, vl::Uniform
  • setUniform1f() : vl::Uniform
  • setUniform1i() : vl::Uniform
  • setUniform1ui() : vl::Uniform
  • setUniform2f() : vl::Uniform
  • setUniform2i() : vl::Uniform
  • setUniform2ui() : vl::Uniform
  • setUniform3f() : vl::Uniform
  • setUniform3i() : vl::Uniform
  • setUniform3ui() : vl::Uniform
  • setUniform4f() : vl::Uniform
  • setUniform4i() : vl::Uniform
  • setUniform4ui() : vl::Uniform
  • setUniformMatrix2f() : vl::Uniform
  • setUniformMatrix2x3f() : vl::Uniform
  • setUniformMatrix2x4f() : vl::Uniform
  • setUniformMatrix3f() : vl::Uniform
  • setUniformMatrix3x2f() : vl::Uniform
  • setUniformMatrix3x4f() : vl::Uniform
  • setUniformMatrix4f() : vl::Uniform
  • setUniformMatrix4x2f() : vl::Uniform
  • setUniformMatrix4x3f() : vl::Uniform
  • setUniformSet()
: vl::Shader
, vl::GLSLProgram
, vl::Actor
  • setUnitIndex() : vl::RenderState
  • setUnits() : vl::PolygonOffset
  • setup()
: vlVolume::Volume
, vl::ReadPixels
, vlVolume::Volume
  • setUpdateTime() : vl::RenderingAbstract
  • setupDefaultRenderStates() : vl::Renderer
  • setupEndPoints() : vl::CatmullRomInterpolator< T >
  • setupInternalData() : vlVolume::Volume
  • setupLabels() : vlVolume::VolumePlot
  • setupParams() : vl::Texture
  • SetupParams() : vl::Texture::SetupParams
  • setupParams() : vl::Texture
  • setupTexture1D() : vl::Texture
  • setupTexture1DArray() : vl::Texture
  • setupTexture2D() : vl::Texture
  • setupTexture2DArray() : vl::Texture
  • setupTexture3D() : vl::Texture
  • setupTextureCubemap() : vl::Texture
  • setupTextureRectangle() : vl::Texture
  • setUsage() : vl::ArrayAbstract
  • setUseAtomColors() : vlMolecule::Bond
  • setUseCameraRotationInverse() : vl::TextureMatrix
  • setUseDisplayLists() : vl::GeometryLoadCallback
  • setUseGLSL() : vl::Terrain
  • setUsePixelBufferObject() : vl::DrawPixels
  • setUseVBOs() : vl::GeometryLoadCallback
  • setValue() : vl::SampleCoverage
  • setVanDerWaalsAtomRadii() : vlMolecule::Molecule
  • setVBODirty()
: vl::ArrayAbstract
, vl::Renderable
  • setVBOEnabled() : vl::Renderable
  • setVerbose() : vl::PolygonSimplifier
  • setVert0() : vlVolume::VolumeInfo
  • setVertC() : vlVolume::VolumeInfo
  • setVertex1() : vl::EdgeExtractor::Edge
  • setVertex2() : vl::EdgeExtractor::Edge
  • setVertexArray() : vl::Geometry
  • setVertexAttributeArray() : vl::Geometry
  • setVertexShader() : vl::Terrain
  • setViewMatrix() : vl::Camera
  • setViewMatrixAsLookAt() : vl::Camera
  • setViewport() : vl::Camera
  • setViewportAlignment() : vl::Text
  • setVisible()
: vlMolecule::Bond
, vlMolecule::Atom
  • setVisited() : vlMolecule::Atom
  • setVolume() : vlVolume::VolumeInfo
  • setVolumeImage() : vlVolume::SlicedVolume
  • setVSync() : vl::OpenGLContextFormat
  • setVSyncEnabled() : vl::OpenGLContext
  • setWarnNonManifold() : vl::EdgeExtractor
  • setWarnOnSeek() : vl::GZipCodec
  • setWidth()
: vl::Viewport
, vl::Texture
, vl::CopyTexSubImage1D
, vl::ReadPixels
, vl::Image
, vl::FBORenderbufferAttachment
, vl::RenderTarget
, vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::Terrain
  • setWindingRule() : vl::Tessellator
  • setWindowClassName() : vlWin32::Win32Window
  • setWindowSize() : vlWin32::Win32Context
  • setWindowTitle()
: vlQt4::Qt4Widget
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlWX::vlWXGLCanvas
, vlSDL::SDLWindow
, vl::OpenGLContext
  • setWorldMatrix() : vl::Transform
  • setWrapR() : vl::TexParameter
  • setWrapS() : vl::TexParameter
  • setWrapT() : vl::TexParameter
  • setWriteExtensions() : vl::ResourceLoadWriter
  • setX()
: vl::Matrix4< scalar_type >
, vl::CopyTexSubImage1D
, vl::Matrix3< scalar_type >
, vl::Viewport
, vl::CopyTexSubImage2D
, vl::ReadPixels
, vl::CopyTexSubImage3D
, vl::Rect< T >
  • setXDegrees() : vl::GhostCameraManipulator
  • setXOffset()
: vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
  • setY()
: vl::Matrix3< scalar_type >
, vl::CopyTexSubImage2D
, vl::Matrix4< scalar_type >
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::CopyTexSubImage1D
, vl::ReadPixels
, vl::Viewport
  • setYDegrees() : vl::GhostCameraManipulator
  • setYOffset()
: vl::CopyTexSubImage3D
, vl::CopyTexSubImage2D
  • setZ() : vl::Matrix4< scalar_type >
  • setZero() : vl::quat
  • setZFar() : vl::DepthRange
  • setZippedFileInfo() : vl::ZippedFile
  • setZNear() : vl::DepthRange
  • setZOffset() : vl::CopyTexSubImage3D
  • setZoomButton() : vl::TrackballManipulator
  • setZoomSpeed() : vl::TrackballManipulator
  • sFail_Back() : vl::StencilOp
  • sFail_Front() : vl::StencilOp
  • ShadeModel() : vl::ShadeModel
  • shadeModel() : vl::ShadeModel
  • shader() : vl::ShaderNode
  • Shader() : vl::Shader
  • shader()
: vl::Effect
, vl::GLSLProgram
, vl::ShaderNode
, vl::GLSLProgram
  • shaderAnimationEnabled() : vl::Rendering
  • shaderCount() : vl::GLSLProgram
  • shaderNode() : vl::Terrain
  • ShaderNode() : vl::ShaderNode
  • shaderNode() : vl::Terrain
  • ShaderSequence() : vl::ShaderSequence
  • shadowColor() : vl::Text
  • shadowEnabled() : vl::Text
  • shadowVector() : vl::Text
  • shallowCopy() : vl::Geometry
  • shareOpenGLResources() : vlWin32::Win32Context
  • show()
: vlQt4::Qt4Widget
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vl::OpenGLContext
, vlGLUT::GLUTWindow
  • showAtomName() : vlMolecule::Atom
  • showAtomNames() : vlMolecule::Molecule
  • showCreases()
: vl::EdgeRenderer
, vl::EdgeUpdateCallback
  • showHiddenLines() : vl::EdgeRenderer
  • showPortals() : vl::SceneManagerPortals
  • shrink() : vl::Collection< T >
  • shrinkDrawElements() : vl::Geometry
  • shutdown()
: vlut::Applet
, vl::VisualizationLibrary
  • silhouette() : vl::Extrusion
  • silhouetteMode() : vl::Extrusion
  • simplifiedIndex() : vl::PolygonSimplifier::Vertex
  • simplifiedTriangles() : vl::PolygonSimplifier
  • simplifiedTrianglesCount() : vl::PolygonSimplifier
  • simplifiedVertices() : vl::PolygonSimplifier
  • simplifiedVerticesCount() : vl::PolygonSimplifier
  • simplify() : vl::PolygonSimplifier
  • size()
: vlVolume::Volume
, vl::DrawPixels::Pixels
, vl::RenderQueue
, vlGLUT::GLUTWindow
, vl::GZipCodec
, vl::DiskFile
, vl::Font
, vl::OpenGLContext
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::VirtualFile
, vl::Collection< T >
, vlQt4::Qt4Widget
, vl::MemoryFile
, vl::ZippedFile
, vl::ArrayAbstract
, vlWin32::Win32Context
  • sizeGPU() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • sizeMax() : vl::PointParameter
  • sizeMin() : vl::PointParameter
  • skipChunk() : vl::A3DSLoader
  • sleep() : vl::Time
  • slerp() : vl::quat
  • sliceCount() : vlVolume::SlicedVolume
  • SlicedVolume() : vlVolume::SlicedVolume
  • slices() : vlVolume::Volume
  • SLONGLONG : vl::SayArg
  • slonglong : vl::SayArg
  • smooth()
: vl::Font
, vl::Extrusion
  • smoothLines()
: vlMolecule::Molecule
, vl::EdgeRenderer
  • sort()
: vl::Collection< T >
, vl::DepthSortCallback
, vl::RenderQueue
  • sortCycles() : vlMolecule::RingExtractor
  • sorter() : vl::RayIntersector
  • sortEventListeners() : vl::OpenGLContext
  • sortMode() : vl::DepthSortCallback
  • sortTriangles()
: vl::DrawElements< index_type, Tgltype, arr_type >
, vl::GeometryLoadCallback
, vl::Geometry
, vl::Primitives
  • sortVertices()
: vl::Geometry
, vl::GeometryLoadCallback
  • source() : vl::GLSLShader
  • source0Alpha() : vl::TexEnv
  • source0RGB() : vl::TexEnv
  • source1Alpha() : vl::TexEnv
  • source1RGB() : vl::TexEnv
  • source2Alpha() : vl::TexEnv
  • source2RGB() : vl::TexEnv
  • sourceZipFile()
: vl::ZippedDirectory
, vl::ZippedFileInfo
  • specular() : vl::Light
  • Sphere() : vl::Sphere
  • split() : vl::String
  • splitLines() : vl::String
  • spotCutoff() : vl::Light
  • spotDirection() : vl::Light
  • spotExponent() : vl::Light
  • squad() : vl::quat
  • squeeze() : vl::String
  • srcAlpha() : vl::BlendFunc
  • srcRect() : vl::BlitFramebuffer
  • srcRGB() : vl::BlendFunc
  • st()
: vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
  • start()
: vl::Time
, vl::DrawArrays
, vl::DrawPixels::Pixels
, vl::Fog
  • startAnimation() : vl::MorphingActor
  • startCRC32() : vl::CRC32CheckSum
  • startDrawing() : vlVG::VectorGraphics
  • startsWith() : vl::String
  • stencilBufferBits() : vl::OpenGLContextFormat
  • StencilFunc() : vl::StencilFunc
  • StencilMask() : vl::StencilMask
  • stencilMask() : vlVG::VectorGraphics
  • StencilOp() : vl::StencilOp
  • stencilTestEnabled() : vlVG::VectorGraphics
  • stereo() : vl::OpenGLContextFormat
  • sticksStyle() : vlMolecule::Molecule
  • stop() : vl::Time
  • stopAnimation() : vl::MorphingActor
  • storeInPixelBufferObject() : vl::ReadPixels
  • stp() : vl::Vector4< scalar_type >
  • str()
: vl::Say
, vl::SayArg
  • stream() : vl::GZipCodec
  • String() : vl::String
  • STRING : vl::SayArg
  • stripfy()
: vl::GeometryLoadCallback
, vl::TriangleStripGenerator
  • style() : vlWin32::Win32Window
  • subDir()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • subImage() : vl::Image
  • subRenderings() : vl::RenderingTree
  • substituteColorGreenKey() : vl::Image
  • substituteColorRGB_RGB() : vl::Image
  • substituteColorRGB_RGBA() : vl::Image
  • substring() : vl::String
  • supports() : vl::Texture
  • swap()
: vl::GLBufferObject
, vl::ref< T >
, vl::Collection< T >
, vl::Buffer
  • swapBuffers()
: vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vlQt4::Qt4Widget
, vl::OpenGLContext
  • symbol() : vlMolecule::AtomInfo
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- t -

  • t()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • t0() : vl::Glyph
  • t1() : vl::Glyph
  • t_UVW() : vl::ObjTexture
  • tags()
: vl::Image
, vlMolecule::Molecule
  • target() : vl::CopyTexSubImage2D
  • targetSector() : vl::Portal
  • Terrain() : vl::Terrain
  • terrainTexture() : vl::Terrain
  • terrainTextureFormat() : vl::Terrain
  • tessBeginData() : vl::Tessellator
  • tessCombineData() : vl::Tessellator
  • tessellate() : vl::Tessellator
  • tessellatedTris() : vl::Tessellator
  • tessellateGeometry() : vl::Tessellator
  • tessellateIntoSinglePolygon() : vl::Tessellator
  • Tessellator() : vl::Tessellator
  • tessEnd() : vl::Tessellator
  • tessError() : vl::Tessellator
  • tessNormal() : vl::Tessellator
  • tessVertexData() : vl::Tessellator
  • texCoordArray() : vl::Geometry
  • texCoords() : vlVolume::SlicedVolume
  • texCoordsArray() : vl::ObjLoader
  • TexEnv() : vl::TexEnv
  • TexGen() : vl::TexGen
  • TexParameter() : vl::TexParameter
  • texres_Value() : vl::ObjTexture
  • text() : vl::Text
  • Text : vl::Font , vl::Text
  • textAlignment() : vl::Text
  • TextStream() : vl::TextStream
  • textTemplate() : vlVolume::VolumePlot
  • texture() : vl::TextureUnit
  • Texture() : vl::Texture
  • texture()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
, vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • textureHandle() : vl::Glyph
  • TextureMatrix() : vl::TextureMatrix
  • textureMode() : vlVG::VectorGraphics
  • textureTarget() : vl::FBOTexture2DAttachment
  • textureUnit() : vl::RenderState
  • TextureUnit() : vl::TextureUnit
  • textureUnitCount() : vl::OpenGLContext
  • threshold() : vlVolume::VolumeInfo
  • Time() : vl::Time
  • toAscii() : vl::String
  • toAxisAngle() : vl::quat
  • toDouble() : vl::String
  • toFloat() : vl::String
  • toInt() : vl::String
  • toLatin1() : vl::String
  • tolerance() : vl::Tessellator
  • toLowerCase() : vl::String
  • toMatrix() : vl::quat
  • top()
: vl::Glyph
, vl::Rect< T >
, vl::RectI
, vl::RectF
  • topRight()
: vl::RectI
, vl::RectF
, vlVolume::Volume
  • toStdString()
: vl::MD5CheckSum
, vl::String
  • toStdWString() : vl::String
  • toUpperCase() : vl::String
  • toUTF16BE() : vl::String
  • toUTF16LE() : vl::String
  • toUTF8() : vl::String
  • tr() : vl::ObjMaterial
  • trackball() : vlut::Applet
  • TrackballManipulator() : vl::TrackballManipulator
  • trackballRotation() : vl::TrackballManipulator
  • transferFunction() : vlVolume::SlicedVolume
  • transform() : vl::Rendering
  • Transform() : vl::Transform
  • transform()
: vl::Actor
, vl::ArrayAbstract
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Geometry
, vl::Rendering
, vl::TrackballManipulator
  • transformed()
: vl::Sphere
, vl::AABB
, vl::Sphere
  • transformGeometry() : vl::GeometryLoadCallback
  • transformMatrix() : vl::GeometryLoadCallback
  • transformTree() : vlMolecule::Molecule
  • translate()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Text
, vl::Transform
, vlVG::VectorGraphics
, vl::Transform
  • translateEvent() : vlSDL::SDLWindow
  • translateKeyEvent() : vlQt4::Qt4Widget
  • translatePath() : vl::VirtualDirectory
  • translateType() : vl::PlyLoader
  • translation()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • translationButton() : vl::TrackballManipulator
  • TranslationMode : vl::TrackballManipulator
  • translationSpeed() : vl::TrackballManipulator
  • transpose()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
  • tree() : vl::SceneManagerBVH< T >
  • Triangle()
: vl::PolygonSimplifier::Triangle
, vl::PolygonSimplifier::Vertex
  • triangleCount()
: vl::Renderable
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::DrawArrays
, vl::Primitives
  • trim() : vl::String
  • trimStdString() : vl::String
  • twoSide() : vl::LightModel
  • type()
: vl::Hint
, vl::PointParameter
, vl::TextureUnit
, vl::ClipPlane
, vl::CullFace
, vl::Image
, vl::SampleCoverage
, vl::FBODepthStencilBufferAttachment
, vl::Fog
, vl::LogicOp
, vl::Uniform
, vl::ColorMask
, vl::Material
, vl::Billboard
, vl::SayArg
, vl::PixelTransfer
, vl::FBOStencilBufferAttachment
, vl::BlendColor
, vl::TexGen
, vl::PolygonMode
, vl::RenderState
, vl::FrontFace
, vl::TexEnv
, vl::FBOColorBufferAttachment
, vl::LineWidth
, vl::ShadeModel
, vlMolecule::AtomInfo
, vl::AlphaFunc
, vl::PolygonOffset
, vl::StencilOp
, vl::FBODepthBufferAttachment
, vl::StencilMask
, vl::DepthRange
, vl::GLSLProgram
, vl::Light
, vl::PolygonStipple
, vl::GLSLShader
, vl::DepthMask
, vl::BlendEquation
, vl::StencilFunc
, vl::DepthFunc
, vl::PointSize
, vl::BlendFunc
, vl::LightModel
, vl::TextureMatrix
, vl::LineStipple
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- u -

  • UIEventListener() : vl::UIEventListener
  • ULONGLONG : vl::SayArg
  • ulonglong : vl::SayArg
  • unbindFragDataLocation() : vl::GLSLProgram
  • uncompressedSize()
: vl::GZipCodec
, vl::ZippedFileInfo
  • ungetLine() : vl::TextStream
  • ungetToken() : vl::BufferedStream< Element_Type, Chunk_Size >
  • Uniform() : vl::Uniform
  • uniforms()
: vl::Actor
, vl::Shader
, vl::UniformSet
  • uniformSet() : vl::GLSLProgram
  • UniformSet() : vl::UniformSet
  • uniformSet()
: vl::Actor
, vl::GLSLProgram
  • united() : vl::Rect< T >
  • units() : vl::PolygonOffset
  • unmapGPUBuffer() : vl::GLBufferObject
  • unproject() : vl::Camera
  • update()
: vlVolume::SlicedVolume
, vl::Actor
, vl::MorphingActor
, vl::OpenGLContext
, vl::Shader
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • updateActorCache() : vl::EdgeRenderer
  • updateAlpha() : vlVolume::MarchingCubes
  • updateBezierSurface() : vl::BezierSurface
  • updateColor() : vlVolume::MarchingCubes
  • updateHierachy() : vl::ShaderNode
  • updateModifiers() : vlGLUT::GLUTWindow
  • updateOverlay() : vlGLUT::GLUTWindow
  • updatePitch() : vl::Image
  • updateTime() : vl::RenderingAbstract
  • updateUniforms() : vlVolume::SlicedVolume
  • updateVBO() : vl::ArrayAbstract
  • updateVBOs()
: vl::Geometry
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • usage()
: vl::GLBufferObject
, vl::ArrayAbstract
  • useAtomColors() : vlMolecule::Bond
  • useCameraRotationInverse() : vl::TextureMatrix
  • useDisplayLists() : vl::GeometryLoadCallback
  • useGLSL() : vl::Terrain
  • usePixelBufferObject() : vl::DrawPixels
  • useProgram() : vl::GLSLProgram
  • useVBOs() : vl::GeometryLoadCallback
  • UT_Float : vl::Uniform
  • UT_Float2 : vl::Uniform
  • UT_Float3 : vl::Uniform
  • UT_Float4 : vl::Uniform
  • UT_Int : vl::Uniform
  • UT_Int2 : vl::Uniform
  • UT_Int3 : vl::Uniform
  • UT_Int4 : vl::Uniform
  • UT_Mat2 : vl::Uniform
  • UT_Mat2x3 : vl::Uniform
  • UT_Mat2x4 : vl::Uniform
  • UT_Mat3 : vl::Uniform
  • UT_Mat3x2 : vl::Uniform
  • UT_Mat3x4 : vl::Uniform
  • UT_Mat4 : vl::Uniform
  • UT_Mat4x2 : vl::Uniform
  • UT_Mat4x3 : vl::Uniform
  • UT_UInt : vl::Uniform
  • UT_UInt2 : vl::Uniform
  • UT_UInt3 : vl::Uniform
  • UT_UInt4 : vl::Uniform
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- v -

  • valence() : vlMolecule::AtomInfo
  • valid() : vl::ObjTexture
  • validateProgram() : vl::GLSLProgram
  • value()
: vl::KeyValues
, vlVolume::Volume
, vl::SampleCoverage
, vlVolume::Volume
  • values() : vlVolume::Volume
  • vanDerWaalsRadius() : vlMolecule::AtomInfo
  • vboDirty()
: vl::ArrayAbstract
, vl::Renderable
  • vboEnabled() : vl::Renderable
  • vector()
: vl::Collection< T >
, vl::PolygonSimplifier::QErr
  • Vector2() : vl::Vector2< scalar_type >
  • Vector3() : vl::Vector3< scalar_type >
  • Vector4() : vl::Vector4< scalar_type >
  • vectorAsVec4() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • vectorGraphicObjects() : vlVG::SceneManagerVectorGraphics
  • VectorGraphics() : vlVG::VectorGraphics
  • verbose() : vl::PolygonSimplifier
  • versionNeeded() : vl::ZippedFileInfo
  • versionString() : vl::VisualizationLibrary
  • vert0() : vlVolume::VolumeInfo
  • vertC() : vlVolume::VolumeInfo
  • Vertex() : vl::PolygonSimplifier::Vertex
  • vertex() : vl::PolygonSimplifier::Triangle
  • Vertex : vl::PolygonSimplifier::Triangle
  • vertex1() : vl::EdgeExtractor::Edge
  • vertex2() : vl::EdgeExtractor::Edge
  • vertexArray()
: vl::Geometry
, vl::ObjLoader
  • VertexAttributeArray() : vl::VertexAttributeArray
  • vertexAttributeArrays() : vl::Geometry
  • vertexShader() : vl::Terrain
  • viewMatrix() : vl::Camera
  • Viewport() : vl::Viewport
  • viewport() : vl::Camera
  • viewportAlignment() : vl::Text
  • VirtualDirectory() : vl::VirtualDirectory
  • VirtualFile() : vl::VirtualFile
  • visibilityEvent() : vl::UIEventListener
  • visible()
: vlMolecule::Bond
, vlMolecule::Atom
  • visited() : vlMolecule::Atom
  • visitSector() : vl::SceneManagerPortals
  • vlWXGLCanvas() : vlWX::vlWXGLCanvas
  • volume() : vl::AABB
  • Volume() : vlVolume::Volume
  • volume() : vlVolume::VolumeInfo
  • volumeInfo() : vlVolume::MarchingCubes
  • VolumeInfo() : vlVolume::VolumeInfo
  • volumeInfo() : vlVolume::MarchingCubes
  • VolumeInfo() : vlVolume::VolumeInfo
  • VolumePlot() : vlVolume::VolumePlot
  • volumes() : vl::Sector
  • vSync() : vl::OpenGLContextFormat
  • vsyncEnabled() : vl::OpenGLContext
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- w -

  • w()
: vl::quat
, vl::Vector4< scalar_type >
  • warning() : vl::Log
  • warnNonManifold() : vl::EdgeExtractor
  • warnOnSeek() : vl::GZipCodec
  • wheelEvent() : vlQt4::Qt4Widget
  • width()
: vl::OpenGLContext
, vl::ReadPixels
, vl::AABB
, vl::Rect< T >
, vl::RenderTarget
, vl::CopyTexSubImage1D
, vl::Terrain
, vl::Texture
, vl::CopyTexSubImage2D
, vl::Viewport
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
  • Win32Context() : vlWin32::Win32Context
  • Win32Window() : vlWin32::Win32Window
  • Win32WindowClassName : vlWin32::Win32Window
  • windingRule() : vl::Tessellator
  • windowClassName() : vlWin32::Win32Window
  • WindowProc() : vlWin32::Win32Window
  • windowSize() : vlWin32::Win32Context
  • winMap() : vlWin32::Win32Window
  • wireframeStyle() : vlMolecule::Molecule
  • worldMatrix() : vl::Transform
  • worldMatrixUpdateTick() : vl::Transform
  • wrapR() : vl::TexParameter
  • wrapS() : vl::TexParameter
  • wrapT() : vl::TexParameter
  • write() : vl::VirtualFile
  • write_Implementation()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • writeCallbacks() : vl::LoadWriterManager
  • writeExtensions() : vl::ResourceLoadWriter
  • writeResource()
: vl::LoadWriter3DS
, vl::LoadWriterTGA
, vl::LoadWriterAC3D
, vl::LoadWriterSTL
, vl::LoadWriterJPG
, vl::LoadWriterTIFF
, vl::LoadWriterAC3D
, vl::LoadWriterDAT
, vl::LoadWriterMD2
, vl::LoadWriterOBJ
, vl::LoadWriterDICOM
, vl::LoadWriter3DS
, vl::LoadWriterOBJ
, vl::ResourceLoadWriter
, vl::LoadWriterManager
, vl::LoadWriterPNG
, vl::LoadWriterPLY
, vl::LoadWriterTIFF
, vl::LoadWriterTGA
, vl::ResourceLoadWriter
, vl::LoadWriterPLY
, vl::LoadWriterPNG
, vl::LoadWriterDAT
, vl::LoadWriterBMP
, vl::LoadWriterDICOM
, vl::LoadWriterManager
, vl::LoadWriterSTL
, vl::LoadWriterBMP
, vl::LoadWriterDDS
  • writeSInt16() : vl::VirtualFile
  • writeSInt32() : vl::VirtualFile
  • writeSInt8() : vl::VirtualFile
  • writeUInt16() : vl::VirtualFile
  • writeUInt32() : vl::VirtualFile
  • writeUInt8() : vl::VirtualFile
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- x -

  • x()
: vl::BezierPatch
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::Vector2< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::CopyTexSubImage2D
, vl::quat
, vl::Viewport
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::ReadPixels
  • xDegrees() : vl::GhostCameraManipulator
  • xoffset()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • xy()
: vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
  • xyz() : vl::Vector4< scalar_type >
  • xyzw() : vl::quat
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- y -

  • y()
: vl::BezierPatch
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::Vector2< scalar_type >
, vl::quat
, vl::Viewport
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::CopyTexSubImage2D
, vl::quat
, vl::ReadPixels
  • yDegrees() : vl::GhostCameraManipulator
  • year()
: vl::Time
, vl::ZippedFileInfo
  • yoffset()
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Enumerations

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions

  • ETrackballMode : vl::TrackballManipulator
  • EType : vl::PlyLoader
  • EUniformType : vl::Uniform
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Enumerator

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • f
  • n
  • p
  • r
  • s
  • t
  • u
  • z

- f -

  • FLOAT64 : vl::SayArg

- n -

  • NO_TYPE : vl::SayArg
  • NoMode : vl::TrackballManipulator
  • NONE : vl::Uniform

- p -

  • PlyChar : vl::PlyLoader
  • PlyDouble : vl::PlyLoader
  • PlyError : vl::PlyLoader
  • PlyFloat : vl::PlyLoader
  • PlyInt : vl::PlyLoader
  • PlyShort : vl::PlyLoader
  • PlyUChar : vl::PlyLoader
  • PlyUInt : vl::PlyLoader
  • PlyUShort : vl::PlyLoader

- r -

  • RotationMode : vl::TrackballManipulator

- s -

  • SLONGLONG : vl::SayArg
  • STRING : vl::SayArg

- t -

  • TranslationMode : vl::TrackballManipulator

- u -

  • ULONGLONG : vl::SayArg
  • UT_Float : vl::Uniform
  • UT_Float2 : vl::Uniform
  • UT_Float3 : vl::Uniform
  • UT_Float4 : vl::Uniform
  • UT_Int : vl::Uniform
  • UT_Int2 : vl::Uniform
  • UT_Int3 : vl::Uniform
  • UT_Int4 : vl::Uniform
  • UT_Mat2 : vl::Uniform
  • UT_Mat2x3 : vl::Uniform
  • UT_Mat2x4 : vl::Uniform
  • UT_Mat3 : vl::Uniform
  • UT_Mat3x2 : vl::Uniform
  • UT_Mat3x4 : vl::Uniform
  • UT_Mat4 : vl::Uniform
  • UT_Mat4x2 : vl::Uniform
  • UT_Mat4x3 : vl::Uniform
  • UT_UInt : vl::Uniform
  • UT_UInt2 : vl::Uniform
  • UT_UInt3 : vl::Uniform
  • UT_UInt4 : vl::Uniform

- z -

  • ZCompress : vl::GZipCodec
  • ZDecompress : vl::GZipCodec
  • ZNone : vl::GZipCodec
  • ZoomMode : vl::TrackballManipulator
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- a -

  • a() : vl::Vector4< scalar_type >
  • A3DSLoader() : vl::A3DSLoader
  • A3DSMaterial() : vl::A3DSMaterial
  • A3DSTexture() : vl::A3DSTexture
  • A3DSTriFace() : vl::A3DSTriFace
  • A3DSVertex() : vl::A3DSVertex
  • AABB() : vl::AABB
  • aabb() : vl::ActorTreeAbstract
  • accumRGBABits() : vl::OpenGLContextFormat
  • acquireData() : vl::String
  • acquireFont() : vl::FontManager
  • activate()
: vl::RenderTarget
, vl::Viewport
, vl::Camera
  • active() : vl::Camera
  • actor() : vl::RayIntersection
  • Actor() : vl::Actor
  • actorAnimationEnabled() : vl::Rendering
  • ActorKdTree() : vl::ActorKdTree
  • actorQueue() : vl::Rendering
  • actorRenderRankStart() : vlVG::SceneManagerVectorGraphics
  • actors()
: vlVG::VectorGraphics
, vl::ActorTreeAbstract
, vl::RayIntersector
, vl::Sector
  • ActorTree() : vl::ActorTree
  • actorTree() : vlMolecule::Molecule
  • ActorTreeAbstract() : vl::ActorTreeAbstract
  • actorTreeMulti() : vlVolume::VolumePlot
  • addActor() : vl::ActorTreeAbstract
  • addAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • addAtom() : vlMolecule::Molecule
  • addBond() : vlMolecule::Molecule
  • addChild()
: vl::ActorTree
, vl::ShaderNode
, vl::Transform
  • addColorAttachment() : vl::FBORenderTarget
  • addDepthAttachment() : vl::FBORenderTarget
  • addDistanceRange() : vl::DistanceLODEvaluator
  • addEdge() : vl::EdgeExtractor
  • addEventListener() : vl::OpenGLContext
  • addFile() : vl::MemoryDirectory
  • addPixelRange() : vl::PixelLODEvaluator
  • addPoint()
: vl::AABB
, vl::RectF
  • addQErr() : vl::PolygonSimplifier::Vertex
  • addStencilAttachment() : vl::FBORenderTarget
  • addTextureAttachment() : vl::FBORenderTarget
  • adjacentAtoms() : vlMolecule::Atom
  • adjacentVertex() : vl::PolygonSimplifier::Vertex
  • adjacentVerticesCount() : vl::PolygonSimplifier::Vertex
  • adjustView()
: vl::Camera
, vl::TrackballManipulator
  • advance() : vl::Glyph
  • align() : vl::DrawPixels::Pixels
  • alignedFree() : vl::Buffer
  • alignedMalloc() : vl::Buffer
  • alignment()
: vl::Buffer
, vl::Text
  • allocate() : vl::Image
  • allocate1D() : vl::Image
  • allocate2D() : vl::Image
  • allocate3D() : vl::Image
  • allocateBuffer() : vl::MemoryFile
  • allocateCubemap() : vl::Image
  • alpha() : vl::ColorMask
  • alphaBias() : vl::PixelTransfer
  • alphaBits() : vl::Image
  • AlphaFunc() : vl::AlphaFunc
  • alphaFunc() : vl::AlphaFunc
  • alphaScale()
: vl::PixelTransfer
, vl::TexEnv
  • alreadyProcessed() : vl::PolygonSimplifier::Vertex
  • alwaysIdentityWorldMatrix() : vl::Transform
  • ambient() : vl::Light
  • ambientColor() : vl::LightModel
  • analyticSolution() : vl::PolygonSimplifier::QErr
  • analyze() : vl::PlyLoader::PlyElement
  • analyzeHeader() : vl::PlyLoader
  • animationStarted() : vl::MorphingActor
  • anisotropy() : vl::TexParameter
  • append() : vl::String
  • appendActors()
: vl::SceneManagerBVH< T >
, vl::ActorTreeAbstract
, vl::SceneManager
, vl::SceneManagerPortals
, vlVG::SceneManagerVectorGraphics
  • appendVisibleActors()
: vl::SceneManager
, vl::ActorTreeAbstract
, vl::SceneManagerBVH< T >
, vl::SceneManagerPortals
, vlVG::SceneManagerVectorGraphics
  • Applet() : vlut::Applet
  • apply()
: vl::RenderState
, vl::Material
, vl::LightModel
, vl::Fog
, vl::LogicOp
, vl::DepthRange
, vl::ShadeModel
, vl::LineWidth
, vl::PolygonStipple
, vl::PointParameter
, vl::StencilOp
, vl::AlphaFunc
, vl::TextureMatrix
, vl::TexEnv
, vl::TexGen
, vl::TexParameter
, vl::Hint
, vl::FrontFace
, vl::SampleCoverage
, vl::BlendEquation
, vl::PolygonMode
, vl::DepthMask
, vl::CullFace
, vl::PixelTransfer
, vl::Light
, vl::TextureUnit
, vl::StencilMask
, vl::BlendColor
, vl::StencilFunc
, vl::ColorMask
, vl::PolygonOffset
, vl::ClipPlane
, vl::GLSLProgram
, vl::LineStipple
, vl::PointSize
, vl::DepthFunc
, vl::BlendFunc
  • applyEnables() : vl::Renderer
  • applyModelViewMatrix() : vl::Camera
  • applyRenderStates() : vl::Renderer
  • applyUniformSet() : vl::GLSLProgram
  • applyViewMatrix() : vl::Camera
  • area() : vl::AABB
  • aromaticRingColor() : vlMolecule::Molecule
  • ArrayAbstract() : vl::ArrayAbstract
  • as() : vl::Object
  • as3x3() : vl::Matrix4< scalar_type >
  • aspectRatio() : vl::Camera
  • at() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::RenderQueue , vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::Collection< T >
  • Atom() : vlMolecule::Atom
  • atom() : vlMolecule::Molecule
  • atom1() : vlMolecule::Bond
  • atom2() : vlMolecule::Bond
  • atomCount() : vlMolecule::Molecule
  • atomDetail() : vlMolecule::Molecule
  • atomicMass() : vlMolecule::AtomInfo
  • atomicNumber() : vlMolecule::AtomInfo
  • AtomInfo() : vlMolecule::AtomInfo
  • atomLabelEffect() : vlMolecule::Molecule
  • atomLabelTemplate() : vlMolecule::Molecule
  • atomName() : vlMolecule::Atom
  • atoms() : vlMolecule::Molecule
  • atomsStyle() : vlMolecule::Molecule
  • atomType() : vlMolecule::Atom
  • attachShader() : vl::GLSLProgram
  • attribIndex() : vl::VertexAttributeArray
  • automaticDelete() : vl::Object
  • automaticResourceInit() : vl::Rendering
  • average() : vlVolume::Volume
  • axis() : vl::Billboard
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- k -

  • ka() : vl::ObjMaterial
  • kd() : vl::ObjMaterial
  • kdtreeFromNonLeafyActors() : vl::ActorKdTree
  • keepAromaticCycles() : vlMolecule::RingExtractor
  • keepMinimalCycles() : vlMolecule::RingExtractor
  • keepPlanarCycles() : vlMolecule::RingExtractor
  • kerningEnabled() : vl::Text
  • keyboard() : vl::OpenGLContext
  • keyPress() : vl::OpenGLContext
  • keyPressEvent()
: vlQt4::Qt4Widget
, vl::UIEventListener
  • keyRelease() : vl::OpenGLContext
  • keyReleaseEvent()
: vlut::Applet
, vlQt4::Qt4Widget
, vl::UIEventListener
  • keyValueMap() : vl::KeyValues
  • ks() : vl::ObjMaterial
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- l -

  • labelFont() : vlVolume::VolumePlot
  • labelFormat() : vlVolume::VolumePlot
  • lastChild() : vl::Transform
  • lastUpdateTime()
: vl::Actor
, vl::Shader
  • layer()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • layout() : vl::Text
  • left()
: vl::Glyph
, vl::Rect< T >
, vl::String
  • length()
: vl::Vector4< scalar_type >
, vl::quat
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
  • lengthSquared()
: vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • less() : vl::Collection< T >
  • level()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
  • light() : vlVolume::SlicedVolume
  • Light() : vl::Light
  • lightIndex() : vl::Light
  • LightModel() : vl::LightModel
  • linearAttenuation() : vl::Light
  • linearFilteringEnabled() : vl::BlitFramebuffer
  • LinearInterpolator() : vl::LinearInterpolator< T >
  • LinearInterpolatorDouble() : vl::LinearInterpolatorDouble
  • LinearInterpolatorDVec2() : vl::LinearInterpolatorDVec2
  • LinearInterpolatorDVec3() : vl::LinearInterpolatorDVec3
  • LinearInterpolatorDVec4() : vl::LinearInterpolatorDVec4
  • LinearInterpolatorFloat() : vl::LinearInterpolatorFloat
  • LinearInterpolatorFVec2() : vl::LinearInterpolatorFVec2
  • LinearInterpolatorFVec3() : vl::LinearInterpolatorFVec3
  • LinearInterpolatorFVec4() : vl::LinearInterpolatorFVec4
  • lineCount()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • lineSmoothHint() : vl::Hint
  • lineSmoothing() : vlVG::VectorGraphics
  • LineStipple() : vl::LineStipple
  • lineStipple() : vlVG::VectorGraphics
  • lineWidth()
: vl::LineWidth
, vlVG::VectorGraphics
, vlMolecule::Molecule
  • LineWidth() : vl::LineWidth
  • lineWidth() : vl::EdgeRenderer
  • linked() : vl::GLSLProgram
  • linkProgram() : vl::GLSLProgram
  • linkStatus() : vl::GLSLProgram
  • listFiles()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • listFilesRecursive()
: vl::DiskDirectory
, vl::FileSystem
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • listFilesRecursive_internal() : vl::DiskDirectory
  • listSubDirs()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • littleEndian() : vl::PlyLoader
  • load() : vl::VirtualFile
  • loadAscii() : vl::STLLoader
  • loadBinary() : vl::STLLoader
  • loadCallbacks() : vl::LoadWriterManager
  • loadExtensions() : vl::ResourceLoadWriter
  • loadFont() : vl::Font
  • loadOBJ() : vl::ObjLoader
  • loadObjMaterials() : vl::ObjLoader
  • loadPly() : vl::PlyLoader
  • loadResource()
: vl::LoadWriter3DS
, vl::LoadWriterOBJ
, vl::LoadWriterTGA
, vl::LoadWriterTIFF
, vl::LoadWriterMD2
, vl::LoadWriterDDS
, vl::LoadWriterBMP
, vl::LoadWriterTGA
, vl::LoadWriterManager
, vl::ResourceLoadWriter
, vl::LoadWriter3DS
, vl::LoadWriterAC3D
, vl::LoadWriterBMP
, vl::LoadWriterDAT
, vl::LoadWriterPNG
, vl::LoadWriterPLY
, vl::LoadWriterDDS
, vl::LoadWriterSTL
, vl::LoadWriterJPG
, vl::LoadWriterDICOM
, vl::LoadWriterJPG
, vl::LoadWriterSTL
, vl::LoadWriterPNG
, vl::LoadWriterOBJ
, vl::LoadWriterPLY
  • loadSTL() : vl::STLLoader
  • loadText() : vl::String
  • loadWriter() : vl::LoadWriterManager
  • LoadWriter3DS() : vl::LoadWriter3DS
  • LoadWriterAC3D() : vl::LoadWriterAC3D
  • LoadWriterBMP() : vl::LoadWriterBMP
  • LoadWriterDAT() : vl::LoadWriterDAT
  • LoadWriterDDS() : vl::LoadWriterDDS
  • LoadWriterDICOM() : vl::LoadWriterDICOM
  • LoadWriterJPG() : vl::LoadWriterJPG
  • loadWriterManager() : vl::VisualizationLibrary
  • LoadWriterManager() : vl::LoadWriterManager
  • LoadWriterMD2() : vl::LoadWriterMD2
  • LoadWriterOBJ() : vl::LoadWriterOBJ
  • LoadWriterPLY() : vl::LoadWriterPLY
  • LoadWriterPNG() : vl::LoadWriterPNG
  • loadWriters() : vl::LoadWriterManager
  • LoadWriterSTL() : vl::LoadWriterSTL
  • LoadWriterTGA() : vl::LoadWriterTGA
  • LoadWriterTIFF() : vl::LoadWriterTIFF
  • localMatrix() : vl::Transform
  • localViewer() : vl::LightModel
  • locateDirectory() : vl::FileSystem
  • locateFile() : vl::FileSystem
  • lod()
: vl::Effect
, vl::Actor
, vl::Effect
, vl::Actor
  • lodBias() : vl::TexEnv
  • lodEvaluator()
: vl::Actor
, vl::Effect
  • LODEvaluator() : vl::LODEvaluator
  • lodEvaluator()
: vl::Effect
, vl::Actor
  • Log() : vl::Log
  • logFile() : vl::StandardLog
  • logger()
: vl::Log
, vl::VisualizationLibrary
  • logicOp()
: vl::LogicOp
, vlVG::VectorGraphics
  • LogicOp() : vl::LogicOp
  • logOpenGLInfo() : vl::OpenGLContext
  • longestSideLength() : vl::AABB
  • lookAt() : vl::Matrix4< scalar_type >
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- m -

  • magFilter() : vl::TexParameter
  • makeColorSpectrum() : vl::Image
  • makeCurrent()
: vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vl::OpenGLContext
  • makeNonUniformColorSpectrum() : vl::Image
  • map_Bump() : vl::ObjMaterial
  • map_d() : vl::ObjMaterial
  • map_Decal() : vl::ObjMaterial
  • map_Disp() : vl::ObjMaterial
  • map_Ka() : vl::ObjMaterial
  • map_Kd() : vl::ObjMaterial
  • map_Ks() : vl::ObjMaterial
  • map_Ns() : vl::ObjMaterial
  • mapAsciiKey() : vlGLUT::GLUTWindow
  • mapColor() : vl::PixelTransfer
  • mapGPUBuffer() : vl::GLBufferObject
  • mapNewToOld() : vl::DoubleVertexRemover
  • mapOldToNew() : vl::DoubleVertexRemover
  • mapSpecialKey() : vlGLUT::GLUTWindow
  • mapStencil() : vl::PixelTransfer
  • MarchingCubes() : vlVolume::MarchingCubes
  • margin() : vl::Text
  • mask() : vl::PolygonStipple
  • mask_Back()
: vl::StencilFunc
, vl::StencilMask
  • mask_Front()
: vl::StencilFunc
, vl::StencilMask
  • Material() : vl::Material
  • material() : vl::ObjMesh
  • materials() : vl::ObjLoader
  • matrix()
: vl::PolygonSimplifier::QErr
, vl::TextureMatrix
, vl::Text
, vlVG::VectorGraphics
  • Matrix2() : vl::Matrix2< scalar_type >
  • Matrix3() : vl::Matrix3< scalar_type >
  • Matrix4() : vl::Matrix4< scalar_type >
  • matrixStack() : vlVG::VectorGraphics
  • maxCorner()
: vl::AABB
, vlVolume::VolumePlot
  • maximum() : vlVolume::Volume
  • maxVertexAttributes() : vl::GLSLProgram
  • md5()
: vl::VirtualFile
, vl::MD5CheckSum
  • MD5CheckSum() : vl::MD5CheckSum
  • meltingPoint() : vlMolecule::AtomInfo
  • MemoryDirectory() : vl::MemoryDirectory
  • memoryFile() : vl::MemoryDirectory
  • MemoryFile() : vl::MemoryFile
  • memorySubDir() : vl::MemoryDirectory
  • mergeTriangleStrips() : vl::Geometry
  • meshes() : vl::ObjLoader
  • MFCWindow() : vlMFC::MFCWindow
  • microsecond() : vl::Time
  • mightNeedZCameraDistance()
: vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterOcclusion
, vl::RenderQueueSorterAggressive
, vl::RenderQueueSorterStandard
  • minCorner()
: vl::AABB
, vlVolume::VolumePlot
  • minFilter() : vl::TexParameter
  • minimum() : vlVolume::Volume
  • minute()
: vl::Time
, vl::ZippedFileInfo
  • mipmapLevel()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • mipmaps() : vl::Image
  • mm_Base() : vl::ObjTexture
  • mm_Gain() : vl::ObjTexture
  • mode()
: vl::Text
, vl::TrackballManipulator
, vl::Fog
, vl::TexEnv
  • modeAlpha() : vl::BlendEquation
  • modeRGB() : vl::BlendEquation
  • Molecule() : vlMolecule::Molecule
  • molecule() : vlMolecule::RingExtractor
  • moleculeName() : vlMolecule::Molecule
  • moleculeStyle() : vlMolecule::Molecule
  • month()
: vl::ZippedFileInfo
, vl::Time
  • MorphingActor() : vl::MorphingActor
  • mouseDownEvent()
: vl::UIEventListener
, vl::TrackballManipulator
  • mouseMoveEvent()
: vl::TrackballManipulator
, vl::UIEventListener
, vl::GhostCameraManipulator
, vlQt4::Qt4Widget
  • mousePressEvent() : vlQt4::Qt4Widget
  • mouseReleaseEvent() : vlQt4::Qt4Widget
  • mouseUpEvent()
: vl::TrackballManipulator
, vl::UIEventListener
  • mouseVisible() : vl::OpenGLContext
  • mouseWheelEvent() : vl::UIEventListener
  • movementSpeed() : vl::GhostCameraManipulator
  • multisample() : vl::OpenGLContextFormat
  • multisampleSamples() : vl::OpenGLContextFormat
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- n -

  • name()
: vl::Object
, vl::PlyLoader::PlyPropertyAbstract
, vlMolecule::AtomInfo
, vl::PlyLoader::PlyElement
  • nearFarClippingPlanesOptimized() : vl::Camera
  • nearPlane() : vl::Camera
  • newElement() : vl::PlyLoader
  • newToken() : vl::RenderQueue
  • next() : vl::ResourceDatabase
  • ni() : vl::ObjMaterial
  • nlerp() : vl::quat
  • normal()
: vl::Billboard
, vl::Plane
, vl::PolygonSimplifier::Triangle
, vl::Portal
  • normal1() : vl::EdgeExtractor::Edge
  • normal2() : vl::EdgeExtractor::Edge
  • normalArray()
: vl::Geometry
, vl::ObjLoader
  • normalHQ() : vlVolume::Volume
  • normalize()
: vl::VertexAttributeArray
, vl::Vector4< scalar_type >
, vl::quat
, vl::ArrayAbstract
, vl::Vector2< scalar_type >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Vector3< scalar_type >
  • normalizeSlashes() : vl::String
  • normalLQ() : vlVolume::Volume
  • ns() : vl::ObjMaterial
  • null()
: vl::Viewport
, vl::String
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- o -

  • o_UVW() : vl::ObjTexture
  • Object() : vl::Object
  • objectPlaneQ() : vl::TexGen
  • objectPlaneR() : vl::TexGen
  • objectPlaneS() : vl::TexGen
  • objectPlaneT() : vl::TexGen
  • ObjMaterial() : vl::ObjMaterial
  • ObjTexture() : vl::ObjTexture
  • occlusionCullingEnabled() : vl::Renderer
  • occlusionQuery() : vl::Actor
  • occlusionQueryTick() : vl::Actor
  • occlusionThreshold() : vl::Renderer
  • offset() : vl::PolygonSimplifier::QErr
  • OnClose() : vlMFC::MFCWindow
  • OnCreate() : vlMFC::MFCWindow
  • OnDropFiles()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnEraseBackground() : vlWX::vlWXGLCanvas
  • OnIdle() : vlWX::vlWXGLCanvas
  • OnKeyDown()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnKeyUp()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnLButtonDblClk() : vlMFC::MFCWindow
  • OnLButtonDown() : vlMFC::MFCWindow
  • OnLButtonUp() : vlMFC::MFCWindow
  • OnMButtonDblClk() : vlMFC::MFCWindow
  • OnMButtonDown() : vlMFC::MFCWindow
  • OnMButtonUp() : vlMFC::MFCWindow
  • OnMouseDown() : vlWX::vlWXGLCanvas
  • OnMouseEnter() : vlWX::vlWXGLCanvas
  • OnMouseMotion() : vlWX::vlWXGLCanvas
  • OnMouseMove() : vlMFC::MFCWindow
  • OnMouseUp() : vlWX::vlWXGLCanvas
  • OnMouseWheel()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnPaint()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnRButtonDblClk() : vlMFC::MFCWindow
  • OnRButtonDown() : vlMFC::MFCWindow
  • OnRButtonUp() : vlMFC::MFCWindow
  • OnSize()
: vlWX::vlWXGLCanvas
, vlMFC::MFCWindow
  • OnTimer() : vlMFC::MFCWindow
  • open()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • openglContext()
: vl::Renderer
, vl::RenderTarget
, vl::UIEventListener
  • OpenGLContext() : vl::OpenGLContext
  • openglContextBoundEvent()
: vl::UIEventListener
, vlut::Applet
  • OpenGLContextFormat() : vl::OpenGLContextFormat
  • openglContextInfo() : vl::OpenGLContext
  • operand0Alpha() : vl::TexEnv
  • operand0RGB() : vl::TexEnv
  • operand1Alpha() : vl::TexEnv
  • operand1RGB() : vl::TexEnv
  • operand2Alpha() : vl::TexEnv
  • operand2RGB() : vl::TexEnv
  • operator bool() : vl::ref< T >
  • operator std::vector< ref< T > >() : vl::Collection< T >
  • operator String() : vl::Say
  • operator!=()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::MD5CheckSum
, vl::quat
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator()()
: vl::ActorRenderingCallback
, vl::DepthSortCallback
, vl::EdgeUpdateCallback
, vl::GeometryLoadCallback
, vl::LoadCallback
, vl::WriteCallback
, vl::MorphingCallback
, vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterBasic
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
, vl::RenderQueueSorterAggressive
, vl::Sector::VisibilityCallback
, vlVolume::VolumePlot::Function
  • operator*()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::ref< T >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator*=()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator+()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::PolygonSimplifier::QErr
, vl::quat
, vl::Sphere
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::AABB
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
  • operator+=()
: vl::AABB
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::PolygonSimplifier::QErr
, vl::quat
, vl::Sphere
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator-()
: vl::quat
, vl::Matrix4< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
  • operator-=()
: vl::quat
, vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
  • operator->() : vl::ref< T >
  • operator/()
: vl::Vector4< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector2< scalar_type >
  • operator/=()
: vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
  • operator<()
: vl::UIEventListener
, vl::String
, vl::A3DSVertex
, vl::quat
, vl::Scissor
, vl::MD5CheckSum
, vl::ref< T >
, vl::EdgeExtractor::Edge
, vl::Font
, vl::Rect< T >
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • operator<<() : vl::Say
  • operator=()
: vl::String
, vl::RectI
, vl::Sphere
, vl::DrawPixels::Pixels
, vl::Image
, vl::ZippedFile
, vl::Vector3< scalar_type >
, vl::VirtualFile
, vl::Vector4< scalar_type >
, vlMolecule::Molecule
, vl::ref< T >
, vl::Vector2< scalar_type >
, vl::ref< T >
, vl::DiskFile
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::GLBufferObject
, vl::GZipCodec
, vl::Collection< T >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::ref< T >
, vl::Object
, vl::RenderingTree
, vl::MemoryFile
, vlMolecule::Atom
, vl::Rendering
, vl::RenderingAbstract
, vl::String
, vl::Vector4< scalar_type >
, vl::Geometry
, vl::String
, vl::RectF
, vl::String
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Buffer
, vl::String
, vl::RectI
, vl::RectF
, vl::Matrix2< scalar_type >
, vl::ArrayAbstract
  • operator==()
: vl::Matrix2< scalar_type >
, vl::String
, vl::MD5CheckSum
, vl::quat
, vl::String
, vl::Vector2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::String
, vl::Vector3< scalar_type >
, vl::String
, vl::Vector4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::EdgeExtractor::Edge
  • operator[]()
: vl::Vector2< scalar_type >
, vl::Vector4< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Vector4< scalar_type >
, vl::Collection< T >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Matrix2< scalar_type >
, vl::Vector3< scalar_type >
, vl::String
, vl::Matrix3< scalar_type >
, vl::String
, vl::Vector2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • origin()
: vl::Plane
, vl::Ray
, vl::Terrain
  • originalIndex() : vl::PolygonSimplifier::Vertex
  • ortho() : vl::Matrix4< scalar_type >
  • ortho2D() : vl::Matrix4< scalar_type >
  • outlineColor() : vl::Text
  • outlineEnabled() : vl::Text
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- z -

  • z()
: vl::quat
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • zFar() : vl::DepthRange
  • ZippedDirectory() : vl::ZippedDirectory
  • ZippedFile() : vl::ZippedFile
  • zippedFile() : vl::ZippedDirectory
  • zippedFileCount() : vl::ZippedDirectory
  • ZippedFileInfo() : vl::ZippedFileInfo
  • zippedFileInfo() : vl::ZippedFile
  • zippedFileOffset() : vl::ZippedFileInfo
  • zippedSubDir() : vl::ZippedDirectory
  • zNear() : vl::DepthRange
  • zoffset() : vl::CopyTexSubImage3D
  • zoomButton() : vl::TrackballManipulator
  • zoomSpeed() : vl::TrackballManipulator
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- ~ -

  • ~Actor() : vl::Actor
  • ~Applet() : vlut::Applet
  • ~Buffer() : vl::Buffer
  • ~DiskFile() : vl::DiskFile
  • ~Effect() : vl::Effect
  • ~FBOAttachmentAbstract() : vl::FBOAttachmentAbstract
  • ~FBORenderTarget() : vl::FBORenderTarget
  • ~Font() : vl::Font
  • ~Geometry() : vl::Geometry
  • ~GLBufferObject() : vl::GLBufferObject
  • ~GLSLProgram() : vl::GLSLProgram
  • ~GLSLShader() : vl::GLSLShader
  • ~GLUTWindow() : vlGLUT::GLUTWindow
  • ~Glyph() : vl::Glyph
  • ~GZipCodec() : vl::GZipCodec
  • ~Image() : vl::Image
  • ~MFCWindow() : vlMFC::MFCWindow
  • ~Molecule() : vlMolecule::Molecule
  • ~Object() : vl::Object
  • ~OpenGLContext() : vl::OpenGLContext
  • ~Pixels() : vl::DrawPixels::Pixels
  • ~Primitives() : vl::Primitives
  • ~ref() : vl::ref< T >
  • ~Renderable() : vl::Renderable
  • ~Renderer() : vl::Renderer
  • ~RenderState() : vl::RenderState
  • ~SDLWindow() : vlSDL::SDLWindow
  • ~Shader() : vl::Shader
  • ~Tessellator() : vl::Tessellator
  • ~TextStream() : vl::TextStream
  • ~Texture() : vl::Texture
  • ~Transform() : vl::Transform
  • ~UIEventListener() : vl::UIEventListener
  • ~VirtualFile() : vl::VirtualFile
  • ~vlWXGLCanvas() : vlWX::vlWXGLCanvas
  • ~ZippedFile() : vl::ZippedFile
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- b -

  • b()
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • back() : vl::Collection< T >
  • backAmbient() : vl::Material
  • backDiffuse() : vl::Material
  • backEmission() : vl::Material
  • backFace() : vl::PolygonMode
  • backgroundColor() : vl::Text
  • backgroundEnabled() : vl::Text
  • backShininess() : vl::Material
  • backSpecular() : vl::Material
  • ballAndStickStyle() : vlMolecule::Molecule
  • begin() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • BezierPatch() : vl::BezierPatch
  • BezierSurface() : vl::BezierSurface
  • Billboard() : vl::Billboard
  • binary() : vl::PlyLoader
  • bindAttachment()
: vl::FBOTextureLayerAttachment
, vl::FBOAttachmentAbstract
, vl::FBOColorBufferAttachment
, vl::FBODepthBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::FBODepthStencilBufferAttachment
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
, vl::FBOTexture3DAttachment
  • bindAttribLocation() : vl::GLSLProgram
  • bindDrawBuffers() : vl::RenderTarget
  • bindFragDataLocation() : vl::GLSLProgram
  • bindFramebuffer()
: vl::FBORenderTarget
, vl::RenderTarget
  • bindManipulators() : vlut::Applet
  • bitsPerPixel()
: vl::Image
, vl::OpenGLContextFormat
  • BlendColor() : vl::BlendColor
  • blendColor() : vl::BlendColor
  • BlendEquation() : vl::BlendEquation
  • blendFrames() : vl::MorphingActor
  • BlendFunc() : vl::BlendFunc
  • blendingEnabled()
: vl::EnableSet
, vl::Shader
  • blendU() : vl::ObjTexture
  • blendV() : vl::ObjTexture
  • BlitFramebuffer() : vl::BlitFramebuffer
  • blue() : vl::ColorMask
  • blueBias() : vl::PixelTransfer
  • blueScale() : vl::PixelTransfer
  • bm() : vl::ObjTexture
  • boilingPoint() : vlMolecule::AtomInfo
  • bond() : vlMolecule::Molecule
  • Bond() : vlMolecule::Bond
  • bond() : vlMolecule::Molecule
  • bondCount() : vlMolecule::Molecule
  • bondDetail() : vlMolecule::Molecule
  • bonds() : vlMolecule::Molecule
  • bondType() : vlMolecule::Bond
  • bootstrap() : vlMolecule::RingExtractor
  • border()
: vl::Texture::SetupParams
, vl::Texture
  • borderColor()
: vl::Text
, vl::TexParameter
  • borderEnabled() : vl::Text
  • bottom() : vl::Rect< T >
  • bottomLeft()
: vl::RectF
, vl::RectI
, vlVolume::Volume
  • boundaryOnly() : vl::Tessellator
  • boundingBox()
: vl::Actor
, vl::Renderable
, vl::SceneManager
  • boundingRect() : vl::Text
  • boundingRectTransformed() : vl::Text
  • boundingSphere()
: vl::Actor
, vl::Renderable
, vl::SceneManager
  • boundsDirty()
: vl::SceneManager
, vl::Renderable
  • boundsUpdateTick() : vl::Renderable
  • box() : vlVolume::SlicedVolume
  • boxEffect() : vlVolume::VolumePlot
  • buffer() : vl::MemoryFile
  • Buffer() : vl::Buffer
  • buffer() : vl::MemoryFile
  • BufferedStream() : vl::BufferedStream< Element_Type, Chunk_Size >
  • bufferEmpty() : vl::BufferedStream< Element_Type, Chunk_Size >
  • bufferMask() : vl::BlitFramebuffer
  • bug() : vl::Log
  • byteAlignment() : vl::Image
  • byteCountGPU() : vl::GLBufferObject
  • bytesPerVector() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • bytesUsed()
: vl::ArrayAbstract
, vl::Buffer
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- c -

  • calculatedRadius() : vlMolecule::AtomInfo
  • callbacks() : vl::Sector
  • Camera() : vl::Camera
  • camera()
: vl::Rendering
, vl::TrackballManipulator
, vl::GhostCameraManipulator
, vl::Rendering
  • canLoad()
: vl::LoadWriterManager
, vl::ResourceLoadWriter
  • canWrite()
: vl::LoadWriterManager
, vl::ResourceLoadWriter
  • capacity() : vl::Collection< T >
  • CatmullRomInterpolator() : vl::CatmullRomInterpolator< T >
  • CatmullRomInterpolatorDouble() : vl::CatmullRomInterpolatorDouble
  • CatmullRomInterpolatorDVec2() : vl::CatmullRomInterpolatorDVec2
  • CatmullRomInterpolatorDVec3() : vl::CatmullRomInterpolatorDVec3
  • CatmullRomInterpolatorDVec4() : vl::CatmullRomInterpolatorDVec4
  • CatmullRomInterpolatorFloat() : vl::CatmullRomInterpolatorFloat
  • CatmullRomInterpolatorFVec2() : vl::CatmullRomInterpolatorFVec2
  • CatmullRomInterpolatorFVec3() : vl::CatmullRomInterpolatorFVec3
  • CatmullRomInterpolatorFVec4() : vl::CatmullRomInterpolatorFVec4
  • cc() : vl::ObjTexture
  • cellSize() : vlVolume::Volume
  • center()
: vl::AABB
, vl::Sphere
, vl::Viewport
  • checkConnectivity() : vl::PolygonSimplifier::Vertex
  • checkDrawBuffers() : vl::RenderTarget
  • checkFramebufferStatus() : vl::FBORenderTarget
  • checkTriangle() : vl::PolygonSimplifier::Triangle
  • checkTriangles() : vl::PolygonSimplifier::Vertex
  • child()
: vl::ActorKdTree
, vl::ActorTree
, vl::ActorTreeAbstract
, vl::ShaderNode
, vl::Transform
  • childCount() : vl::Transform
  • childN() : vl::ActorKdTree
  • childP() : vl::ActorKdTree
  • childrenCount()
: vl::ActorKdTree
, vl::ActorTree
, vl::ActorTreeAbstract
, vl::ShaderNode
  • chunk() : vl::Terrain
  • chunkCount() : vl::Terrain
  • chunks() : vl::Terrain
  • clamp() : vl::ObjTexture
  • classify() : vl::Plane
  • className()
: vl::GZipCodec
, vl::Image
, vl::Light
, vl::LoadWriterManager
, vl::LODEvaluator
, vl::Log
, vl::StandardLog
, vl::MD5CheckSum
, vl::MemoryDirectory
, vl::MemoryFile
, vl::Actor
, vl::MorphingCallback
, vl::MorphingActor
, vl::ActorKdTree
, vl::Object
, vl::OpenGLContextFormat
, vl::ActorTree
, vl::OpenGLContext
, vl::PixelLODEvaluator
, vl::ActorTreeAbstract
, vl::Plane
, vl::PolygonSimplifier
, vl::ArrayAbstract
, vl::Primitives
, vl::RayIntersection
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::RayIntersectionGeometry
, vl::RayIntersector
, vl::BezierPatch
, vl::ReadPixels
, vl::Rect< T >
, vl::BezierSurface
, vl::RectI
, vl::RectF
, vl::Billboard
, vl::Renderable
, vl::Renderer
, vl::BlitFramebuffer
, vl::Rendering
, vl::RenderingCallback
, vl::Buffer
, vl::RenderingTree
, vl::RenderQueue
, vl::BufferedStream< Element_Type, Chunk_Size >
, vl::RenderQueueSorter
, vl::RenderQueueSorterByShader
, vl::Camera
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterBasic
, vl::Clear
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorterOcclusion
, vl::ClipPlane
, vl::RenderQueueSorterAggressive
, vl::RenderState
, vl::Collection< T >
, vl::RenderTarget
, vl::RenderToken
, vl::CopyTexSubImage1D
, vl::ResourceDatabase
, vl::ResourceLoadWriter
, vl::CopyTexSubImage2D
, vl::SceneManager
, vl::SceneManagerActorKdTree
, vl::CopyTexSubImage3D
, vl::SceneManagerActorTree
, vl::SceneManagerBVH< T >
, vl::DepthSortCallback
, vl::Scissor
, vl::PixelTransfer
, vl::DiskDirectory
, vl::Hint
, vl::CullFace
, vl::DiskFile
, vl::FrontFace
, vl::DepthFunc
, vl::DistanceLODEvaluator
, vl::DepthMask
, vl::PolygonMode
, vl::VertexMapper
, vl::ShadeModel
, vl::BlendFunc
, vl::DoubleVertexRemover
, vl::BlendEquation
, vl::SampleCoverage
, vl::DrawArrays
, vl::AlphaFunc
, vl::Material
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::LightModel
, vl::Fog
, vl::DrawPixels
, vl::PolygonOffset
, vl::LogicOp
, vl::EdgeExtractor
, vl::DepthRange
, vl::LineWidth
, vl::EdgeRenderer
, vl::PointSize
, vl::PolygonStipple
, vl::EdgeUpdateCallback
, vl::LineStipple
, vl::PointParameter
, vl::ShaderSequence
, vl::StencilFunc
, vl::StencilOp
, vl::Effect
, vl::StencilMask
, vl::BlendColor
, vl::FileSystem
, vl::ColorMask
, vl::TextureMatrix
, vl::Glyph
, vl::TexEnv
, vl::TexGen
, vl::Font
, vl::TextureUnit
, vl::RenderStateSet
, vl::FontManager
, vl::EnableSet
, vl::Shader
, vl::FBOAttachmentAbstract
, vl::ShaderNode
, vl::Terrain
, vl::FBORenderbufferAttachment
, vl::Text
, vl::TextStream
, vl::FBOColorBufferAttachment
, vl::TexParameter
, vl::Texture
, vl::FBODepthBufferAttachment
, vl::Time
, vl::TrackballManipulator
, vl::FBOStencilBufferAttachment
, vl::Transform
, vl::TriangleStripGenerator
, vl::FBODepthStencilBufferAttachment
, vl::UIEventListener
, vl::Uniform
, vl::FBOTexture1DAttachment
, vl::UniformSet
, vl::VertexAttributeArray
, vl::FBOTexture2DAttachment
, vl::Viewport
, vl::VirtualDirectory
, vl::FBOTextureAttachment
, vl::VirtualFile
, vl::LoadWriter3DS
, vl::FBOTexture3DAttachment
, vl::LoadWriterAC3D
, vl::LoadWriterBMP
, vl::FBOTextureLayerAttachment
, vl::LoadWriterDAT
, vl::LoadWriterDDS
, vl::FBORenderTarget
, vl::LoadWriterDICOM
, vl::LoadWriterJPG
, vl::Frustum
, vl::LoadWriterMD2
, vl::LoadWriterOBJ
, vl::Geometry
, vl::ObjMaterial
, vl::ObjMesh
, vl::GeometryLoadCallback
, vl::LoadWriterPLY
, vl::LoadWriterPNG
, vl::GhostCameraManipulator
, vl::LoadWriterSTL
, vl::STLLoader
, vl::GLBufferObject
, vl::LoadWriterTGA
, vlVolume::VolumeInfo
, vl::LoadWriterTIFF
, vlVG::VectorGraphics
, vlVG::SceneManagerVectorGraphics
, vl::GLSLShader
, vl::ZippedDirectory
, vl::ZippedFileInfo
, vl::GLSLVertexShader
, vl::ZippedFile
, vlut::Applet
, vl::GLSLFragmentShader
, vl::GLSLGeometryShader
, vlVolume::Volume
, vl::GLSLProgram
  • clear()
: vl::Buffer
, vl::Collection< T >
, vl::Image
, vl::KeyValues
, vl::RenderQueue
, vl::String
, vlVG::VectorGraphics
  • Clear() : vl::Clear
  • clear() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • clearArrays() : vl::Geometry
  • clearCache() : vl::EdgeRenderer
  • clearColor()
: vl::Viewport
, vlVG::VectorGraphics
  • clearColorInt() : vl::Viewport
  • clearColorMode()
: vl::Clear
, vl::Viewport
  • clearColorUInt() : vl::Viewport
  • clearDepth() : vl::Viewport
  • clearDistanceRangeSet() : vl::DistanceLODEvaluator
  • clearFlags()
: vl::Rendering
, vl::Viewport
  • clearLocalBuffer() : vl::DrawElements< index_type, Tgltype, arr_type >
  • clearMipmaps() : vl::Image
  • clearPixelRangeSet() : vl::PixelLODEvaluator
  • clearStencil()
: vlVG::VectorGraphics
, vl::Viewport
  • clearTrianglesAndVertices() : vl::PolygonSimplifier
  • clip() : vl::AABB
  • ClipPlane() : vl::ClipPlane
  • clone()
: vl::ArrayAbstract
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::GZipCodec
, vl::MemoryDirectory
, vl::MemoryFile
, vl::Primitives
, vl::VirtualFile
, vl::DiskFile
, vl::ZippedFile
  • close()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::ZippedFile
, vl::VirtualFile
  • collapse() : vl::PolygonSimplifier
  • collapseCost() : vl::PolygonSimplifier::Vertex
  • collapsePosition() : vl::PolygonSimplifier::Vertex
  • collapseVertex() : vl::PolygonSimplifier::Vertex
  • Collection() : vl::Collection< T >
  • collectStatistics() : vl::Renderer
  • color()
: vl::Fog
, vl::TexEnv
, vl::Text
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
, vlVG::VectorGraphics
  • colorArray() : vl::Geometry
  • colorControl() : vl::LightModel
  • colorizePrimitives() : vl::Geometry
  • colorMask() : vlVG::VectorGraphics
  • ColorMask() : vl::ColorMask
  • colorMaterial() : vl::Material
  • colorMaterialEnabled() : vl::Material
  • colorMaterialFace() : vl::Material
  • colorPath() : vl::Extrusion
  • combineAlpha() : vl::TexEnv
  • combineRGB() : vl::TexEnv
  • compare() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::String
  • compareFunc() : vl::TexParameter
  • compareMode() : vl::TexParameter
  • compile() : vl::GLSLShader
  • compileDisplayList() : vl::Renderable
  • compileKdTree() : vl::ActorKdTree
  • compileStatus() : vl::GLSLShader
  • compressedSize()
: vl::ZippedFileInfo
, vl::GZipCodec
  • compression() : vl::LoadWriterPNG
  • compressionLevel() : vl::GZipCodec
  • compressionMethod() : vl::ZippedFileInfo
  • compressionRatio() : vl::GZipCodec
  • compute()
: vl::CRC32CheckSum
, vlVolume::VolumePlot
, vl::MD5CheckSum
  • computeAABB() : vl::ActorTreeAbstract
  • computeAdjacentVertices() : vl::PolygonSimplifier::Vertex
  • computeArea() : vl::PolygonSimplifier::Triangle
  • computeAtomAdjacency() : vlMolecule::Molecule
  • computeAverage() : vlVolume::Volume
  • computeBoundingBox() : vl::Sector , vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::ArrayAbstract
  • computeBoundingSphere() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • computeBounds()
: vl::Actor
, vl::Renderable
, vl::SceneManager
  • computeBounds_Implementation()
: vl::DrawPixels
, vl::Clear
, vl::Geometry
, vl::Renderable
, vl::Text
  • computeCollapseInfo() : vl::PolygonSimplifier
  • computeEdgePenalty() : vl::PolygonSimplifier::Vertex
  • computeEdges() : vlVolume::MarchingCubes
  • computeFrustumPlanes() : vl::Camera
  • computeMaximum() : vlVolume::Volume
  • computeMinimum() : vlVolume::Volume
  • computeNormal()
: vl::Portal
, vl::PolygonSimplifier::Triangle
  • computeNormals()
: vl::GeometryLoadCallback
, vl::Geometry
  • computePoint()
: vl::InterpolatorDouble
, vl::CatmullRomInterpolatorDVec3
, vl::LinearInterpolator< T >
, vl::InterpolatorDVec4
, vl::LinearInterpolatorFVec2
, vl::InterpolatorFloat
, vl::InterpolatorDVec2
, vl::LinearInterpolatorFloat
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorDouble
, vl::CatmullRomInterpolatorFVec2
, vl::InterpolatorFVec2
, vl::LinearInterpolatorFVec3
, vl::InterpolatorFVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolator< T >
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDouble
, vl::InterpolatorDVec3
, vl::InterpolatorFVec4
, vl::CatmullRomInterpolatorFVec4
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec2
  • computePortalNormals() : vl::SceneManagerPortals
  • computePotentialArea() : vl::PolygonSimplifier::Triangle
  • computePotentialNormal() : vl::PolygonSimplifier::Triangle
  • computeQErr() : vl::PolygonSimplifier::Triangle
  • computeRay() : vl::Camera
  • computeRayFrustum() : vl::Camera
  • computeStartingSector() : vl::SceneManagerPortals
  • computeVector() : vl::TrackballManipulator
  • computeWorldMatrix()
: vl::Billboard
, vl::Transform
  • computeWorldMatrixRecursive() : vl::Transform
  • confirmZCameraDistanceNeed()
: vl::RenderQueueSorterAggressive
, vl::RenderQueueSorterByRenderable
, vl::RenderQueueSorterStandard
, vl::RenderQueueSorter
, vl::RenderQueueSorterBasic
, vl::RenderQueueSorterByShader
, vl::RenderQueueSorterOcclusion
  • conjugate() : vl::quat
  • constantAttenuation() : vl::Light
  • contains() : vl::String
  • continueCRC32() : vl::CRC32CheckSum
  • continueDrawing() : vlVG::VectorGraphics
  • continuousUpdate() : vl::OpenGLContext
  • contours() : vl::Tessellator
  • contourVerts() : vl::Tessellator
  • contrast() : vl::Image
  • contrastHounsfield() : vl::Image
  • contrastHounsfieldAuto() : vl::Image
  • convertFormat() : vl::Image
  • convertPrimitivesToDrawArrays() : vl::Geometry
  • convertToDrawArrays() : vl::GeometryLoadCallback
  • convertType() : vl::Image
  • coordinate() : vlVolume::Volume
  • coordinates() : vlMolecule::Atom
  • copy() : vl::MemoryFile
  • copyPixels()
: vl::CopyTexSubImage
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage2D
, vl::BlitFramebuffer
, vl::CopyTexSubImage1D
  • copySubImage() : vl::Image
  • CopyTexSubImage() : vl::CopyTexSubImage
  • CopyTexSubImage1D() : vl::CopyTexSubImage1D
  • CopyTexSubImage2D() : vl::CopyTexSubImage2D
  • CopyTexSubImage3D() : vl::CopyTexSubImage3D
  • count()
: vl::ResourceDatabase
, vl::Uniform
, vl::String
, vl::DrawArrays
  • CountAndCapture() : vlMFC::MFCWindow
  • CountAndRelease() : vlMFC::MFCWindow
  • countType() : vl::PlyLoader::PlyScalarList
  • covalentRadius() : vlMolecule::AtomInfo
  • cpkColor() : vlMolecule::AtomInfo
  • crc32()
: vl::ZippedFileInfo
, vl::VirtualFile
  • crc32_init() : vl::CRC32CheckSum
  • CRC32CheckSum() : vl::CRC32CheckSum
  • creaseAngle()
: vl::EdgeExtractor
, vl::EdgeRenderer
  • create()
: vl::FBORenderTarget
, vl::FBORenderbufferAttachment
  • createCubemap() : vl::Image
  • createData() : vl::String
  • createFBORenderTarget() : vl::OpenGLContext
  • createGLBufferObject() : vl::GLBufferObject
  • createOcclusionQuery() : vl::Actor
  • createProgram() : vl::GLSLProgram
  • createShader() : vl::GLSLShader
  • createTexture() : vl::Texture
  • cube() : vlVolume::Volume
  • cull() : vl::Frustum
  • CullFace() : vl::CullFace
  • cullingEnabled()
: vl::SceneManager
, vl::Rendering
  • currentEffect() : vlVG::VectorGraphics
  • currentTime() : vl::Time
  • cycle() : vlMolecule::Molecule
  • cycles() : vlMolecule::Molecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- d -

  • data() : vl::VertexAttributeArray
  • dataIsDirty() : vlVolume::Volume
  • day() : vl::ZippedFileInfo
  • dayOfMonth() : vl::Time
  • dayOfWeek() : vl::Time
  • debug() : vl::Log
  • declareActor() : vl::EdgeRenderer
  • decReference() : vl::Object
  • deepCopy() : vl::Geometry
  • defaultLineColor() : vl::EdgeRenderer
  • deleteDisplayList() : vl::Renderable
  • deleteGLBufferObject() : vl::GLBufferObject
  • deleteOcclusionQuery() : vl::Actor
  • deletePixelBufferObject() : vl::DrawPixels::Pixels
  • deletePixelBufferObjects() : vl::DrawPixels
  • deleteProgram() : vl::GLSLProgram
  • deleteShader() : vl::GLSLShader
  • deleteVBOs()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
, vl::Primitives
, vl::Renderable
  • density() : vl::Fog
  • depth()
: vl::AABB
, vl::Image
, vl::Terrain
, vl::Texture
  • depthBias() : vl::PixelTransfer
  • depthBufferBits() : vl::OpenGLContextFormat
  • depthFirstVisit() : vlMolecule::RingExtractor
  • DepthFunc() : vl::DepthFunc
  • depthFunc() : vl::DepthFunc
  • DepthMask() : vl::DepthMask
  • depthMask() : vl::DepthMask
  • DepthRange() : vl::DepthRange
  • depthScale() : vl::PixelTransfer
  • DepthSortCallback() : vl::DepthSortCallback
  • depthSortMode()
: vl::RenderQueueSorterStandard
, vl::RenderQueueSorterAggressive
  • depthTextureMode() : vl::TexParameter
  • destroy()
: vl::FBOAttachmentAbstract
, vl::FBORenderbufferAttachment
, vl::FBORenderTarget
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWin32::Win32Window
, vlMFC::MFCWindow
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • destroyAllFBORenderTargets() : vl::OpenGLContext
  • destroyEvent()
: vl::UIEventListener
, vlut::Applet
  • destroyFBORenderTarget() : vl::OpenGLContext
  • destroyWindow()
: vlWin32::Win32Window
, vlMFC::MFCWindow
  • detachAllShaders() : vl::GLSLProgram
  • detachShader() : vl::GLSLProgram
  • detail() : vl::BezierSurface
  • detailRepetitionMode() : vl::Terrain
  • detailTexture() : vl::Terrain
  • detailTextureFormat() : vl::Terrain
  • detectEncoding() : vl::String
  • diffuse() : vl::Light
  • dimension()
: vl::Image
, vl::Texture::SetupParams
, vl::Texture
  • direction() : vl::Ray
  • directories() : vl::FileSystem
  • dirty() : vl::TexParameter
  • disable()
: vl::Shader
, vl::ClipPlane
, vl::Light
, vl::RenderState
, vl::Scissor
, vl::TextureUnit
, vl::EnableSet
  • disableAll()
: vl::EnableSet
, vl::Shader
  • discardOriginalNormals() : vl::GeometryLoadCallback
  • discardRemovedTriangles() : vl::PolygonSimplifier::Vertex
  • DiskDirectory() : vl::DiskDirectory
  • DiskFile() : vl::DiskFile
  • diskFile() : vl::DiskDirectory
  • DiskFile() : vl::DiskFile
  • diskSubDir() : vl::DiskDirectory
  • dispatchDestroyEvent() : vl::OpenGLContext
  • dispatchFileDroppedEvent() : vl::OpenGLContext
  • dispatchInitEvent() : vl::OpenGLContext
  • dispatchKeyPressEvent() : vl::OpenGLContext
  • dispatchKeyReleaseEvent() : vl::OpenGLContext
  • dispatchMouseDownEvent() : vl::OpenGLContext
  • dispatchMouseMoveEvent() : vl::OpenGLContext
  • dispatchMouseUpEvent() : vl::OpenGLContext
  • dispatchMouseWheelEvent() : vl::OpenGLContext
  • dispatchRenderingCallbacks() : vl::RenderingAbstract
  • dispatchResizeEvent() : vl::OpenGLContext
  • dispatchRunEvent() : vl::OpenGLContext
  • dispatchVisibilityEvent() : vl::OpenGLContext
  • displayList() : vl::Renderable
  • displayListDirty() : vl::Renderable
  • displayListEnabled() : vl::Renderable
  • distance()
: vl::Plane
, vl::RayIntersection
  • distanceAttenuation() : vl::PointParameter
  • DistanceLODEvaluator() : vl::DistanceLODEvaluator
  • distanceRange()
: vl::PixelLODEvaluator
, vl::DistanceLODEvaluator
  • distanceRangeCount()
: vl::DistanceLODEvaluator
, vl::PixelLODEvaluator
  • distanceRangeSet()
: vl::DistanceLODEvaluator
, vl::PixelLODEvaluator
  • dot() : vl::quat
  • doubleBuffer() : vl::OpenGLContextFormat
  • DoubleVertexRemover() : vl::DoubleVertexRemover
  • downloadGLBufferObject() : vl::GLBufferObject
  • downsample() : vlVolume::Volume
  • dpFail_Back() : vl::StencilOp
  • dpFail_Front() : vl::StencilOp
  • dpPass_Back() : vl::StencilOp
  • dpPass_Front() : vl::StencilOp
  • dragEnterEvent() : vlQt4::Qt4Widget
  • drawActor() : vlVG::VectorGraphics
  • drawActorCopy() : vlVG::VectorGraphics
  • DrawArrays() : vl::DrawArrays
  • DrawElements() : vl::DrawElements< index_type, Tgltype, arr_type >
  • drawEllipse() : vlVG::VectorGraphics
  • drawFramebuffer() : vl::BlitFramebuffer
  • drawLine() : vlVG::VectorGraphics
  • drawLineLoop() : vlVG::VectorGraphics
  • drawLines() : vlVG::VectorGraphics
  • drawLineStrip() : vlVG::VectorGraphics
  • DrawPixels() : vl::DrawPixels
  • drawPoint() : vlVG::VectorGraphics
  • drawPoints() : vlVG::VectorGraphics
  • drawQuad() : vlVG::VectorGraphics
  • draws() : vl::DrawPixels
  • drawText() : vlVG::VectorGraphics
  • dropEvent() : vlQt4::Qt4Widget
  • dstAlpha() : vl::BlendFunc
  • dstRect() : vl::BlitFramebuffer
  • dstRGB() : vl::BlendFunc
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- e -

  • e()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • Edge() : vl::EdgeExtractor::Edge
  • EdgeExtractor() : vl::EdgeExtractor
  • EdgeRenderer() : vl::EdgeRenderer
  • edges()
: vl::EdgeUpdateCallback
, vl::EdgeExtractor
, vl::EdgeUpdateCallback
  • EdgeUpdateCallback() : vl::EdgeUpdateCallback
  • effect()
: vl::Actor
, vlVolume::SlicedVolume
  • Effect() : vl::Effect
  • elapsed() : vl::Time
  • electronAffinity() : vlMolecule::AtomInfo
  • electronegativity() : vlMolecule::AtomInfo
  • elemCount() : vl::PlyLoader::PlyElement
  • elements() : vl::PlyLoader
  • empiricalRadius() : vlMolecule::AtomInfo
  • empty()
: vl::Collection< T >
, vl::Image
, vl::RenderQueue
, vl::String
, vl::Buffer
  • enable()
: vl::ClipPlane
, vl::Light
, vl::RenderState
, vl::Scissor
, vl::TextureUnit
, vl::EnableSet
, vl::Shader
  • enableMask()
: vl::Actor
, vl::Effect
, vl::RenderingAbstract
, vl::SceneManager
  • enables()
: vl::EnableSet
, vl::Shader
  • EnableSet() : vl::EnableSet
  • end() : vl::Array< vector_type, scalar_type, gl_size, gl_type > , vl::Fog
  • endDrawing() : vlVG::VectorGraphics
  • endOfFile() : vl::VirtualFile
  • endsWith() : vl::String
  • enlarge() : vl::AABB
  • envVars() : vl::VisualizationLibrary
  • equalize() : vl::Image
  • erase()
: vl::Collection< T >
, vl::KeyValues
  • eraseActor() : vl::ActorTreeAbstract
  • eraseAllAtoms() : vlMolecule::Molecule
  • eraseAllBonds() : vlMolecule::Molecule
  • eraseAllChildren()
: vl::ActorTree
, vl::Transform
  • eraseAllChildrenRecursive() : vl::Transform
  • eraseAllEventListeners() : vl::OpenGLContext
  • eraseAllFiles() : vl::MemoryDirectory
  • eraseAllRenderStates()
: vl::RenderStateSet
, vl::Shader
  • eraseAllUniforms()
: vl::UniformSet
, vl::Actor
, vl::Shader
  • eraseAt() : vl::Collection< T >
  • eraseAtom() : vlMolecule::Molecule
  • eraseBond() : vlMolecule::Molecule
  • eraseChild()
: vl::ActorTree
, vl::ShaderNode
, vl::Transform
  • eraseChildren()
: vl::Transform
, vl::ShaderNode
  • eraseEnable() : vl::ShaderNode
  • eraseRenderState()
: vl::RenderStateSet
, vl::Shader
, vl::ShaderNode
, vl::Shader
  • eraseUniform()
: vl::UniformSet
, vl::Actor
, vl::Shader
, vl::ShaderNode
, vl::UniformSet
  • eraseVertexAttributeByName() : vl::Geometry
  • error() : vl::Log
  • euronotation() : vl::Say
  • evaluate()
: vl::PolygonSimplifier::QErr
, vl::PixelLODEvaluator
, vl::DistanceLODEvaluator
, vl::LODEvaluator
  • evaluateFunction() : vlVolume::VolumePlot
  • evaluateLOD()
: vl::Rendering
, vl::Effect
, vl::Actor
  • eventListener() : vl::OpenGLContext
  • eventListenerCount() : vl::OpenGLContext
  • eventListeners() : vl::OpenGLContext
  • executeCallbacks() : vl::Sector
  • executeRenderingCallbacks() : vl::Actor
  • exists()
: vl::DiskFile
, vl::GZipCodec
, vl::DiskDirectory
, vl::VirtualFile
, vl::MemoryFile
, vl::ZippedFile
  • exStyle() : vlWin32::Win32Window
  • externalSector() : vl::SceneManagerPortals
  • extract()
: vl::ResourceDatabase
, vl::ZippedFile
  • extractEdges() : vl::EdgeExtractor
  • extractFileExtension() : vl::String
  • extractFileName() : vl::String
  • extractPath() : vl::String
  • extraFieldLength() : vl::ZippedFileInfo
  • extrude() : vl::Extrusion
  • Extrusion() : vl::Extrusion
  • eyePlaneQ() : vl::TexGen
  • eyePlaneR() : vl::TexGen
  • eyePlaneS() : vl::TexGen
  • eyePlaneT() : vl::TexGen
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- f -

  • face_type() : vl::ObjMesh
  • faceMode() : vl::CullFace
  • faceNormalIndex() : vl::ObjMesh
  • facePositionIndex() : vl::ObjMesh
  • faceTexCoordIndex() : vl::ObjMesh
  • factor()
: vl::PolygonOffset
, vl::LineStipple
  • fadeThresholdSize() : vl::PointParameter
  • farPlane() : vl::Camera
  • FBOAttachmentAbstract() : vl::FBOAttachmentAbstract
  • fboAttachments() : vl::FBORenderTarget
  • FBOColorBufferAttachment() : vl::FBOColorBufferAttachment
  • FBODepthBufferAttachment() : vl::FBODepthBufferAttachment
  • FBODepthStencilBufferAttachment() : vl::FBODepthStencilBufferAttachment
  • FBORenderbufferAttachment() : vl::FBORenderbufferAttachment
  • fboRenderTargets() : vl::FBOAttachmentAbstract
  • FBOStencilBufferAttachment() : vl::FBOStencilBufferAttachment
  • FBOTexture1DAttachment() : vl::FBOTexture1DAttachment
  • FBOTexture2DAttachment() : vl::FBOTexture2DAttachment
  • FBOTexture3DAttachment() : vl::FBOTexture3DAttachment
  • FBOTextureAttachment() : vl::FBOTextureAttachment
  • FBOTextureLayerAttachment() : vl::FBOTextureLayerAttachment
  • field() : vl::String
  • file()
: vl::DiskDirectory
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::ZippedDirectory
  • fileDroppedEvent() : vl::UIEventListener
  • fileExists() : vl::VirtualDirectory
  • fileNameLength() : vl::ZippedFileInfo
  • filePath() : vl::Font
  • fileSystem() : vl::VisualizationLibrary
  • FileSystem() : vl::FileSystem
  • fill() : vl::String
  • fillBottom() : vl::Extrusion
  • fillBuffer() : vl::BufferedStream< Element_Type, Chunk_Size >
  • fillEllipse() : vlVG::VectorGraphics
  • fillPolygon() : vlVG::VectorGraphics
  • fillQuad() : vlVG::VectorGraphics
  • fillQuads() : vlVG::VectorGraphics
  • fillQuadStrip() : vlVG::VectorGraphics
  • fillRenderQueue() : vl::Rendering
  • fillTop() : vl::Extrusion
  • fillTriangleFan() : vlVG::VectorGraphics
  • fillTriangles() : vlVG::VectorGraphics
  • fillTriangleStrip() : vlVG::VectorGraphics
  • fillUncompressedBuffer()
: vl::GZipCodec
, vl::ZippedFile
  • filterStrings() : vl::String
  • finalizeCRC32() : vl::CRC32CheckSum
  • find()
: vl::Collection< T >
, vl::String
  • findBackwards() : vl::String
  • findChild() : vl::ShaderNode
  • findLoader() : vl::LoadWriterManager
  • findVertexAttribute() : vl::Geometry
  • findWriter() : vl::LoadWriterManager
  • flipVertically() : vl::Image
  • Fog() : vl::Fog
  • fogCoordArray() : vl::Geometry
  • fogHint() : vl::Hint
  • followedTransform()
: vl::Camera
, vl::ClipPlane
, vl::Light
, vl::ClipPlane
  • followTransform()
: vl::Camera
, vl::Light
, vl::ClipPlane
  • font()
: vl::Glyph
, vl::Text
, vlVG::VectorGraphics
  • fontManager() : vl::VisualizationLibrary
  • fonts() : vl::FontManager
  • format()
: vl::Image
, vl::Say
, vl::Texture::SetupParams
, vl::Say
  • fov() : vl::Camera
  • fps() : vlut::Applet
  • fragDataLocationBinding() : vl::GLSLProgram
  • fragmentShader() : vl::Terrain
  • freeCombinedVertices() : vl::Tessellator
  • freeTypeLibrary() : vl::VisualizationLibrary
  • fromAscii() : vl::String
  • fromAxisAngle() : vl::quat
  • fromDouble() : vl::String
  • fromEulerXYZ() : vl::quat
  • fromEulerZYX() : vl::quat
  • fromInt() : vl::String
  • fromLatin1() : vl::String
  • fromLongLong() : vl::String
  • fromMatrix() : vl::quat
  • fromStdString() : vl::String
  • fromStdWString() : vl::String
  • fromUInt() : vl::String
  • fromULongLong() : vl::String
  • fromUTF16() : vl::String
  • fromUTF16BE() : vl::String
  • fromUTF16LE() : vl::String
  • fromUTF8() : vl::String
  • fromVectors() : vl::quat
  • frontAmbient() : vl::Material
  • frontDiffuse() : vl::Material
  • frontEmission() : vl::Material
  • frontFace() : vl::FrontFace
  • FrontFace() : vl::FrontFace
  • frontFace() : vl::PolygonMode
  • frontShininess() : vl::Material
  • frontSpecular() : vl::Material
  • frustum()
: vl::Camera
, vl::Matrix4< scalar_type >
, vl::RayIntersector
  • frustumStack() : vl::SceneManagerPortals
  • fullscreen()
: vl::OpenGLContext
, vl::OpenGLContextFormat
  • function_Back() : vl::StencilFunc
  • function_Front() : vl::StencilFunc
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- g -

  • g()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • generalPurposeFlag() : vl::ZippedFileInfo
  • generateAtomLabel() : vlMolecule::Molecule
  • generateAtomLabels() : vlMolecule::Molecule
  • generateEdgeGeometry() : vl::EdgeExtractor
  • generateMipmap() : vl::TexParameter
  • generateMipmapHint() : vl::Hint
  • generatePixelBufferObject() : vl::DrawPixels::Pixels
  • generatePixelBufferObjects() : vl::DrawPixels
  • generateRings() : vlMolecule::Molecule
  • generateTextureCoordinates() : vlVolume::SlicedVolume
  • genModeQ() : vl::TexGen
  • genModeR() : vl::TexGen
  • genModeS() : vl::TexGen
  • genModeT() : vl::TexGen
  • genRGBAVolume() : vlVolume::SlicedVolume
  • geometry() : vlVolume::SlicedVolume
  • Geometry() : vl::Geometry
  • geometry()
: vl::MorphingActor
, vl::RayIntersectionGeometry
, vl::Portal
, vlVolume::SlicedVolume
  • geometryInputType() : vl::GLSLProgram
  • GeometryLoadCallback() : vl::GeometryLoadCallback
  • geometryOutputType() : vl::GLSLProgram
  • geometryVerticesOut() : vl::GLSLProgram
  • get()
: vl::ref< T >
, vl::ResourceDatabase
  • get2x2() : vl::Matrix3< scalar_type >
  • get3x3() : vl::Matrix4< scalar_type >
  • getAlphaFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getAsFloat() : vl::PlyLoader::PlyScalar
  • getAsInt() : vl::PlyLoader::PlyScalar
  • getAsLookAt() : vl::Matrix4< scalar_type >
  • getAttribLocation() : vl::GLSLProgram
  • getBlendColor() : vl::Shader
  • getBlendEquation()
: vl::Shader
, vlVG::VectorGraphics
  • getBlendFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getClipPlane() : vl::Shader
  • getColor() : vl::PlyLoader::PlyElement
  • getColorMask() : vl::Shader
  • getComputedWorldMatrix() : vl::Transform
  • getCullFace() : vl::Shader
  • getDepthFunc() : vl::Shader
  • getDepthMask() : vl::Shader
  • getDepthRange() : vl::Shader
  • getEnableSet() : vl::Shader
  • getFocus()
: vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • getFog() : vl::Shader
  • getFrontFace() : vl::Shader
  • getGLSLProgram() : vl::Shader
  • getHint() : vl::Shader
  • getKeys() : vl::KeyValues
  • getLight() : vl::Shader
  • getLightModel() : vl::Shader
  • getLineStipple() : vl::Shader
  • getLineWidth() : vl::Shader
  • getLogicOp() : vl::Shader
  • getLowerCase() : vl::String
  • getMaterial() : vl::Shader
  • getNormal() : vl::PlyLoader::PlyElement
  • getNormalized() : vl::quat
  • getPixelTransfer() : vl::Shader
  • getPointParameter() : vl::Shader
  • getPointSize() : vl::Shader
  • getPolygonMode() : vl::Shader
  • getPolygonOffset() : vl::Shader
  • getPolygonStipple() : vl::Shader
  • getProcAddress() : vl::OpenGLContext
  • getRenderStateSet() : vl::Shader
  • getSampleCoverage() : vl::Shader
  • getScissorBox() : vl::Clear
  • getShadeModel() : vl::Shader
  • getStencilFunc()
: vl::Shader
, vlVG::VectorGraphics
  • getStencilMask() : vl::Shader
  • getStencilOp()
: vl::Shader
, vlVG::VectorGraphics
, vl::Shader
  • getT()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • getTexEnv() : vl::Shader
  • getTexGen() : vl::Shader
  • getTexParameter() : vl::Texture
  • getTextureMatrix() : vl::Shader
  • getTextureUnit() : vl::Shader
  • getTitleCase() : vl::String
  • getUniform()
: vl::GLSLProgram
, vl::Actor
, vl::GLSLProgram
, vl::Shader
, vl::Uniform
, vl::UniformSet
, vl::GLSLProgram
, vl::Uniform
  • getUniformfv() : vl::GLSLProgram
  • getUniformiv() : vl::GLSLProgram
  • getUniformLocation() : vl::GLSLProgram
  • getUniformSet() : vl::Shader
  • getUpperCase() : vl::String
  • getVertex() : vl::PlyLoader::PlyElement
  • getViewMatrixAsLookAt() : vl::Camera
  • getWindow() : vlWin32::Win32Window
  • getX()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • getY()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
  • getYXRotationAngles() : vl::Matrix4< scalar_type >
  • getZ() : vl::Matrix4< scalar_type >
  • ghostCamera() : vlut::Applet
  • GhostCameraManipulator() : vl::GhostCameraManipulator
  • GLBufferObject() : vl::GLBufferObject
  • glSize() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • GLSLFragmentShader() : vl::GLSLFragmentShader
  • GLSLGeometryShader() : vl::GLSLGeometryShader
  • GLSLProgram() : vl::GLSLProgram
  • glslProgram()
: vlVolume::SlicedVolume
, vl::RenderStateSet
, vl::Shader
, vl::RenderStateSet
, vl::Shader
, vlVolume::SlicedVolume
  • GLSLShader() : vl::GLSLShader
  • glslVertexBlendEnabled() : vl::MorphingActor
  • GLSLVertexShader() : vl::GLSLVertexShader
  • glType() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • glut_close_func() : vlGLUT::GLUTWindow
  • glut_display_func() : vlGLUT::GLUTWindow
  • glut_idle_func() : vlGLUT::GLUTWindow
  • glut_keyboard_func() : vlGLUT::GLUTWindow
  • glut_keyboard_up_func() : vlGLUT::GLUTWindow
  • glut_motion_func() : vlGLUT::GLUTWindow
  • glut_mouse_func() : vlGLUT::GLUTWindow
  • glut_mouse_wheel_func() : vlGLUT::GLUTWindow
  • glut_passive_motion_func() : vlGLUT::GLUTWindow
  • glut_reshape_func() : vlGLUT::GLUTWindow
  • glut_special_func() : vlGLUT::GLUTWindow
  • glut_special_up_func() : vlGLUT::GLUTWindow
  • glut_visibility_func() : vlGLUT::GLUTWindow
  • glut_wmclose_func() : vlGLUT::GLUTWindow
  • GLUTWindow() : vlGLUT::GLUTWindow
  • glyph() : vl::Font
  • Glyph() : vl::Glyph
  • glyphIndex() : vl::Glyph
  • gocAlphaFunc() : vl::Shader
  • gocBlendColor() : vl::Shader
  • gocBlendEquation() : vl::Shader
  • gocBlendFunc() : vl::Shader
  • gocClipPlane() : vl::Shader
  • gocColorMask() : vl::Shader
  • gocCullFace() : vl::Shader
  • gocDepthFunc() : vl::Shader
  • gocDepthMask() : vl::Shader
  • gocDepthRange() : vl::Shader
  • gocEnableSet() : vl::Shader
  • gocFog() : vl::Shader
  • gocFrontFace() : vl::Shader
  • gocGLSLProgram() : vl::Shader
  • gocHint() : vl::Shader
  • gocLight() : vl::Shader
  • gocLightModel() : vl::Shader
  • gocLineStipple() : vl::Shader
  • gocLineWidth() : vl::Shader
  • gocLogicOp() : vl::Shader
  • gocMaterial() : vl::Shader
  • gocPixelTransfer() : vl::Shader
  • gocPointParameter() : vl::Shader
  • gocPointSize() : vl::Shader
  • gocPolygonMode() : vl::Shader
  • gocPolygonOffset() : vl::Shader
  • gocPolygonStipple() : vl::Shader
  • gocRenderStateSet() : vl::Shader
  • gocSampleCoverage() : vl::Shader
  • gocShadeModel() : vl::Shader
  • gocStencilFunc() : vl::Shader
  • gocStencilMask() : vl::Shader
  • gocStencilOp() : vl::Shader
  • gocTexEnv() : vl::Shader
  • gocTexGen() : vl::Shader
  • gocTextureMatrix() : vl::Shader
  • gocTextureUnit() : vl::Shader
  • gocUniform()
: vl::Actor
, vl::UniformSet
, vl::GLSLProgram
, vl::Shader
  • gocUniformSet() : vl::Shader
  • gpuBuffer() : vl::ArrayAbstract
  • green() : vl::ColorMask
  • greenBias() : vl::PixelTransfer
  • greenScale() : vl::PixelTransfer
  • GZipCodec() : vl::GZipCodec
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- h -

  • handle()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::FBORenderTarget
, vl::Primitives
, vl::Texture
, vl::GLBufferObject
, vlGLUT::GLUTWindow
, vl::FBORenderbufferAttachment
, vl::GLSLShader
, vl::GLSLProgram
  • harvestNonLeafActors() : vl::ActorKdTree
  • has() : vl::KeyValues
  • hasMipmaps() : vl::Texture::SetupParams
  • hasMipMaps() : vl::Texture
  • hasPixelBufferObject() : vl::DrawPixels::Pixels
  • hasTexture() : vl::TextureUnit
  • hasVertex() : vl::PolygonSimplifier::Triangle
  • hdc() : vlWin32::Win32Context
  • height()
: vl::Viewport
, vl::AABB
, vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
, vl::OpenGLContext
, vl::ReadPixels
, vl::RenderTarget
, vl::Terrain
, vl::Texture
  • heightmapTexture() : vl::Terrain
  • heightmapTextureFormat() : vl::Terrain
  • hglrc() : vlWin32::Win32Context
  • hide()
: vl::OpenGLContext
, vlGLUT::GLUTWindow
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vlQt4::Qt4Widget
  • highQualityNormals() : vlVolume::MarchingCubes
  • Hint() : vl::Hint
  • hour()
: vl::ZippedFileInfo
, vl::Time
  • hwnd()
: vlWin32::Win32Context
, vlWin32::Win32Window
, vlMFC::MFCWindow
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- i -

  • id()
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • ignoreNextMouseMoveEvent() : vl::OpenGLContext
  • illum() : vl::ObjMaterial
  • image()
: vl::ReadPixels
, vl::Texture::SetupParams
, vlVG::VectorGraphics
, vl::DrawPixels::Pixels
, vlVG::VectorGraphics
  • Image() : vl::Image
  • image() : vl::DrawPixels::Pixels
  • Image() : vl::Image
  • imageBuffer() : vl::Image
  • imagePath() : vl::Texture::SetupParams
  • imfchan() : vl::ObjTexture
  • incidentBonds() : vlMolecule::Molecule
  • incidentTriangle() : vl::PolygonSimplifier::Vertex
  • incidentTrianglesCount() : vl::PolygonSimplifier::Vertex
  • includes() : vl::Sphere
  • incReference() : vl::Object
  • index()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
  • indexCount()
: vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
  • indexCountGPU() : vl::DrawElements< index_type, Tgltype, arr_type >
  • indexOffset() : vl::PixelTransfer
  • indexShift() : vl::PixelTransfer
  • indices() : vl::DrawElements< index_type, Tgltype, arr_type >
  • info() : vl::Log
  • infoLog()
: vl::GLSLShader
, vl::GLSLProgram
  • inherit() : vl::ShaderNode
  • init()
: vl::MorphingActor
, vl::SayArg
, vl::Terrain
, vl::VisualizationLibrary
, vl::ZippedDirectory
, vlWin32::Win32Context
  • initEnvVars() : vl::VisualizationLibrary
  • initEvent()
: vl::UIEventListener
, vlut::Applet
  • initExtensions() : vl::OpenGLContext
  • initFloat() : vl::Uniform
  • initFrom() : vl::MorphingActor
  • initGLUTWindow() : vlGLUT::GLUTWindow
  • initialize()
: vl::SceneManagerPortals
, vlut::Applet
  • initialized() : vl::VisualizationLibrary
  • initializeGL() : vlQt4::Qt4Widget
  • initInt() : vl::Uniform
  • initKeymap() : vlGLUT::GLUTWindow
  • initMFCWindow() : vlMFC::MFCWindow
  • initQt4Widget() : vlQt4::Qt4Widget
  • initResources()
: vl::Shader
, vl::GLSLProgram
, vl::RenderState
, vl::TextureUnit
  • initSDLWindow() : vlSDL::SDLWindow
  • initStorage() : vl::FBORenderbufferAttachment
  • initUInt() : vl::Uniform
  • initWin32Window() : vlWin32::Win32Window
  • inputFile() : vl::BufferedStream< Element_Type, Chunk_Size >
  • insert()
: vl::Collection< T >
, vl::String
  • insertActor() : vl::ActorKdTree
  • instances() : vl::Primitives
  • interlineSpacing() : vl::Text
  • internalBindAttachment() : vl::FBORenderbufferAttachment
  • internalFormat() : vl::Texture
  • internalType()
: vl::FBORenderbufferAttachment
, vl::FBOColorBufferAttachment
, vl::FBODepthBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::FBODepthStencilBufferAttachment
  • interpolator()
: vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec3
, vl::CatmullRomInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • Interpolator() : vl::Interpolator
  • intersect() : vl::RayIntersector
  • intersected() : vl::Rect< T >
  • intersectGeometry() : vl::RayIntersector
  • intersectionPoint() : vl::RayIntersection
  • intersections() : vl::RayIntersector
  • intersectPolygon() : vl::RayIntersector
  • intersectQuad() : vl::RayIntersector
  • intersects() : vl::AABB
  • intersectTriangle() : vl::RayIntersector
  • invalidateCache() : vl::DepthSortCallback
  • inverse()
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::quat
  • inverseViewMatrix() : vl::Camera
  • invert()
: vl::Matrix3< scalar_type >
, vl::SampleCoverage
, vl::Matrix4< scalar_type >
, vl::Matrix2< scalar_type >
  • isAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • isAtomAdjacent() : vlMolecule::Atom
  • isCompressedFormat()
: vl::Texture
, vl::Image
  • isCorrupted() : vl::ZippedDirectory
  • isCrease() : vl::EdgeExtractor::Edge
  • isCubemap() : vl::Image
  • isEnabled()
: vl::SceneManager
, vl::UIEventListener
, vl::RenderingAbstract
, vl::Shader
, vl::EnableSet
, vl::Primitives
  • isExtensionSupported() : vl::OpenGLContext
  • isIdentity()
: vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
  • isIncidentTriangle() : vl::PolygonSimplifier::Vertex
  • isInside() : vl::AABB
  • isKeyPressed() : vl::OpenGLContext
  • isNull()
: vl::Matrix4< scalar_type >
, vl::Vector2< scalar_type >
, vl::AABB
, vl::Vector3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Rect< T >
, vl::Vector4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Sphere
  • isOccludee() : vl::Actor
  • isOpen()
: vl::VirtualFile
, vl::Portal
, vl::MemoryFile
, vl::ZippedFile
, vl::GZipCodec
, vl::DiskFile
  • isosurfaceActor() : vlVolume::VolumePlot
  • isosurfaceEffect() : vlVolume::VolumePlot
  • isosurfaceGeometry() : vlVolume::VolumePlot
  • isOutside() : vl::Plane
  • isPoint()
: vl::AABB
, vl::Sphere
, vl::Rect< T >
  • isPointInside() : vl::Viewport
  • isProtected() : vl::PolygonSimplifier::Vertex
  • isStarted() : vl::Time
  • isValid()
: vl::Image
, vl::Texture
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- p -

  • p()
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • paintGL() : vlQt4::Qt4Widget
  • parent()
: vl::ShaderNode
, vl::Transform
, vl::ActorTreeAbstract
  • parentDir() : vl::DiskFile
  • parse() : vl::Say
  • parse3DS() : vl::A3DSLoader
  • parseLine() : vl::ObjTexture
  • patches() : vl::BezierSurface
  • path()
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::VirtualDirectory
, vl::VirtualFile
, vl::ObjTexture
, vl::ZippedFileInfo
  • pattern() : vl::LineStipple
  • peek() : vl::VirtualFile
  • perspective() : vl::Matrix4< scalar_type >
  • perspectiveCorrectionHint() : vl::Hint
  • pipeline() : vl::Say
  • pitch() : vl::Image
  • pivot() : vl::TrackballManipulator
  • PixelLODEvaluator() : vl::PixelLODEvaluator
  • Pixels() : vl::DrawPixels::Pixels
  • pixels() : vl::Image
  • pixelsXN() : vl::Image
  • pixelsXP() : vl::Image
  • pixelsYN() : vl::Image
  • pixelsYP() : vl::Image
  • pixelsZN() : vl::Image
  • pixelsZP() : vl::Image
  • pixelsZSlice() : vl::Image
  • PixelTransfer() : vl::PixelTransfer
  • Plane() : vl::Plane
  • plane()
: vl::ActorKdTree
, vl::ClipPlane
, vl::Frustum
  • planeIndex() : vl::ClipPlane
  • planes() : vl::Frustum
  • platformSlash() : vl::String
  • plotTransform() : vlVolume::VolumePlot
  • PlyElement() : vl::PlyLoader::PlyElement
  • PlyLoader() : vl::PlyLoader
  • PlyScalar() : vl::PlyLoader::PlyScalar
  • PlyScalarList() : vl::PlyLoader::PlyScalarList
  • pointCount()
: vl::Primitives
, vl::Renderable
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Geometry
  • PointParameter() : vl::PointParameter
  • points() : vl::BezierPatch
  • PointSize() : vl::PointSize
  • pointSize()
: vl::PointSize
, vlVG::VectorGraphics
  • pointSmoothHint() : vl::Hint
  • pointSmoothing() : vlVG::VectorGraphics
  • pointSpriteCoordReplace() : vl::TexEnv
  • PolygonMode() : vl::PolygonMode
  • PolygonOffset() : vl::PolygonOffset
  • polygonOffsetFactor() : vl::EdgeRenderer
  • polygonOffsetUnits() : vl::EdgeRenderer
  • PolygonSimplifier() : vl::PolygonSimplifier
  • polygonSmoohtHint() : vl::Hint
  • polygonSmoothing() : vlVG::VectorGraphics
  • polygonStipple() : vlVG::VectorGraphics
  • PolygonStipple() : vl::PolygonStipple
  • pop_back() : vl::Collection< T >
  • popMatrix() : vlVG::VectorGraphics
  • popScissor() : vlVG::VectorGraphics
  • popState() : vlVG::VectorGraphics
  • Portal() : vl::Portal
  • portals() : vl::Sector
  • position()
: vlWin32::Win32Context
, vl::Billboard
, vl::DrawPixels::Pixels
, vl::GhostCameraManipulator
, vl::Light
, vl::OpenGLContext
, vl::PolygonSimplifier::Vertex
, vl::VirtualFile
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlGLUT::GLUTWindow
  • position_Implementation()
: vl::MemoryFile
, vl::DiskFile
, vl::GZipCodec
, vl::VirtualFile
, vl::ZippedFile
  • positionPath() : vl::Extrusion
  • postColorMatrixAlphaBias() : vl::PixelTransfer
  • postColorMatrixAlphaScale() : vl::PixelTransfer
  • postColorMatrixBlueBias() : vl::PixelTransfer
  • postColorMatrixBlueScale() : vl::PixelTransfer
  • postColorMatrixGreenBias() : vl::PixelTransfer
  • postColorMatrixGreenScale() : vl::PixelTransfer
  • postColorMatrixRedBias() : vl::PixelTransfer
  • postColorMatrixRedScale() : vl::PixelTransfer
  • postConvolutionAlphaBias() : vl::PixelTransfer
  • postConvolutionAlphaScale() : vl::PixelTransfer
  • postConvolutionBlueBias() : vl::PixelTransfer
  • postConvolutionBlueScale() : vl::PixelTransfer
  • postConvolutionGreenBias() : vl::PixelTransfer
  • postConvolutionGreenScale() : vl::PixelTransfer
  • postConvolutionRedBias() : vl::PixelTransfer
  • postConvolutionRedScale() : vl::PixelTransfer
  • prepareActors() : vl::ActorTreeAbstract
  • prepareAtomInsert() : vlMolecule::Molecule
  • prepareBondInsert() : vlMolecule::Molecule
  • prepareForRendering() : vlMolecule::Molecule
  • prepareToReconnect()
: vl::UIEventListener
, vl::GhostCameraManipulator
, vl::TrackballManipulator
  • prepend() : vl::String
  • primitiveIndex() : vl::RayIntersectionGeometry
  • primitives()
: vl::Geometry
, vl::RayIntersectionGeometry
, vl::Geometry
  • Primitives() : vl::Primitives
  • primitiveType()
: vl::Primitives
, vl::DrawElements< index_type, Tgltype, arr_type >
  • print()
: vl::ObjTexture
, vl::Log
, vl::Image
, vl::Log
, vl::KeyValues
  • printFormat() : vl::Image
  • printFramebufferError() : vl::FBORenderTarget
  • printImplementation()
: vl::Log
, vl::StandardLog
  • printType() : vl::Image
  • processCube() : vlVolume::MarchingCubes
  • project() : vl::Camera
  • projectionMatrix() : vl::Camera
  • properties() : vl::PlyLoader::PlyElement
  • ptr()
: vl::Matrix4< scalar_type >
, vl::String
, vl::MemoryFile
, vl::Matrix3< scalar_type >
, vl::Vector3< scalar_type >
, vl::ArrayAbstract
, vl::Vector3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Vector2< scalar_type >
, vl::ArrayAbstract
, vl::Vector4< scalar_type >
, vl::Buffer
, vl::Vector2< scalar_type >
, vl::Buffer
, vl::String
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Vector4< scalar_type >
  • pureInteger() : vl::VertexAttributeArray
  • push_back() : vl::Collection< T >
  • pushMatrix() : vlVG::VectorGraphics
  • pushScissor() : vlVG::VectorGraphics
  • pushState() : vlVG::VectorGraphics
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- q -

  • q() : vl::Vector4< scalar_type >
  • QErr() : vl::PolygonSimplifier::QErr
  • qerr() : vl::PolygonSimplifier::Vertex
  • Qt4Widget() : vlQt4::Qt4Widget
  • quadraticAttenuation() : vl::Light
  • quality() : vl::LoadWriterJPG
  • quat() : vl::quat
  • quick() : vl::PolygonSimplifier
  • quitApplication()
: vlQt4::Qt4Widget
, vlWin32::Win32Context
, vlWX::vlWXGLCanvas
, vl::OpenGLContext
, vlSDL::SDLWindow
, vlGLUT::GLUTWindow
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:07 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- r -

  • r()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • radius()
: vlMolecule::Atom
, vlMolecule::Bond
, vl::Sphere
  • rank() : vl::UIEventListener
  • rasmolColor() : vlMolecule::AtomInfo
  • rawboundingRect() : vl::Text
  • ray() : vl::RayIntersector
  • RayIntersection() : vl::RayIntersection
  • RayIntersectionGeometry() : vl::RayIntersectionGeometry
  • RayIntersector() : vl::RayIntersector
  • read()
: vl::VirtualFile
, vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
, vl::PlyLoader::PlyElement
  • read0x3D3D() : vl::A3DSLoader
  • read0x4000() : vl::A3DSLoader
  • read0x4100() : vl::A3DSLoader
  • read0xAFFF() : vl::A3DSLoader
  • read_Implementation()
: vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
, vl::DiskFile
, vl::GZipCodec
  • readBuffer()
: vl::CopyTexSubImage
, vl::ReadPixels
  • readChunk() : vl::A3DSLoader
  • readColByte3() : vl::A3DSLoader
  • readColChunk() : vl::A3DSLoader
  • readColFloat3() : vl::A3DSLoader
  • readDouble()
: vl::TextStream
, vl::VirtualFile
  • readElements() : vl::PlyLoader
  • readFloat() : vl::VirtualFile
  • readFloatPercent() : vl::A3DSLoader
  • readFramebuffer() : vl::BlitFramebuffer
  • readHeader() : vl::PlyLoader
  • readInt() : vl::TextStream
  • readLine()
: vl::TextStream
, vl::A3DSLoader
  • readLineCR() : vl::TextStream
  • readLineLF() : vl::TextStream
  • readMapChunk() : vl::A3DSLoader
  • readPercentChunk() : vl::A3DSLoader
  • ReadPixels() : vl::ReadPixels
  • readPixels() : vl::Image
  • readQuotedString() : vl::TextStream
  • readSByte() : vl::VirtualFile
  • readSInt16() : vl::VirtualFile
  • readSInt32() : vl::VirtualFile
  • readSInt64() : vl::VirtualFile
  • readStdString() : vl::TextStream
  • readString() : vl::TextStream
  • readToken() : vl::BufferedStream< Element_Type, Chunk_Size >
  • readUByte() : vl::VirtualFile
  • readUInt16() : vl::VirtualFile
  • readUInt32() : vl::VirtualFile
  • readUInt64() : vl::VirtualFile
  • readVec3() : vl::A3DSLoader
  • readWordPercent() : vl::A3DSLoader
  • Rect() : vl::Rect< T >
  • rect() : vl::Viewport
  • RectF() : vl::RectF
  • RectI() : vl::RectI
  • red() : vl::ColorMask
  • redBias() : vl::PixelTransfer
  • redScale() : vl::PixelTransfer
  • ref() : vl::ref< T >
  • referenceCount() : vl::Object
  • reflect() : vl::CRC32CheckSum
  • refValue() : vl::AlphaFunc
  • refValue_Back() : vl::StencilFunc
  • refValue_Front() : vl::StencilFunc
  • regenerate() : vl::VertexMapper
  • regenerateVertices() : vl::Geometry
  • registerLoadWriter()
: vl::LoadWriterManager
, vl::LoadWriterOBJ
  • releaseAllFonts() : vl::FontManager
  • releaseFont() : vl::FontManager
  • releaseFreeTypeData() : vl::Font
  • releaseImages() : vl::DrawPixels
  • remove() : vl::String
  • removeAdjacentVertex() : vl::PolygonSimplifier::Vertex
  • removeAfterCall() : vl::RenderingCallback
  • removeAllAttachments() : vl::FBORenderTarget
  • removeAttachment() : vl::FBORenderTarget
  • removed()
: vl::PolygonSimplifier::Triangle
, vl::PolygonSimplifier::Vertex
  • removeDoubles()
: vlMolecule::RingExtractor
, vl::DoubleVertexRemover
, vl::GeometryLoadCallback
, vl::PolygonSimplifier
  • removeEventListener() : vl::OpenGLContext
  • removeFile() : vl::MemoryDirectory
  • removeIncidentTriangle() : vl::PolygonSimplifier::Vertex
  • removeOrder() : vl::PolygonSimplifier::Vertex
  • removeScissor() : vlVG::VectorGraphics
  • render()
: vl::Clear
, vl::DrawArrays
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::DrawPixels
, vl::EdgeRenderer
, vl::Geometry
, vl::Primitives
, vl::Renderable
, vl::Renderer
, vl::Rendering
, vl::RenderingAbstract
, vl::RenderingTree
, vl::Text
  • Renderable() : vl::Renderable
  • renderBackground() : vl::Text
  • renderBlock() : vl::Actor
  • renderBorder() : vl::Text
  • renderBuffers() : vl::RenderTarget
  • renderbufferStorageReady() : vl::FBORenderbufferAttachment
  • renderedLinesCount() : vl::Renderer
  • renderedPointsCount() : vl::Renderer
  • renderedRenderablesCount() : vl::Renderer
  • renderedTrianglesCount() : vl::Renderer
  • renderer() : vl::Rendering
  • Renderer() : vl::Renderer
  • renderer() : vl::Rendering
  • Rendering() : vl::Rendering
  • rendering() : vl::VisualizationLibrary
  • RenderingAbstract() : vl::RenderingAbstract
  • RenderingCallback() : vl::RenderingCallback
  • renderingCallback()
: vl::BlitFramebuffer
, vl::ReadPixels
, vl::RenderingCallback
, vl::CopyTexSubImage
  • renderingCallbacks()
: vl::Actor
, vl::RenderingAbstract
, vl::Actor
  • RenderingTree() : vl::RenderingTree
  • renderLines() : vl::EdgeRenderer
  • renderPortal() : vl::SceneManagerPortals
  • renderQueue() : vl::Rendering
  • RenderQueue() : vl::RenderQueue
  • renderQueueSorter() : vl::Rendering
  • RenderQueueSorter() : vl::RenderQueueSorter
  • RenderQueueSorterAggressive() : vl::RenderQueueSorterAggressive
  • RenderQueueSorterBasic() : vl::RenderQueueSorterBasic
  • RenderQueueSorterByRenderable() : vl::RenderQueueSorterByRenderable
  • RenderQueueSorterByShader() : vl::RenderQueueSorterByShader
  • RenderQueueSorterOcclusion() : vl::RenderQueueSorterOcclusion
  • RenderQueueSorterStandard() : vl::RenderQueueSorterStandard
  • renderRank()
: vl::Actor
, vl::Effect
  • renderSolids() : vl::EdgeRenderer
  • renderState()
: vl::RenderStateSet
, vl::Shader
, vl::RenderStateSet
  • RenderState() : vl::RenderState
  • renderStates()
: vl::RenderStateSet
, vl::Shader
  • RenderStateSet() : vl::RenderStateSet
  • renderTarget() : vl::Rendering
  • RenderTarget() : vl::RenderTarget
  • renderTarget() : vl::OpenGLContext
  • renderText() : vl::Text
  • RenderToken() : vl::RenderToken
  • replace() : vl::String
  • replaceVertex() : vl::PolygonSimplifier::Triangle
  • requiredMemory() : vl::Image
  • requiredMemory1D() : vl::Image
  • requiredMemory2D() : vl::Image
  • requiredMemory3D() : vl::Image
  • requiredMemoryCubemap() : vl::Image
  • reserve() : vl::Collection< T >
  • reset()
: vl::Image
, vlMolecule::Molecule
, vl::ZippedDirectory
, vlVolume::MarchingCubes
, vl::EdgeExtractor
, vl::Shader
  • resetEnables() : vl::Renderer
  • resetGLSLBindings() : vl::MorphingActor
  • resetMatrix()
: vl::Text
, vlVG::VectorGraphics
  • resetRenderStates() : vl::Renderer
  • resetStates() : vl::Rendering
  • resetStream()
: vl::ZippedFile
, vl::GZipCodec
  • resize()
: vl::String
, vl::Buffer
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::BezierPatch
, vl::Collection< T >
  • resizeEvent()
: vlut::Applet
, vl::UIEventListener
  • resizeGL() : vlQt4::Qt4Widget
  • ResourceLoadWriter() : vl::ResourceLoadWriter
  • resources() : vl::ResourceDatabase
  • reverse() : vl::String
  • rg() : vl::Vector4< scalar_type >
  • rgb() : vl::Vector4< scalar_type >
  • rgbaBits() : vl::OpenGLContextFormat
  • rgbScale() : vl::TexEnv
  • right()
: vl::RectF
, vl::String
, vl::RectI
, vl::Rect< T >
  • RingExtractor() : vlMolecule::RingExtractor
  • ringOffset() : vlMolecule::Molecule
  • rotate()
: vl::Matrix4< scalar_type >
, vlVG::VectorGraphics
, vl::Transform
, vl::Matrix4< scalar_type >
, vl::Text
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Transform
  • rotateXYZ() : vl::Matrix4< scalar_type >
  • rotateZYX() : vl::Matrix4< scalar_type >
  • rotation()
: vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • rotationButton() : vl::TrackballManipulator
  • rotationPath() : vl::Extrusion
  • rotationSpeed()
: vl::GhostCameraManipulator
, vl::TrackballManipulator
  • rotationXYZ() : vl::Matrix4< scalar_type >
  • rotationZYX() : vl::Matrix4< scalar_type >
  • run()
: vlVolume::MarchingCubes
, vlut::Applet
, vlMolecule::RingExtractor
  • runEvent()
: vl::UIEventListener
, vlut::Applet
, vl::GhostCameraManipulator
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- s -

  • s()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • s0() : vl::Glyph
  • s1() : vl::Glyph
  • s_UVW() : vl::ObjTexture
  • sample() : vl::Image
  • SampleCoverage() : vl::SampleCoverage
  • sampleLinear() : vl::Image
  • sampleNearest() : vlVolume::Volume
  • samples() : vl::FBORenderbufferAttachment
  • sampleSmooth() : vlVolume::Volume
  • samplingResolution() : vlVolume::VolumePlot
  • savePath() : vl::ReadPixels
  • Say() : vl::Say
  • SayArg() : vl::SayArg
  • scalarCount() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • scalarCountGPU() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • scalars() : vl::PlyLoader::PlyScalarList
  • scalarType()
: vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
  • scale()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Transform
, vlVG::VectorGraphics
  • scaling()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • scalingPath() : vl::Extrusion
  • sceneBoundingSphere() : vl::Camera
  • SceneManager() : vl::SceneManager
  • sceneManager() : vlut::Applet
  • SceneManagerActorKdTree() : vl::SceneManagerActorKdTree
  • SceneManagerActorTree() : vl::SceneManagerActorTree
  • SceneManagerPortals() : vl::SceneManagerPortals
  • sceneManagers() : vl::Rendering
  • SceneManagerVectorGraphics() : vlVG::SceneManagerVectorGraphics
  • scheduleRelinking() : vl::GLSLProgram
  • Scissor() : vl::Scissor
  • scissor()
: vl::Actor
, vl::Shader
, vlVG::VectorGraphics
  • scissorRect() : vl::Scissor
  • scissorStack() : vlVG::VectorGraphics
  • sdlSurface() : vlSDL::SDLWindow
  • SDLWindow() : vlSDL::SDLWindow
  • second()
: vl::Time
, vl::ZippedFileInfo
  • secondaryColorArray() : vl::Geometry
  • Sector() : vl::Sector
  • sectors() : vl::SceneManagerPortals
  • seek() : vl::BufferedStream< Element_Type, Chunk_Size >
  • seekCur() : vl::VirtualFile
  • seekEnd() : vl::VirtualFile
  • seekSet() : vl::VirtualFile
  • seekSet_Implementation()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • set()
: vl::Collection< T >
, vl::KeyValues
, vl::CullFace
, vl::FrontFace
, vl::DepthFunc
, vl::DepthMask
, vl::PolygonMode
, vl::ShadeModel
, vl::BlendFunc
, vl::BlendEquation
, vl::SampleCoverage
, vl::AlphaFunc
, vl::Fog
, vl::PolygonOffset
, vl::LogicOp
, vl::DepthRange
, vl::LineWidth
, vl::PointSize
, vl::PolygonStipple
, vl::LineStipple
, vl::PointParameter
, vl::StencilFunc
, vl::StencilOp
, vl::StencilMask
, vl::BlendColor
, vl::ColorMask
, vl::Viewport
  • set2x2() : vl::Matrix3< scalar_type >
  • set3x3() : vl::Matrix4< scalar_type >
  • setAccumRGBABits() : vl::OpenGLContextFormat
  • setActive() : vl::Camera
  • setActor() : vl::RayIntersection
  • setActorAnimationEnabled() : vl::Rendering
  • setActorDirty() : vl::EdgeRenderer
  • setActorRenderRankStart() : vlVG::SceneManagerVectorGraphics
  • setAdvance() : vl::Glyph
  • setAlign() : vl::DrawPixels::Pixels
  • setAlignment() : vl::Text
  • setAlpha() : vl::ColorMask
  • setAlphaBias() : vl::PixelTransfer
  • setAlphaFunc() : vlVG::VectorGraphics
  • setAlphaScale()
: vl::PixelTransfer
, vl::TexEnv
  • setAlwaysIdentityWorldMatrix() : vl::Transform
  • setAmbient()
: vl::Light
, vl::Material
  • setAmbientColor() : vl::LightModel
  • setAnimation() : vl::MorphingActor
  • setAnisotropy() : vl::TexParameter
  • setAromaticBondsColor() : vlMolecule::Molecule
  • setAromaticRingColor() : vlMolecule::Molecule
  • setAtom1() : vlMolecule::Bond
  • setAtom2() : vlMolecule::Bond
  • setAtomColors() : vlMolecule::Molecule
  • setAtomDetail() : vlMolecule::Molecule
  • setAtomName() : vlMolecule::Atom
  • setAtomRadii() : vlMolecule::Molecule
  • setAtomType() : vlMolecule::Atom
  • setAtomTypeVisible() : vlMolecule::Molecule
  • setAttribIndex() : vl::VertexAttributeArray
  • setAutomaticDelete() : vl::Object
  • setAutomaticResourceInit() : vl::Rendering
  • setAxis() : vl::Billboard
  • setBackAmbient() : vl::Material
  • setBackDiffuse() : vl::Material
  • setBackEmission() : vl::Material
  • setBackFace() : vl::PolygonMode
  • setBackFlatColor() : vl::Material
  • setBackgroundColor() : vl::Text
  • setBackgroundEnabled() : vl::Text
  • setBackShininess() : vl::Material
  • setBackSpecular() : vl::Material
  • setBackTransparency() : vl::Material
  • setBlendEquation() : vlVG::VectorGraphics
  • setBlendFunc() : vlVG::VectorGraphics
  • setBlendU() : vl::ObjTexture
  • setBlendV() : vl::ObjTexture
  • setBlue() : vl::ColorMask
  • setBlueBias() : vl::PixelTransfer
  • setBlueScale() : vl::PixelTransfer
  • setBM() : vl::ObjTexture
  • setBondDetail() : vlMolecule::Molecule
  • setBondRadii() : vlMolecule::Molecule
  • setBondType() : vlMolecule::Bond
  • setBorder()
: vl::Texture::SetupParams
, vl::Texture
  • setBorderColor()
: vl::Text
, vl::TexParameter
  • setBorderEnabled() : vl::Text
  • setBoundaryOnly() : vl::Tessellator
  • setBoundingBox()
: vl::Renderable
, vl::SceneManager
  • setBoundingSphere()
: vl::Renderable
, vl::SceneManager
  • setBoundsDirty()
: vl::Renderable
, vl::SceneManager
  • setBox() : vlVolume::SlicedVolume
  • setBuffer() : vl::MemoryFile
  • setBufferData() : vl::GLBufferObject
  • setBufferMask() : vl::BlitFramebuffer
  • setBufferSubData() : vl::GLBufferObject
  • setByteAlignment() : vl::Image
  • setCalculatedAtomRadii() : vlMolecule::Molecule
  • setCamera()
: vl::GhostCameraManipulator
, vl::Rendering
, vl::TrackballManipulator
  • setCC() : vl::ObjTexture
  • setCenter() : vl::Sphere
  • setChild()
: vl::ActorTree
, vl::Transform
  • setClamp() : vl::ObjTexture
  • setClearColor() : vl::Viewport
  • setClearColorBuffer() : vl::Clear
  • setClearColorInt() : vl::Viewport
  • setClearColorMode()
: vl::Clear
, vl::Viewport
  • setClearColorUInt() : vl::Viewport
  • setClearColorValue() : vl::Clear
  • setClearColorValueInt() : vl::Clear
  • setClearColorValueUInt() : vl::Clear
  • setClearDepth() : vl::Viewport
  • setClearDepthBuffer() : vl::Clear
  • setClearDepthValue() : vl::Clear
  • setClearFlags()
: vl::Rendering
, vl::Viewport
  • setClearStencil() : vl::Viewport
  • setClearStencilBuffer() : vl::Clear
  • setClearStencilValue() : vl::Clear
  • setCollapsePosition() : vl::PolygonSimplifier::Vertex
  • setCollectStatistics() : vl::Renderer
  • setColor()
: vl::Fog
, vl::TexEnv
, vl::Text
, vlVG::VectorGraphics
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
  • setColorArray() : vl::Geometry
  • setColorControl() : vl::LightModel
  • setColorMask() : vlVG::VectorGraphics
  • setColorMaterial() : vl::Material
  • setColorMaterialEnabled() : vl::Material
  • setCombineAlpha() : vl::TexEnv
  • setCombineRGB() : vl::TexEnv
  • setCompression() : vl::LoadWriterPNG
  • setCompressionLevel() : vl::GZipCodec
  • setComputeNormals() : vl::GeometryLoadCallback
  • setConstantAttenuation() : vl::Light
  • setContinuousUpdate()
: vl::OpenGLContext
, vlQt4::Qt4Widget
  • setConvertToDrawArrays() : vl::GeometryLoadCallback
  • setCoordinates() : vlMolecule::Atom
  • setCount() : vl::DrawArrays
  • setCountType() : vl::PlyLoader::PlyScalarList
  • setCovalentAtomRadii() : vlMolecule::Molecule
  • setCPKAtomColors() : vlMolecule::Molecule
  • setCreaseAngle()
: vl::EdgeExtractor
, vl::EdgeRenderer
  • setCullingEnabled()
: vl::Rendering
, vl::SceneManager
  • setData() : vl::VertexAttributeArray
  • setDataDirty() : vlVolume::Volume
  • setDefaultFont() : vlVG::VectorGraphics
  • setDefaultLineColor() : vl::EdgeRenderer
  • setDensity() : vl::Fog
  • setDepth()
: vl::Image
, vl::Terrain
, vl::Texture
  • setDepthBias() : vl::PixelTransfer
  • setDepthBufferBits() : vl::OpenGLContextFormat
  • setDepthScale() : vl::PixelTransfer
  • setDepthSortMode()
: vl::RenderQueueSorterStandard
, vl::RenderQueueSorterAggressive
  • setDepthTextureMode() : vl::TexParameter
  • setDetail() : vl::BezierSurface
  • setDetailRepetitionCount() : vl::Terrain
  • setDetailTexture() : vl::Terrain
  • setDetailTextureFormat() : vl::Terrain
  • setDiffuse()
: vl::Light
, vl::Material
  • setDimension()
: vl::Texture::SetupParams
, vl::Texture
  • setDirection() : vl::Ray
  • setDiscardOriginalNormals() : vl::GeometryLoadCallback
  • setDisplayList() : vl::Renderable
  • setDisplayListDirty() : vl::Renderable
  • setDisplayListEnabled() : vl::Renderable
  • setDistance() : vl::RayIntersection
  • setDistanceAttenuation() : vl::PointParameter
  • setDistanceRange() : vl::DistanceLODEvaluator
  • setDistanceRangeSet() : vl::DistanceLODEvaluator
  • setDoubleBuffer() : vl::OpenGLContextFormat
  • setDrawBuffers() : vl::RenderTarget
  • setDrawFramebuffer() : vl::BlitFramebuffer
  • setDstAlpha() : vl::BlendFunc
  • setDstRect() : vl::BlitFramebuffer
  • setDstRGB() : vl::BlendFunc
  • setEffect() : vl::Actor
  • setElemCount() : vl::PlyLoader::PlyElement
  • setEmission() : vl::Material
  • setEmpiricalAtomRadii() : vlMolecule::Molecule
  • setEnable() : vl::ShaderNode
  • setEnabled()
: vl::Primitives
, vl::UIEventListener
  • setEnableMask()
: vl::Actor
, vl::Effect
, vl::RenderingAbstract
, vl::SceneManager
  • setEnableSet() : vl::Shader
  • setEnd() : vl::Fog
  • setEvaluateLOD() : vl::Rendering
  • setExStyle() : vlWin32::Win32Window
  • setEyePlaneQ() : vl::TexGen
  • setEyePlaneR() : vl::TexGen
  • setEyePlaneS() : vl::TexGen
  • setEyePlaneT() : vl::TexGen
  • setFactor()
: vl::PolygonOffset
, vl::LineStipple
  • setFadeThresholdSize() : vl::PointParameter
  • setFarPlane() : vl::Camera
  • setFillBottom() : vl::Extrusion
  • setFillTop() : vl::Extrusion
  • setFlatColor() : vl::Material
  • setFogCoordArray() : vl::Geometry
  • setFogHint() : vl::Hint
  • setFont()
: vl::Glyph
, vl::Text
, vlVG::VectorGraphics
  • setFormat()
: vl::Image
, vl::Texture::SetupParams
  • setFOV() : vl::Camera
  • setFragmentShader() : vl::Terrain
  • setFrontAmbient() : vl::Material
  • setFrontDiffuse() : vl::Material
  • setFrontEmission() : vl::Material
  • setFrontFace() : vl::PolygonMode
  • setFrontFlatColor() : vl::Material
  • setFrontShininess() : vl::Material
  • setFrontSpecular() : vl::Material
  • setFrontTransparency() : vl::Material
  • setFrustum()
: vl::Camera
, vl::RayIntersector
  • setFullscreen()
: vl::OpenGLContextFormat
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
  • setGenerateMipmap() : vl::TexParameter
  • setGenerateMipmapHint() : vl::Hint
  • setGenModeQ() : vl::TexGen
  • setGenModeR() : vl::TexGen
  • setGenModeS() : vl::TexGen
  • setGenModeT() : vl::TexGen
  • setGeometry() : vl::RayIntersectionGeometry
  • setGeometryInputType() : vl::GLSLProgram
  • setGeometryOutputType() : vl::GLSLProgram
  • setGeometryVerticesOut() : vl::GLSLProgram
  • setGLSLVertexBlendEnabled() : vl::MorphingActor
  • setGlyphIndex() : vl::Glyph
  • setGreen() : vl::ColorMask
  • setGreenBias() : vl::PixelTransfer
  • setGreenScale() : vl::PixelTransfer
  • setHandle() : vl::Texture
  • setHasMipmaps() : vl::Texture::SetupParams
  • setHeight()
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
, vl::ReadPixels
, vl::Rect< T >
, vl::RenderTarget
, vl::Terrain
, vl::Texture
, vl::Viewport
  • setHeightmapTexture() : vl::Terrain
  • setHeightmapTextureFormat() : vl::Terrain
  • setHighQualityNormals() : vlVolume::MarchingCubes
  • setId()
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • setIdentity()
: vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • setIllum() : vl::ObjMaterial
  • setImage()
: vl::ReadPixels
, vl::Texture::SetupParams
, vlVG::VectorGraphics
  • setImageBuffer() : vl::Image
  • setImagePath() : vl::Texture::SetupParams
  • setImfchan() : vl::ObjTexture
  • setIndexOffset() : vl::PixelTransfer
  • setIndexShift() : vl::PixelTransfer
  • setInputFile() : vl::BufferedStream< Element_Type, Chunk_Size >
  • setInstances() : vl::Primitives
  • setInterlineSpacing() : vl::Text
  • setInternalFormat() : vl::Texture
  • setInterpolator()
: vl::CatmullRomInterpolatorFVec4
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • setIntersectionPoint() : vl::RayIntersection
  • setInverseViewMatrix() : vl::Camera
  • setInvert() : vl::SampleCoverage
  • setIsCrease() : vl::EdgeExtractor::Edge
  • setIsOpen() : vl::Portal
  • setKa() : vl::ObjMaterial
  • setKd() : vl::ObjMaterial
  • setKerningEnabled() : vl::Text
  • setKeysBackward() : vl::GhostCameraManipulator
  • setKeysDown() : vl::GhostCameraManipulator
  • setKeysForward() : vl::GhostCameraManipulator
  • setKeysLeft() : vl::GhostCameraManipulator
  • setKeysRight() : vl::GhostCameraManipulator
  • setKeysUp() : vl::GhostCameraManipulator
  • setKs() : vl::ObjMaterial
  • setLabelFont() : vlVolume::VolumePlot
  • setLabelFormat() : vlVolume::VolumePlot
  • setLastUpdateTime()
: vl::Actor
, vl::Shader
  • setLayer()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • setLayout() : vl::Text
  • setLeft() : vl::Glyph
  • setLevel()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • setLight() : vlVolume::SlicedVolume
  • setLightIndex() : vl::Light
  • setLinearAttenuation() : vl::Light
  • setLinearFilteringEnabled() : vl::BlitFramebuffer
  • setLineSmoothHint() : vl::Hint
  • setLineSmoothing() : vlVG::VectorGraphics
  • setLineStipple() : vlVG::VectorGraphics
  • setLineWidth()
: vl::EdgeRenderer
, vlVG::VectorGraphics
, vlMolecule::Molecule
  • setLoadExtensions() : vl::ResourceLoadWriter
  • setLocalMatrix() : vl::Transform
  • setLocalViewer() : vl::LightModel
  • setLOD() : vl::Effect
  • setLodBias() : vl::TexEnv
  • setLODEvaluator()
: vl::Actor
, vl::Effect
  • setLODs() : vl::Actor
  • setLogFile() : vl::StandardLog
  • setLogger() : vl::Log
  • setLogicOp() : vlVG::VectorGraphics
  • setMagFilter() : vl::TexParameter
  • setMap_Bump() : vl::ObjMaterial
  • setMap_d() : vl::ObjMaterial
  • setMap_Decal() : vl::ObjMaterial
  • setMap_Disp() : vl::ObjMaterial
  • setMap_Ka() : vl::ObjMaterial
  • setMap_Kd() : vl::ObjMaterial
  • setMap_Ks() : vl::ObjMaterial
  • setMap_Ns() : vl::ObjMaterial
  • setMapColor() : vl::PixelTransfer
  • setMapStencil() : vl::PixelTransfer
  • setMargin() : vl::Text
  • setMaterial() : vl::ObjMesh
  • setMatrix()
: vl::TextureMatrix
, vl::Text
, vlVG::VectorGraphics
  • setMaxCorner()
: vl::AABB
, vlVolume::VolumePlot
  • setMinCorner()
: vl::AABB
, vlVolume::VolumePlot
  • setMinFilter() : vl::TexParameter
  • setMipmapLevel()
: vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
  • setMipmaps() : vl::Image
  • setMM_Base() : vl::ObjTexture
  • setMM_Gain() : vl::ObjTexture
  • setMode()
: vl::Fog
, vl::TexEnv
, vl::Text
  • setMolecule() : vlMolecule::RingExtractor
  • setMoleculeName() : vlMolecule::Molecule
  • setMoleculeStyle() : vlMolecule::Molecule
  • setMousePosition()
: vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • setMouseVisible()
: vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
  • setMovementSpeed() : vl::GhostCameraManipulator
  • setMultisample() : vl::OpenGLContextFormat
  • setMultisampleSamples() : vl::OpenGLContextFormat
  • setName()
: vl::Object
, vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyElement
  • setNearFarClippingPlanesOptimized() : vl::Camera
  • setNearPlane() : vl::Camera
  • setNi() : vl::ObjMaterial
  • setNormal()
: vl::Billboard
, vl::Plane
, vl::Portal
  • setNormal1() : vl::EdgeExtractor::Edge
  • setNormal2() : vl::EdgeExtractor::Edge
  • setNormalArray() : vl::Geometry
  • setNormalize() : vl::VertexAttributeArray
  • setNoRotation() : vl::quat
  • setNs() : vl::ObjMaterial
  • setNull()
: vl::AABB
, vl::Sphere
  • setO_UVW() : vl::ObjTexture
  • setObjectPlaneQ() : vl::TexGen
  • setObjectPlaneR() : vl::TexGen
  • setObjectPlaneS() : vl::TexGen
  • setObjectPlaneT() : vl::TexGen
  • setOccludee() : vl::Actor
  • setOcclusionCullingEnabled() : vl::Renderer
  • setOcclusionQueryTick() : vl::Actor
  • setOcclusionThreshold() : vl::Renderer
  • setOpenGLContext() : vl::Renderer
  • setOpenGLContextInfo() : vl::OpenGLContext
  • setOperand0Alpha() : vl::TexEnv
  • setOperand0RGB() : vl::TexEnv
  • setOperand1Alpha() : vl::TexEnv
  • setOperand1RGB() : vl::TexEnv
  • setOperand2Alpha() : vl::TexEnv
  • setOperand2RGB() : vl::TexEnv
  • setOrigin()
: vl::Plane
, vl::Ray
, vl::Terrain
  • setOutlineColor() : vl::Text
  • setOutlineEnabled() : vl::Text
  • setParent() : vl::ActorTreeAbstract
  • setPath()
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::MemoryDirectory
, vl::VirtualDirectory
, vl::VirtualFile
, vl::ObjTexture
, vl::ZippedDirectory
  • setPattern() : vl::LineStipple
  • setPerspectiveCorrectionHint() : vl::Hint
  • setPivot() : vl::TrackballManipulator
  • setPixelRange() : vl::PixelLODEvaluator
  • setPixelRangeSet() : vl::PixelLODEvaluator
  • setPlane()
: vl::ClipPlane
, vl::Frustum
  • setPlaneIndex() : vl::ClipPlane
  • setPlotTransform() : vlVolume::VolumePlot
  • setPoint()
: vl::Sphere
, vlVG::VectorGraphics
  • setPointSize() : vlVG::VectorGraphics
  • setPointSmoothHint() : vl::Hint
  • setPointSmoothing() : vlVG::VectorGraphics
  • setPointSpriteCoordReplace() : vl::TexEnv
  • setPolygonOffsetFactor() : vl::EdgeRenderer
  • setPolygonOffsetUnits() : vl::EdgeRenderer
  • setPolygonSmoohtHint() : vl::Hint
  • setPolygonSmoothing() : vlVG::VectorGraphics
  • setPolygonStipple() : vlVG::VectorGraphics
  • setPosition()
: vlQt4::Qt4Widget
, vl::DrawPixels::Pixels
, vl::Billboard
, vl::GhostCameraManipulator
, vl::Light
, vl::OpenGLContext
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
  • setPostColorMatrixAlphaBias() : vl::PixelTransfer
  • setPostColorMatrixAlphaScale() : vl::PixelTransfer
  • setPostColorMatrixBlueBias() : vl::PixelTransfer
  • setPostColorMatrixBlueScale() : vl::PixelTransfer
  • setPostColorMatrixGreenBias() : vl::PixelTransfer
  • setPostColorMatrixGreenScale() : vl::PixelTransfer
  • setPostColorMatrixRedBias() : vl::PixelTransfer
  • setPostColorMatrixRedScale() : vl::PixelTransfer
  • setPostConvolutionAlphaBias() : vl::PixelTransfer
  • setPostConvolutionAlphaScale() : vl::PixelTransfer
  • setPostConvolutionBlueBias() : vl::PixelTransfer
  • setPostConvolutionBlueScale() : vl::PixelTransfer
  • setPostConvolutionGreenBias() : vl::PixelTransfer
  • setPostConvolutionGreenScale() : vl::PixelTransfer
  • setPostConvolutionRedBias() : vl::PixelTransfer
  • setPostConvolutionRedScale() : vl::PixelTransfer
  • setPrimitiveIndex() : vl::RayIntersectionGeometry
  • setPrimitives() : vl::RayIntersectionGeometry
  • setPrimitiveType()
: vl::Primitives
, vl::DrawElements< index_type, Tgltype, arr_type >
  • setProjectionAsFrustum() : vl::Camera
  • setProjectionAsOrtho() : vl::Camera
  • setProjectionAsOrtho2D() : vl::Camera
  • setProjectionAsPerspective() : vl::Camera
  • setProjectionMatrix() : vl::Camera
  • setProtectedVertices() : vl::PolygonSimplifier
  • setPureInteger() : vl::VertexAttributeArray
  • setQErr() : vl::PolygonSimplifier::Vertex
  • setQuadraticAttenuation() : vl::Light
  • setQuality() : vl::LoadWriterJPG
  • setQuick() : vl::PolygonSimplifier
  • setRadius()
: vl::Sphere
, vlMolecule::Atom
, vlMolecule::Bond
  • setRank() : vl::UIEventListener
  • setRay() : vl::RayIntersector
  • setReadBuffer()
: vl::CopyTexSubImage
, vl::ReadPixels
  • setReadFramebuffer() : vl::BlitFramebuffer
  • setRed() : vl::ColorMask
  • setRedBias() : vl::PixelTransfer
  • setRedScale() : vl::PixelTransfer
  • setRemoveAfterCall() : vl::RenderingCallback
  • setRemoveDoubles()
: vl::GeometryLoadCallback
, vl::PolygonSimplifier
  • setRenderBlock() : vl::Actor
  • setRenderer() : vl::Rendering
  • setRendering() : vl::VisualizationLibrary
  • setRenderQueueSorter() : vl::Rendering
  • setRenderRank()
: vl::Actor
, vl::Effect
  • setRenderState()
: vl::RenderStateSet
, vl::Shader
, vl::ShaderNode
  • setRenderStateSet() : vl::Shader
  • setRenderTarget() : vl::Rendering
  • setRGBABits() : vl::OpenGLContextFormat
  • setRGBScale() : vl::TexEnv
  • setRingOffset() : vlMolecule::Molecule
  • setRotationButton() : vl::TrackballManipulator
  • setRotationSpeed()
: vl::GhostCameraManipulator
, vl::TrackballManipulator
  • setS0() : vl::Glyph
  • setS1() : vl::Glyph
  • setS_UVW() : vl::ObjTexture
  • setSamples() : vl::FBORenderbufferAttachment
  • setSamplingResolution() : vlVolume::VolumePlot
  • setSavePath() : vl::ReadPixels
  • setScalarType()
: vl::PlyLoader::PlyScalar
, vl::PlyLoader::PlyScalarList
  • setSceneBoundingSphere() : vl::Camera
  • setScissor()
: vl::Actor
, vl::Scissor
, vlVG::VectorGraphics
, vl::Shader
  • setScissorBox() : vl::Clear
  • setSecondaryColorArray() : vl::Geometry
  • setSetupParams() : vl::Texture
  • setShader() : vl::ShaderNode
  • setShaderAnimationEnabled() : vl::Rendering
  • setShadowColor() : vl::Text
  • setShadowEnabled() : vl::Text
  • setShadowVector() : vl::Text
  • setShininess() : vl::Material
  • setShowAtomName() : vlMolecule::Atom
  • setShowAtomNames() : vlMolecule::Molecule
  • setShowCreases()
: vl::EdgeRenderer
, vl::EdgeUpdateCallback
  • setShowHiddenLines() : vl::EdgeRenderer
  • setShowPortals() : vl::SceneManagerPortals
  • setSilhouette() : vl::Extrusion
  • setSilhouetteMode() : vl::Extrusion
  • setSize()
: vl::DrawPixels::Pixels
, vl::Font
, vl::OpenGLContext
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlGLUT::GLUTWindow
, vlWin32::Win32Context
  • setSizeMax() : vl::PointParameter
  • setSizeMin() : vl::PointParameter
  • setSliceCount() : vlVolume::SlicedVolume
  • setSmooth()
: vl::Extrusion
, vl::Font
  • setSmoothLines()
: vl::EdgeRenderer
, vlMolecule::Molecule
  • setSortMode() : vl::DepthSortCallback
  • setSortTriangles() : vl::GeometryLoadCallback
  • setSortVertices() : vl::GeometryLoadCallback
  • setSource() : vl::GLSLShader
  • setSource0Alpha() : vl::TexEnv
  • setSource0RGB() : vl::TexEnv
  • setSource1Alpha() : vl::TexEnv
  • setSource1RGB() : vl::TexEnv
  • setSource2Alpha() : vl::TexEnv
  • setSource2RGB() : vl::TexEnv
  • setSourceZipFile()
: vl::ZippedFileInfo
, vl::ZippedDirectory
  • setSpecular()
: vl::Light
, vl::Material
  • setSpotCutoff() : vl::Light
  • setSpotDirection() : vl::Light
  • setSpotExponent() : vl::Light
  • setSrcAlpha() : vl::BlendFunc
  • setSrcRect() : vl::BlitFramebuffer
  • setSrcRGB() : vl::BlendFunc
  • setStart()
: vl::DrawArrays
, vl::DrawPixels::Pixels
, vl::Fog
  • setStencilBufferBits() : vl::OpenGLContextFormat
  • setStencilFunc() : vlVG::VectorGraphics
  • setStencilMask() : vlVG::VectorGraphics
  • setStencilOp() : vlVG::VectorGraphics
  • setStencilTestEnabled() : vlVG::VectorGraphics
  • setStereo() : vl::OpenGLContextFormat
  • setStoreInPixelBufferObject() : vl::ReadPixels
  • setStream() : vl::GZipCodec
  • setStripfy() : vl::GeometryLoadCallback
  • setStyle() : vlWin32::Win32Window
  • setT()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • setT0() : vl::Glyph
  • setT1() : vl::Glyph
  • setT_UVW() : vl::ObjTexture
  • setTags() : vl::Image
  • setTarget() : vl::CopyTexSubImage2D
  • setTargetSector() : vl::Portal
  • setTerrainTexture() : vl::Terrain
  • setTerrainTextureFormat() : vl::Terrain
  • setTessellateIntoSinglePolygon() : vl::Tessellator
  • setTessNormal() : vl::Tessellator
  • setTexCompareFunc() : vl::TexParameter
  • setTexCompareMode() : vl::TexParameter
  • setTexCoordArray() : vl::Geometry
  • setTexres_Value() : vl::ObjTexture
  • setText() : vl::Text
  • setTextAlignment() : vl::Text
  • setTexture()
: vl::FBOTexture2DAttachment
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
, vl::TextureUnit
  • setTextureHandle() : vl::Glyph
  • setTextureMode() : vlVG::VectorGraphics
  • setTextureTarget() : vl::FBOTexture2DAttachment
  • setThreshold() : vlVolume::VolumeInfo
  • setTolerance() : vl::Tessellator
  • setTop() : vl::Glyph
  • setTr() : vl::ObjMaterial
  • setTransferFunction() : vlVolume::SlicedVolume
  • setTransform()
: vl::Actor
, vl::Rendering
, vlVG::VectorGraphics
, vl::TrackballManipulator
  • setTransformGeometry() : vl::GeometryLoadCallback
  • setTransformMatrix() : vl::GeometryLoadCallback
  • setTranslationButton() : vl::TrackballManipulator
  • setTranslationSpeed() : vl::TrackballManipulator
  • setTransparency() : vl::Material
  • setTree() : vl::SceneManagerBVH< T >
  • setTwoSide() : vl::LightModel
  • setType()
: vl::FBODepthBufferAttachment
, vl::FBOStencilBufferAttachment
, vl::FBOColorBufferAttachment
, vl::Billboard
, vl::FBODepthStencilBufferAttachment
, vl::Image
  • setUniform()
: vl::Uniform
, vl::ShaderNode
, vl::Uniform
, vl::UniformSet
, vl::Actor
, vl::Shader
, vl::Uniform
, vl::GLSLProgram
, vl::Uniform
  • setUniform1f() : vl::Uniform
  • setUniform1i() : vl::Uniform
  • setUniform1ui() : vl::Uniform
  • setUniform2f() : vl::Uniform
  • setUniform2i() : vl::Uniform
  • setUniform2ui() : vl::Uniform
  • setUniform3f() : vl::Uniform
  • setUniform3i() : vl::Uniform
  • setUniform3ui() : vl::Uniform
  • setUniform4f() : vl::Uniform
  • setUniform4i() : vl::Uniform
  • setUniform4ui() : vl::Uniform
  • setUniformMatrix2f() : vl::Uniform
  • setUniformMatrix2x3f() : vl::Uniform
  • setUniformMatrix2x4f() : vl::Uniform
  • setUniformMatrix3f() : vl::Uniform
  • setUniformMatrix3x2f() : vl::Uniform
  • setUniformMatrix3x4f() : vl::Uniform
  • setUniformMatrix4f() : vl::Uniform
  • setUniformMatrix4x2f() : vl::Uniform
  • setUniformMatrix4x3f() : vl::Uniform
  • setUniformSet()
: vl::Actor
, vl::Shader
, vl::GLSLProgram
  • setUnitIndex() : vl::RenderState
  • setUnits() : vl::PolygonOffset
  • setup()
: vlVolume::Volume
, vl::ReadPixels
  • setUpdateTime() : vl::RenderingAbstract
  • setupDefaultRenderStates() : vl::Renderer
  • setupEndPoints() : vl::CatmullRomInterpolator< T >
  • setupInternalData() : vlVolume::Volume
  • setupLabels() : vlVolume::VolumePlot
  • setupParams() : vl::Texture
  • SetupParams() : vl::Texture::SetupParams
  • setupParams() : vl::Texture
  • setupTexture1D() : vl::Texture
  • setupTexture1DArray() : vl::Texture
  • setupTexture2D() : vl::Texture
  • setupTexture2DArray() : vl::Texture
  • setupTexture3D() : vl::Texture
  • setupTextureCubemap() : vl::Texture
  • setupTextureRectangle() : vl::Texture
  • setUsage() : vl::ArrayAbstract
  • setUseAtomColors() : vlMolecule::Bond
  • setUseCameraRotationInverse() : vl::TextureMatrix
  • setUseDisplayLists() : vl::GeometryLoadCallback
  • setUseGLSL() : vl::Terrain
  • setUsePixelBufferObject() : vl::DrawPixels
  • setUseVBOs() : vl::GeometryLoadCallback
  • setValue() : vl::SampleCoverage
  • setVanDerWaalsAtomRadii() : vlMolecule::Molecule
  • setVBODirty()
: vl::ArrayAbstract
, vl::Renderable
  • setVBOEnabled() : vl::Renderable
  • setVerbose() : vl::PolygonSimplifier
  • setVert0() : vlVolume::VolumeInfo
  • setVertC() : vlVolume::VolumeInfo
  • setVertex1() : vl::EdgeExtractor::Edge
  • setVertex2() : vl::EdgeExtractor::Edge
  • setVertexArray() : vl::Geometry
  • setVertexAttributeArray() : vl::Geometry
  • setVertexShader() : vl::Terrain
  • setViewMatrix() : vl::Camera
  • setViewMatrixAsLookAt() : vl::Camera
  • setViewport() : vl::Camera
  • setViewportAlignment() : vl::Text
  • setVisible()
: vlMolecule::Atom
, vlMolecule::Bond
  • setVisited() : vlMolecule::Atom
  • setVolume() : vlVolume::VolumeInfo
  • setVolumeImage() : vlVolume::SlicedVolume
  • setVSync() : vl::OpenGLContextFormat
  • setVSyncEnabled() : vl::OpenGLContext
  • setWarnNonManifold() : vl::EdgeExtractor
  • setWarnOnSeek() : vl::GZipCodec
  • setWidth()
: vl::RenderTarget
, vl::Rect< T >
, vl::ReadPixels
, vl::CopyTexSubImage2D
, vl::Glyph
, vl::Image
, vl::Terrain
, vl::FBORenderbufferAttachment
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
, vl::Viewport
, vl::Texture
  • setWindingRule() : vl::Tessellator
  • setWindowClassName() : vlWin32::Win32Window
  • setWindowSize() : vlWin32::Win32Context
  • setWindowTitle()
: vlQt4::Qt4Widget
, vlGLUT::GLUTWindow
, vlWin32::Win32Context
, vlSDL::SDLWindow
, vl::OpenGLContext
, vlWX::vlWXGLCanvas
  • setWorldMatrix() : vl::Transform
  • setWrapR() : vl::TexParameter
  • setWrapS() : vl::TexParameter
  • setWrapT() : vl::TexParameter
  • setWriteExtensions() : vl::ResourceLoadWriter
  • setX()
: vl::Matrix3< scalar_type >
, vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::Viewport
, vl::Matrix4< scalar_type >
, vl::ReadPixels
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage1D
  • setXDegrees() : vl::GhostCameraManipulator
  • setXOffset()
: vl::CopyTexSubImage3D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage1D
  • setY()
: vl::CopyTexSubImage1D
, vl::Matrix4< scalar_type >
, vl::Viewport
, vl::Matrix3< scalar_type >
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::ReadPixels
  • setYDegrees() : vl::GhostCameraManipulator
  • setYOffset()
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • setZ() : vl::Matrix4< scalar_type >
  • setZero() : vl::quat
  • setZFar() : vl::DepthRange
  • setZippedFileInfo() : vl::ZippedFile
  • setZNear() : vl::DepthRange
  • setZOffset() : vl::CopyTexSubImage3D
  • setZoomButton() : vl::TrackballManipulator
  • setZoomSpeed() : vl::TrackballManipulator
  • sFail_Back() : vl::StencilOp
  • sFail_Front() : vl::StencilOp
  • ShadeModel() : vl::ShadeModel
  • shadeModel() : vl::ShadeModel
  • shader()
: vl::Effect
, vl::GLSLProgram
  • Shader() : vl::Shader
  • shader()
: vl::Effect
, vl::ShaderNode
, vl::GLSLProgram
  • shaderAnimationEnabled() : vl::Rendering
  • shaderCount() : vl::GLSLProgram
  • shaderNode() : vl::Terrain
  • ShaderNode() : vl::ShaderNode
  • shaderNode() : vl::Terrain
  • ShaderSequence() : vl::ShaderSequence
  • shadowColor() : vl::Text
  • shadowEnabled() : vl::Text
  • shadowVector() : vl::Text
  • shallowCopy() : vl::Geometry
  • shareOpenGLResources() : vlWin32::Win32Context
  • show()
: vlWin32::Win32Context
, vlQt4::Qt4Widget
, vlGLUT::GLUTWindow
, vl::OpenGLContext
, vlWX::vlWXGLCanvas
  • showAtomName() : vlMolecule::Atom
  • showAtomNames() : vlMolecule::Molecule
  • showCreases()
: vl::EdgeUpdateCallback
, vl::EdgeRenderer
  • showHiddenLines() : vl::EdgeRenderer
  • showPortals() : vl::SceneManagerPortals
  • shrink() : vl::Collection< T >
  • shrinkDrawElements() : vl::Geometry
  • shutdown()
: vl::VisualizationLibrary
, vlut::Applet
  • silhouette() : vl::Extrusion
  • silhouetteMode() : vl::Extrusion
  • simplifiedIndex() : vl::PolygonSimplifier::Vertex
  • simplifiedTriangles() : vl::PolygonSimplifier
  • simplifiedTrianglesCount() : vl::PolygonSimplifier
  • simplifiedVertices() : vl::PolygonSimplifier
  • simplifiedVerticesCount() : vl::PolygonSimplifier
  • simplify() : vl::PolygonSimplifier
  • size()
: vlQt4::Qt4Widget
, vl::DiskFile
, vl::Font
, vl::Collection< T >
, vlGLUT::GLUTWindow
, vlVolume::Volume
, vl::DrawPixels::Pixels
, vl::ArrayAbstract
, vl::ZippedFile
, vl::VirtualFile
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::OpenGLContext
, vl::RenderQueue
, vlWin32::Win32Context
, vl::GZipCodec
, vl::MemoryFile
  • sizeGPU() : vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • sizeMax() : vl::PointParameter
  • sizeMin() : vl::PointParameter
  • skipChunk() : vl::A3DSLoader
  • sleep() : vl::Time
  • slerp() : vl::quat
  • sliceCount() : vlVolume::SlicedVolume
  • SlicedVolume() : vlVolume::SlicedVolume
  • slices() : vlVolume::Volume
  • smooth()
: vl::Font
, vl::Extrusion
  • smoothLines()
: vlMolecule::Molecule
, vl::EdgeRenderer
  • sort()
: vl::Collection< T >
, vl::DepthSortCallback
, vl::RenderQueue
  • sortCycles() : vlMolecule::RingExtractor
  • sorter() : vl::RayIntersector
  • sortEventListeners() : vl::OpenGLContext
  • sortMode() : vl::DepthSortCallback
  • sortTriangles()
: vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Primitives
, vl::Geometry
, vl::GeometryLoadCallback
  • sortVertices()
: vl::GeometryLoadCallback
, vl::Geometry
  • source() : vl::GLSLShader
  • source0Alpha() : vl::TexEnv
  • source0RGB() : vl::TexEnv
  • source1Alpha() : vl::TexEnv
  • source1RGB() : vl::TexEnv
  • source2Alpha() : vl::TexEnv
  • source2RGB() : vl::TexEnv
  • sourceZipFile()
: vl::ZippedDirectory
, vl::ZippedFileInfo
  • specular() : vl::Light
  • Sphere() : vl::Sphere
  • split() : vl::String
  • splitLines() : vl::String
  • spotCutoff() : vl::Light
  • spotDirection() : vl::Light
  • spotExponent() : vl::Light
  • squad() : vl::quat
  • squeeze() : vl::String
  • srcAlpha() : vl::BlendFunc
  • srcRect() : vl::BlitFramebuffer
  • srcRGB() : vl::BlendFunc
  • st()
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • start()
: vl::DrawArrays
, vl::DrawPixels::Pixels
, vl::Time
, vl::Fog
  • startAnimation() : vl::MorphingActor
  • startCRC32() : vl::CRC32CheckSum
  • startDrawing() : vlVG::VectorGraphics
  • startsWith() : vl::String
  • stencilBufferBits() : vl::OpenGLContextFormat
  • StencilFunc() : vl::StencilFunc
  • stencilMask() : vlVG::VectorGraphics
  • StencilMask() : vl::StencilMask
  • StencilOp() : vl::StencilOp
  • stencilTestEnabled() : vlVG::VectorGraphics
  • stereo() : vl::OpenGLContextFormat
  • sticksStyle() : vlMolecule::Molecule
  • stop() : vl::Time
  • stopAnimation() : vl::MorphingActor
  • storeInPixelBufferObject() : vl::ReadPixels
  • stp() : vl::Vector4< scalar_type >
  • str() : vl::Say
  • stream() : vl::GZipCodec
  • String() : vl::String
  • stripfy()
: vl::GeometryLoadCallback
, vl::TriangleStripGenerator
  • style() : vlWin32::Win32Window
  • subDir()
: vl::ZippedDirectory
, vl::MemoryDirectory
, vl::DiskDirectory
, vl::VirtualDirectory
  • subImage() : vl::Image
  • subRenderings() : vl::RenderingTree
  • substituteColorGreenKey() : vl::Image
  • substituteColorRGB_RGB() : vl::Image
  • substituteColorRGB_RGBA() : vl::Image
  • substring() : vl::String
  • supports() : vl::Texture
  • swap()
: vl::ref< T >
, vl::Buffer
, vl::Collection< T >
, vl::GLBufferObject
  • swapBuffers()
: vl::OpenGLContext
, vlWX::vlWXGLCanvas
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vlWin32::Win32Context
, vlQt4::Qt4Widget
  • symbol() : vlMolecule::AtomInfo
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- t -

  • t()
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • t0() : vl::Glyph
  • t1() : vl::Glyph
  • t_UVW() : vl::ObjTexture
  • tags()
: vl::Image
, vlMolecule::Molecule
  • target() : vl::CopyTexSubImage2D
  • targetSector() : vl::Portal
  • Terrain() : vl::Terrain
  • terrainTexture() : vl::Terrain
  • terrainTextureFormat() : vl::Terrain
  • tessBeginData() : vl::Tessellator
  • tessCombineData() : vl::Tessellator
  • tessellate() : vl::Tessellator
  • tessellatedTris() : vl::Tessellator
  • tessellateGeometry() : vl::Tessellator
  • tessellateIntoSinglePolygon() : vl::Tessellator
  • Tessellator() : vl::Tessellator
  • tessEnd() : vl::Tessellator
  • tessError() : vl::Tessellator
  • tessNormal() : vl::Tessellator
  • tessVertexData() : vl::Tessellator
  • texCoordArray() : vl::Geometry
  • texCoords() : vlVolume::SlicedVolume
  • texCoordsArray() : vl::ObjLoader
  • TexEnv() : vl::TexEnv
  • TexGen() : vl::TexGen
  • TexParameter() : vl::TexParameter
  • texres_Value() : vl::ObjTexture
  • text() : vl::Text
  • Text() : vl::Text
  • textAlignment() : vl::Text
  • TextStream() : vl::TextStream
  • textTemplate() : vlVolume::VolumePlot
  • texture() : vl::TextureUnit
  • Texture() : vl::Texture
  • texture()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
, vl::FBOTexture3DAttachment
, vl::FBOTextureLayerAttachment
, vl::TextureUnit
  • textureHandle() : vl::Glyph
  • TextureMatrix() : vl::TextureMatrix
  • textureMode() : vlVG::VectorGraphics
  • textureTarget() : vl::FBOTexture2DAttachment
  • textureUnit() : vl::RenderState
  • TextureUnit() : vl::TextureUnit
  • textureUnitCount() : vl::OpenGLContext
  • threshold() : vlVolume::VolumeInfo
  • Time() : vl::Time
  • toAscii() : vl::String
  • toAxisAngle() : vl::quat
  • toDouble() : vl::String
  • toFloat() : vl::String
  • toInt() : vl::String
  • toLatin1() : vl::String
  • tolerance() : vl::Tessellator
  • toLowerCase() : vl::String
  • toMatrix() : vl::quat
  • top()
: vl::Glyph
, vl::Rect< T >
, vl::RectI
, vl::RectF
  • topRight()
: vl::RectI
, vl::RectF
, vlVolume::Volume
  • toStdString()
: vl::MD5CheckSum
, vl::String
  • toStdWString() : vl::String
  • toUpperCase() : vl::String
  • toUTF16BE() : vl::String
  • toUTF16LE() : vl::String
  • toUTF8() : vl::String
  • tr() : vl::ObjMaterial
  • trackball() : vlut::Applet
  • TrackballManipulator() : vl::TrackballManipulator
  • trackballRotation() : vl::TrackballManipulator
  • transferFunction() : vlVolume::SlicedVolume
  • transform() : vl::TrackballManipulator
  • Transform() : vl::Transform
  • transform()
: vl::Actor
, vl::ArrayAbstract
, vl::Array< vector_type, scalar_type, gl_size, gl_type >
, vl::Geometry
, vl::Rendering
  • transformed()
: vl::Sphere
, vl::AABB
, vl::Sphere
  • transformGeometry() : vl::GeometryLoadCallback
  • transformMatrix() : vl::GeometryLoadCallback
  • transformTree() : vlMolecule::Molecule
  • translate()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Text
, vl::Transform
, vlVG::VectorGraphics
  • translateEvent() : vlSDL::SDLWindow
  • translateKeyEvent() : vlQt4::Qt4Widget
  • translatePath() : vl::VirtualDirectory
  • translateType() : vl::PlyLoader
  • translation()
: vl::Matrix3< scalar_type >
, vl::Matrix4< scalar_type >
  • translationButton() : vl::TrackballManipulator
  • translationSpeed() : vl::TrackballManipulator
  • transpose()
: vl::Matrix2< scalar_type >
, vl::Matrix4< scalar_type >
, vl::Matrix3< scalar_type >
  • tree() : vl::SceneManagerBVH< T >
  • Triangle() : vl::PolygonSimplifier::Triangle
  • triangleCount()
: vl::DrawArrays
, vl::Geometry
, vl::Renderable
, vl::Primitives
, vl::DrawElements< index_type, Tgltype, arr_type >
  • trim() : vl::String
  • trimStdString() : vl::String
  • twoSide() : vl::LightModel
  • type()
: vl::LineStipple
, vl::Material
, vl::ClipPlane
, vl::ColorMask
, vl::ShadeModel
, vlMolecule::AtomInfo
, vl::RenderState
, vl::Fog
, vl::GLSLProgram
, vl::PolygonStipple
, vl::Image
, vl::StencilOp
, vl::Uniform
, vl::Billboard
, vl::LogicOp
, vl::GLSLShader
, vl::StencilMask
, vl::PolygonOffset
, vl::Hint
, vl::AlphaFunc
, vl::DepthFunc
, vl::DepthRange
, vl::StencilFunc
, vl::BlendFunc
, vl::PointParameter
, vl::TextureMatrix
, vl::BlendEquation
, vl::FBOColorBufferAttachment
, vl::FBODepthStencilBufferAttachment
, vl::DepthMask
, vl::PixelTransfer
, vl::CullFace
, vl::PolygonMode
, vl::FBOStencilBufferAttachment
, vl::FBODepthBufferAttachment
, vl::BlendColor
, vl::TexEnv
, vl::TextureUnit
, vl::FrontFace
, vl::LightModel
, vl::TexGen
, vl::PointSize
, vl::SampleCoverage
, vl::LineWidth
, vl::Light
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- u -

  • UIEventListener() : vl::UIEventListener
  • unbindFragDataLocation() : vl::GLSLProgram
  • uncompressedSize()
: vl::ZippedFileInfo
, vl::GZipCodec
  • ungetLine() : vl::TextStream
  • ungetToken() : vl::BufferedStream< Element_Type, Chunk_Size >
  • Uniform() : vl::Uniform
  • uniforms()
: vl::Actor
, vl::Shader
, vl::UniformSet
  • uniformSet()
: vl::Actor
, vl::GLSLProgram
  • UniformSet() : vl::UniformSet
  • united() : vl::Rect< T >
  • units() : vl::PolygonOffset
  • unmapGPUBuffer() : vl::GLBufferObject
  • unproject() : vl::Camera
  • update()
: vl::Actor
, vl::MorphingActor
, vl::OpenGLContext
, vl::Shader
, vlQt4::Qt4Widget
, vlWX::vlWXGLCanvas
, vlWin32::Win32Context
, vlGLUT::GLUTWindow
, vlSDL::SDLWindow
, vlVolume::SlicedVolume
  • updateActorCache() : vl::EdgeRenderer
  • updateAlpha() : vlVolume::MarchingCubes
  • updateBezierSurface() : vl::BezierSurface
  • updateColor() : vlVolume::MarchingCubes
  • updateHierachy() : vl::ShaderNode
  • updateModifiers() : vlGLUT::GLUTWindow
  • updateOverlay() : vlGLUT::GLUTWindow
  • updatePitch() : vl::Image
  • updateTime() : vl::RenderingAbstract
  • updateUniforms() : vlVolume::SlicedVolume
  • updateVBO() : vl::ArrayAbstract
  • updateVBOs()
: vl::DrawArrays
, vl::Geometry
, vl::DrawElements< index_type, Tgltype, arr_type >
, vl::Renderable
, vl::Primitives
, vl::Geometry
  • usage()
: vl::ArrayAbstract
, vl::GLBufferObject
  • useAtomColors() : vlMolecule::Bond
  • useCameraRotationInverse() : vl::TextureMatrix
  • useDisplayLists() : vl::GeometryLoadCallback
  • useGLSL() : vl::Terrain
  • usePixelBufferObject() : vl::DrawPixels
  • useProgram() : vl::GLSLProgram
  • useVBOs() : vl::GeometryLoadCallback
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- v -

  • valence() : vlMolecule::AtomInfo
  • valid() : vl::ObjTexture
  • validateProgram() : vl::GLSLProgram
  • value()
: vl::KeyValues
, vlVolume::Volume
, vl::SampleCoverage
, vlVolume::Volume
  • values() : vlVolume::Volume
  • vanDerWaalsRadius() : vlMolecule::AtomInfo
  • vboDirty()
: vl::ArrayAbstract
, vl::Renderable
  • vboEnabled() : vl::Renderable
  • vector()
: vl::Collection< T >
, vl::PolygonSimplifier::QErr
  • Vector2() : vl::Vector2< scalar_type >
  • Vector3() : vl::Vector3< scalar_type >
  • Vector4() : vl::Vector4< scalar_type >
  • vectorAsVec4() : vl::ArrayAbstract , vl::Array< vector_type, scalar_type, gl_size, gl_type >
  • vectorGraphicObjects() : vlVG::SceneManagerVectorGraphics
  • VectorGraphics() : vlVG::VectorGraphics
  • verbose() : vl::PolygonSimplifier
  • versionNeeded() : vl::ZippedFileInfo
  • versionString() : vl::VisualizationLibrary
  • vert0() : vlVolume::VolumeInfo
  • vertC() : vlVolume::VolumeInfo
  • vertex() : vl::PolygonSimplifier::Triangle
  • Vertex() : vl::PolygonSimplifier::Vertex
  • vertex1() : vl::EdgeExtractor::Edge
  • vertex2() : vl::EdgeExtractor::Edge
  • vertexArray()
: vl::Geometry
, vl::ObjLoader
  • VertexAttributeArray() : vl::VertexAttributeArray
  • vertexAttributeArrays() : vl::Geometry
  • vertexShader() : vl::Terrain
  • viewMatrix() : vl::Camera
  • viewport() : vl::Camera
  • Viewport() : vl::Viewport
  • viewport() : vl::Camera
  • viewportAlignment() : vl::Text
  • VirtualDirectory() : vl::VirtualDirectory
  • VirtualFile() : vl::VirtualFile
  • visibilityEvent() : vl::UIEventListener
  • visible()
: vlMolecule::Atom
, vlMolecule::Bond
  • visited() : vlMolecule::Atom
  • visitSector() : vl::SceneManagerPortals
  • vlWXGLCanvas() : vlWX::vlWXGLCanvas
  • Volume() : vlVolume::Volume
  • volume()
: vlVolume::VolumeInfo
, vl::AABB
  • volumeInfo() : vlVolume::MarchingCubes
  • VolumeInfo() : vlVolume::VolumeInfo
  • volumeInfo() : vlVolume::MarchingCubes
  • VolumeInfo() : vlVolume::VolumeInfo
  • VolumePlot() : vlVolume::VolumePlot
  • volumes() : vl::Sector
  • vSync() : vl::OpenGLContextFormat
  • vsyncEnabled() : vl::OpenGLContext
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- w -

  • w()
: vl::quat
, vl::Vector4< scalar_type >
  • warning() : vl::Log
  • warnNonManifold() : vl::EdgeExtractor
  • warnOnSeek() : vl::GZipCodec
  • wheelEvent() : vlQt4::Qt4Widget
  • width()
: vl::OpenGLContext
, vl::ReadPixels
, vl::AABB
, vl::Rect< T >
, vl::RenderTarget
, vl::CopyTexSubImage1D
, vl::Terrain
, vl::Texture
, vl::CopyTexSubImage2D
, vl::Viewport
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::FBORenderbufferAttachment
, vl::Image
  • Win32Context() : vlWin32::Win32Context
  • Win32Window() : vlWin32::Win32Window
  • windingRule() : vl::Tessellator
  • windowClassName() : vlWin32::Win32Window
  • WindowProc() : vlWin32::Win32Window
  • windowSize() : vlWin32::Win32Context
  • winMap() : vlWin32::Win32Window
  • wireframeStyle() : vlMolecule::Molecule
  • worldMatrix() : vl::Transform
  • worldMatrixUpdateTick() : vl::Transform
  • wrapR() : vl::TexParameter
  • wrapS() : vl::TexParameter
  • wrapT() : vl::TexParameter
  • write() : vl::VirtualFile
  • write_Implementation()
: vl::DiskFile
, vl::GZipCodec
, vl::MemoryFile
, vl::VirtualFile
, vl::ZippedFile
  • writeCallbacks() : vl::LoadWriterManager
  • writeExtensions() : vl::ResourceLoadWriter
  • writeResource()
: vl::LoadWriter3DS
, vl::LoadWriterTGA
, vl::LoadWriterManager
, vl::LoadWriterJPG
, vl::LoadWriterPLY
, vl::LoadWriterSTL
, vl::LoadWriterMD2
, vl::LoadWriterTIFF
, vl::LoadWriterAC3D
, vl::LoadWriterDDS
, vl::LoadWriterDAT
, vl::LoadWriterDICOM
, vl::LoadWriterAC3D
, vl::LoadWriterOBJ
, vl::ResourceLoadWriter
, vl::LoadWriterPLY
, vl::LoadWriter3DS
, vl::LoadWriterSTL
, vl::LoadWriterOBJ
, vl::LoadWriterTIFF
, vl::ResourceLoadWriter
, vl::LoadWriterPNG
, vl::LoadWriterMD2
, vl::LoadWriterDAT
, vl::LoadWriterDICOM
, vl::LoadWriterJPG
, vl::LoadWriterManager
, vl::LoadWriterBMP
, vl::LoadWriterDDS
, vl::LoadWriterBMP
  • writeSInt16() : vl::VirtualFile
  • writeSInt32() : vl::VirtualFile
  • writeSInt8() : vl::VirtualFile
  • writeUInt16() : vl::VirtualFile
  • writeUInt32() : vl::VirtualFile
  • writeUInt8() : vl::VirtualFile
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- x -

  • x()
: vl::BezierPatch
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::Vector2< scalar_type >
, vl::quat
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::CopyTexSubImage2D
, vl::quat
, vl::Viewport
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::ReadPixels
  • xDegrees() : vl::GhostCameraManipulator
  • xoffset()
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
  • xy()
: vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
  • xyz() : vl::Vector4< scalar_type >
  • xyzw() : vl::quat
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~

- y -

  • y()
: vl::BezierPatch
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::Rect< T >
, vl::Vector2< scalar_type >
, vl::quat
, vl::Viewport
, vl::Vector4< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::CopyTexSubImage2D
, vl::quat
, vl::ReadPixels
  • yDegrees() : vl::GhostCameraManipulator
  • year()
: vl::Time
, vl::ZippedFileInfo
  • yoffset()
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Related Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions

  • DiskDirectory : vl::DiskFile
  • DrawPixels : vl::DrawPixels::Pixels
  • FBORenderTarget : vl::FBOAttachmentAbstract , vl::FBORenderbufferAttachment
  • FontManager : vl::Font
  • GLSLProgram : vl::Uniform
  • MorphingCallback : vl::MorphingActor
  • OpenGLContext
: vl::FBORenderTarget
, vl::UIEventListener
, vl::RenderTarget
  • PolygonSimplifier : vl::PolygonSimplifier::Triangle , vl::PolygonSimplifier::Vertex
  • Renderer : vl::GLSLProgram
  • Say : vl::SayArg
  • SceneManagerPortals : vl::Portal
  • Text : vl::Font
  • Triangle : vl::PolygonSimplifier::Vertex
  • Vertex : vl::PolygonSimplifier::Triangle
  • ZippedDirectory : vl::ZippedFileInfo
  • ZippedFile : vl::ZippedFileInfo
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions

  • Points : vl::BezierPatch
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- a -

  • a2 : vl::PolygonSimplifier::QErr
  • ab : vl::PolygonSimplifier::QErr
  • ac : vl::PolygonSimplifier::QErr
  • ad : vl::PolygonSimplifier::QErr
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- m -

  • mA : vl::A3DSTriFace
  • mAABB
: vl::Actor
, vl::SceneManager
, vl::ActorTreeAbstract
  • mAccumRGBABits : vl::OpenGLContextFormat
  • mActive : vl::Camera
  • mActor : vl::RenderToken , vl::RayIntersection
  • mActorAnimationEnabled : vl::Rendering
  • mActorCache : vl::EdgeRenderer
  • mActorQueue : vl::Rendering
  • mActorRenderRankStart : vlVG::SceneManagerVectorGraphics
  • mActors
: vlVolume::VolumePlot
, vl::ActorTreeAbstract
, vl::RayIntersector
, vl::Sector
  • mActorTree : vlMolecule::Molecule
  • mActorTreeMulti : vlVolume::VolumePlot
  • mAdjacentAtoms : vlMolecule::Atom
  • mAdjacentVerts : vl::PolygonSimplifier::Vertex
  • mAdvance : vl::Glyph
  • mAlign : vl::DrawPixels::Pixels
  • mAlignment : vl::Buffer , vl::Text
  • mAlpha : vl::ColorMask
  • mAlphaBias : vl::PixelTransfer
  • mAlphaFunc : vl::AlphaFunc
  • mAlphaScale : vl::PixelTransfer , vl::TexEnv
  • mAlreadyProcessed : vl::PolygonSimplifier::Vertex
  • mAmbient : vl::A3DSMaterial , vl::Light
  • mAmbientColor : vl::LightModel
  • mAnim_t : vl::MorphingActor
  • mAnim_t_Binding : vl::MorphingActor
  • mAnimationEnd : vl::MorphingActor
  • mAnimationPeriod : vl::MorphingActor
  • mAnimationStart : vl::MorphingActor
  • mAnimationStarted : vl::MorphingActor
  • mAnimationStartTime : vl::MorphingActor
  • mAnisotropy : vl::TexParameter
  • mAromaticRingColor : vlMolecule::Molecule
  • mAssumeIdentityWorldMatrix : vl::Transform
  • mAtom1 : vlMolecule::Bond
  • mAtom2 : vlMolecule::Bond
  • mAtomDetail : vlMolecule::Molecule
  • mAtomicMass : vlMolecule::AtomInfo
  • mAtomicNumber : vlMolecule::AtomInfo
  • mAtomLabelEffect : vlMolecule::Molecule
  • mAtomLabelTemplate : vlMolecule::Molecule
  • mAtomName : vlMolecule::Atom
  • mAtoms : vlMolecule::Molecule
  • mAtomType : vlMolecule::Atom
  • mAttribIndex : vl::VertexAttributeArray
  • mAutomaticResourceInit : vl::Rendering
  • mAverage : vlVolume::Volume
  • mAxis : vl::Billboard
  • mB : vl::A3DSTriFace
  • mBackAmbient : vl::Material
  • mBackDiffuse : vl::Material
  • mBackEmission : vl::Material
  • mBackFace : vl::PolygonMode
  • mBackgroundColor : vl::Text
  • mBackgroundEnabled : vl::Text
  • mBackShininess : vl::Material
  • mBackSpecular : vl::Material
  • mBinary : vl::PlyLoader
  • mBlendColor : vl::BlendColor
  • mBlendingEnabled : vl::EnableSet
  • mBlendU : vl::ObjTexture
  • mBlendV : vl::ObjTexture
  • mBlue : vl::ColorMask
  • mBlueBias : vl::PixelTransfer
  • mBlueScale : vl::PixelTransfer
  • mBM : vl::ObjTexture
  • mBoilingPoint : vlMolecule::AtomInfo
  • mBondDetail : vlMolecule::Molecule
  • mBonds : vlMolecule::Molecule
  • mBorder : vl::Texture::SetupParams , vl::Texture
  • mBorderColor : vl::Text , vl::TexParameter
  • mBorderEnabled : vl::Text
  • mBottomLeft : vlVolume::Volume
  • mBoundaryOnly : vl::Tessellator
  • mBoundingVolumeTree : vl::SceneManagerBVH< T >
  • mBoundsDirty : vl::SceneManager
  • mBoundsUpdateTick : vl::Actor
  • mBox : vlVolume::SlicedVolume
  • mBoxEffect : vlVolume::VolumePlot
  • mBuffer : vl::BufferedStream< Element_Type, Chunk_Size > , vl::MemoryFile
  • mBufferGPU : vl::ArrayAbstract
  • mBufferMask : vl::BlitFramebuffer
  • mByteAlign : vl::Image
  • mByteCount : vl::Buffer
  • mByteCountGPU : vl::GLBufferObject
  • mC : vl::A3DSTriFace
  • mCache : vlVolume::SlicedVolume
  • mCacheMatrix : vl::DepthSortCallback
  • mCalculatedRadius : vlMolecule::AtomInfo
  • mCallbacks : vl::Sector
  • mCamera
: vl::GhostCameraManipulator
, vl::Rendering
, vl::TrackballManipulator
  • mCameraDistance : vl::RenderToken
  • mCatmullRomSpline : vl::CatmullRomInterpolator< T >
  • mCC : vl::ObjTexture
  • mCellSize : vlVolume::Volume
  • mCenter : vl::Sphere
  • mChar : vl::PlyLoader::PlyScalar
  • mChildN : vl::ActorKdTree
  • mChildP : vl::ActorKdTree
  • mChildren : vl::ActorTree , vl::Transform
  • mChunkId : vl::A3DSLoader
  • mChunkLen : vl::A3DSLoader
  • mChunks : vl::Terrain
  • mClamp : vl::ObjTexture
  • mClassName : vlMFC::MFCWindow
  • mClearColor : vl::Viewport
  • mClearColorBuffer : vl::Clear
  • mClearColorInt : vl::Viewport
  • mClearColorMode : vl::Clear , vl::Viewport
  • mClearColorUInt : vl::Viewport
  • mClearColorValue : vl::Clear
  • mClearColorValueInt : vl::Clear
  • mClearColorValueUInt : vl::Clear
  • mClearDepth : vl::Viewport
  • mClearDepthBuffer : vl::Clear
  • mClearDepthValue : vl::Clear
  • mClearFlags : vl::Rendering , vl::Viewport
  • mClearStencil : vl::Viewport
  • mClearStencilBuffer : vl::Clear
  • mClearStencilValue : vl::Clear
  • mCollapseCost : vl::PolygonSimplifier::Vertex
  • mCollapsePosition : vl::PolygonSimplifier::Vertex
  • mCollapseVertex : vl::PolygonSimplifier::Vertex
  • mCollectStatistics : vl::Renderer
  • mColor
: vl::Fog
, vl::TexEnv
, vl::Text
, vl::PlyLoader::PlyElement
, vlVolume::VolumeInfo
, vlMolecule::Atom
, vlMolecule::Bond
  • mColorArray : vlVolume::MarchingCubes
  • mColorControl : vl::LightModel
  • mColorMaterial : vl::Material
  • mColorMaterialEnabled : vl::Material
  • mColorMaterialFace : vl::Material
  • mColorPath : vl::Extrusion
  • mColors : vl::PlyLoader
  • mCombineAlpha : vl::TexEnv
  • mCombinedVertices : vl::Tessellator
  • mCombineRGB : vl::TexEnv
  • mCompareFunc : vl::TexParameter
  • mCompareMode : vl::TexParameter
  • mCompiled : vl::GLSLShader
  • mCompressedSize : vl::ZippedFileInfo
  • mCompression : vl::LoadWriterPNG
  • mCompressionLevel : vl::GZipCodec
  • mCompressionMethod : vl::ZippedFileInfo
  • mComputeNormals : vl::GeometryLoadCallback
  • mConstantAttenuation : vl::Light
  • mContinuousUpdate : vl::OpenGLContext
  • mContours : vl::Tessellator
  • mContourVerts : vl::Tessellator
  • mControlPoints : vl::BezierPatch
  • mConvertToDrawArrays : vl::GeometryLoadCallback
  • mCoordinates : vlMolecule::Atom
  • mCoords : vl::ObjLoader
  • mCoordSystem : vl::A3DSObject
  • mCorrupted : vl::A3DSLoader
  • mCount : vl::DrawArrays
  • mCountType : vl::PlyLoader::PlyScalarList
  • mCovalentRadius : vlMolecule::AtomInfo
  • mCPKColor : vlMolecule::AtomInfo
  • mCRC32 : vl::CRC32CheckSum , vl::ZippedFileInfo
  • mCreaseAngle : vl::EdgeExtractor , vl::EdgeRenderer
  • mCubeEdgeFlags : vlVolume::MarchingCubes
  • mCubes : vlVolume::Volume
  • mCullingEnabled : vl::Rendering , vl::SceneManager
  • mCurrentEnable : vl::Renderer
  • mCurrentRenderState : vl::Renderer
  • mCurrentUniform : vl::Renderer
  • mCycles : vlMolecule::Molecule
  • mData : vl::VertexAttributeArray , vl::PlyLoader::PlyScalar
  • mDataIsDirty : vlVolume::Volume
  • mDay : vl::ZippedFileInfo
  • mDayOfMonth : vl::Time
  • mDayOfWeek : vl::Time
  • mDefaultLineColor : vl::EdgeRenderer
  • mDefaultRenderStates : vl::Renderer
  • mDensity : vl::Fog
  • mDepth
: vl::Image
, vl::Terrain
, vl::Texture
  • mDepthBias : vl::PixelTransfer
  • mDepthFunc : vl::DepthFunc
  • mDepthMask : vl::DepthMask
  • mDepthScale : vl::PixelTransfer
  • mDepthSortMode : vl::RenderQueueSorterStandard , vl::RenderQueueSorterAggressive
  • mDepthTextureMode : vl::TexParameter
  • mDetail : vl::BezierSurface
  • mDetailRepetitionCount : vl::Terrain
  • mDetailTexture : vl::Terrain
  • mDetailTextureFormat : vl::Terrain
  • mDiffuse : vl::Light , vl::A3DSMaterial
  • mDimension : vl::Texture::SetupParams , vl::Texture
  • mDirection : vl::Ray
  • mDirectories : vl::FileSystem
  • mDirty : vl::TexParameter
  • mDiscardOriginalNormals : vl::GeometryLoadCallback
  • mDistance : vl::RayIntersection , vl::RayIntersectionGeometry
  • mDistanceAttenuation : vl::PointParameter
  • mDistanceRangeSet : vl::DistanceLODEvaluator
  • mDouble : vl::PlyLoader::PlyScalar
  • mDoubleSided : vl::A3DSMaterial
  • mDpFail_Back : vl::StencilOp
  • mDpFail_Front : vl::StencilOp
  • mDpPass_Back : vl::StencilOp
  • mDpPass_Front : vl::StencilOp
  • mDrawBuffers : vl::RenderTarget
  • mDrawElements : vlVolume::MarchingCubes
  • mDrawFramebuffer : vl::BlitFramebuffer
  • mDraws : vl::DrawPixels
  • mDstAlpha : vl::BlendFunc
  • mDstRect : vl::BlitFramebuffer
  • mDstRGB : vl::BlendFunc
  • mEdges : vl::EdgeExtractor
  • mEffect : vl::Actor , vlVolume::SlicedVolume
  • mEffectRenderRank : vl::RenderToken
  • mElapsedTime : vl::MorphingActor
  • mElectronAffinity : vlMolecule::AtomInfo
  • mElectronegativity : vlMolecule::AtomInfo
  • mElemCount : vl::PlyLoader::PlyElement
  • mElements : vl::PlyLoader
  • mEmpiricalRadius : vlMolecule::AtomInfo
  • mEnabled : vl::Primitives , vl::UIEventListener
  • mEnableMask
: vl::SceneManager
, vl::Actor
, vl::Effect
, vl::RenderingAbstract
  • mEnables : vl::EnableSet , vl::ShaderNode
  • mEnables_Final : vl::ShaderNode
  • mEnableSet : vl::Shader
  • mEnableTable : vl::Renderer
  • mEnd : vl::Fog
  • mEvaluateLOD : vl::Rendering
  • mEventListeners : vl::OpenGLContext
  • mExStyle : vlWin32::Win32Window
  • mExternalSector : vl::SceneManagerPortals
  • mExtraFieldLength : vl::ZippedFileInfo
  • mEyePlaneQ : vl::TexGen
  • mEyePlaneR : vl::TexGen
  • mEyePlaneS : vl::TexGen
  • mEyePlaneT : vl::TexGen
  • mEyeSpaceVerts : vl::DepthSortCallback
  • mFace_icoords : vl::ObjMesh
  • mFace_inormals : vl::ObjMesh
  • mFace_itexcoords : vl::ObjMesh
  • mFace_type : vl::ObjMesh
  • mFaceList : vl::A3DSObject
  • mFaceMode : vl::CullFace
  • mFactor : vl::PolygonOffset , vl::LineStipple
  • mFadeThresholdSize : vl::PointParameter
  • mFans : vl::Tessellator
  • mFarPlane : vl::Camera
  • mFBOAttachments : vl::FBORenderTarget
  • mFBORenderTarget : vl::OpenGLContext
  • mFBORenderTargets : vl::FBOAttachmentAbstract
  • mFileName
: vl::A3DSTexture
, vl::ObjTexture
, vl::ZippedFileInfo
  • mFileNameLength : vl::ZippedFileInfo
  • mFilePath : vl::Font
  • mFiles : vl::MemoryDirectory , vl::ZippedDirectory
  • mFillBottom : vl::Extrusion
  • mFillTop : vl::Extrusion
  • mFlags : vl::A3DSTriFace
  • mFloat : vl::PlyLoader::PlyScalar
  • mFloatData : vl::Uniform
  • mFly : vlut::Applet
  • mFogHint : vl::Hint
  • mFollowedTransform : vl::ClipPlane , vl::Light
  • mFollowTransform : vl::Camera
  • mFont : vl::Glyph , vl::Text
  • mFonts : vl::FontManager
  • mFormat
: vl::Image
, vl::Texture::SetupParams
, vl::Texture
  • mFOV : vl::Camera
  • mFPS : vlut::Applet
  • mFragDataLocation : vl::GLSLProgram
  • mFragmentShader : vl::Terrain
  • mFrame1 : vl::MorphingActor
  • mFrame2 : vl::MorphingActor
  • mFrameCount : vlut::Applet
  • mFrontAmbient : vl::Material
  • mFrontDiffuse : vl::Material
  • mFrontEmission : vl::Material
  • mFrontFace : vl::FrontFace , vl::PolygonMode
  • mFrontShininess : vl::Material
  • mFrontSpecular : vl::Material
  • mFrustum : vl::Camera , vl::RayIntersector
  • mFrustumStack : vl::SceneManagerPortals
  • mFT_Face : vl::Font
  • mFullscreen : vl::OpenGLContextFormat , vl::OpenGLContext
  • mFunction_Back : vl::StencilFunc
  • mFunction_Front : vl::StencilFunc
  • mGeneralPurposeFlag : vl::ZippedFileInfo
  • mGenerateMipmap : vl::TexParameter
  • mGenerateMipmapHint : vl::Hint
  • mGenModeQ : vl::TexGen
  • mGenModeR : vl::TexGen
  • mGenModeS : vl::TexGen
  • mGenModeT : vl::TexGen
  • mGeometry
: vl::MorphingActor
, vl::RayIntersectionGeometry
, vlVolume::SlicedVolume
  • mGeometryInputType : vl::GLSLProgram
  • mGeometryOutputType : vl::GLSLProgram
  • mGeometryVerticesOut : vl::GLSLProgram
  • mGLContextInfo : vl::OpenGLContext
  • mGLSLProgram : vl::RenderStateSet , vlVolume::SlicedVolume
  • mGLSLVertexBlendEnabled : vl::MorphingActor
  • mGlyphIndex : vl::Glyph
  • mGlyphMap : vl::Font
  • mGreen : vl::ColorMask
  • mGreenBias : vl::PixelTransfer
  • mGreenScale : vl::PixelTransfer
  • mHandle
: vl::DiskFile
, vl::FBORenderbufferAttachment
, vl::FBORenderTarget
, vl::GLBufferObject
, vl::GLSLShader
, vl::GLSLProgram
, vl::Texture
, vlGLUT::GLUTWindow
  • mHasDoubleBuffer : vl::OpenGLContextFormat
  • mHasMipmaps : vl::Texture::SetupParams , vl::Texture
  • mHasMultisample : vl::OpenGLContextFormat
  • mHDC : vlWin32::Win32Context
  • mHeight
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::Glyph
, vl::Font
, vl::FBORenderbufferAttachment
, vl::Image
, vl::ReadPixels
, vl::Rect< T >
, vl::RenderTarget
, vl::Terrain
, vl::Texture
, vl::Viewport
  • mHeightmapTexture : vl::Terrain
  • mHeightmapTextureFormat : vl::Terrain
  • mHGLRC : vlWin32::Win32Context
  • mHour : vl::Time , vl::ZippedFileInfo
  • mHWND : vlWin32::Win32Window
  • mId
: vlMolecule::Atom
, vlMolecule::Bond
, vlMolecule::Molecule
  • mIgnoreNextMouseMoveEvent : vl::OpenGLContext
  • mIllum : vl::ObjMaterial
  • mImage
: vl::DrawPixels::Pixels
, vl::ReadPixels
, vl::Texture::SetupParams
  • mImagePath : vl::Texture::SetupParams
  • mImfchan : vl::ObjTexture
  • mIncidentTriangles : vl::PolygonSimplifier::Vertex
  • mIndex : vl::A3DSVertex
  • mIndexBuffer : vl::DrawElements< index_type, Tgltype, arr_type >
  • mIndexOffset : vl::PixelTransfer
  • mIndexShift : vl::PixelTransfer
  • mIndices : vl::PlyLoader
  • mInited : vlGLUT::GLUTWindow
  • mInputFile : vl::BufferedStream< Element_Type, Chunk_Size > , vl::A3DSLoader
  • mInstances : vl::Primitives
  • mInt : vl::PlyLoader::PlyScalar
  • mIntData : vl::Uniform
  • mInterlineSpacing : vl::Text
  • mInterpolator
: vl::CatmullRomInterpolatorFVec4
, vl::CatmullRomInterpolatorFVec3
, vl::CatmullRomInterpolatorFVec2
, vl::CatmullRomInterpolatorFloat
, vl::CatmullRomInterpolatorDVec4
, vl::CatmullRomInterpolatorDVec3
, vl::CatmullRomInterpolatorDVec2
, vl::CatmullRomInterpolatorDouble
, vl::LinearInterpolatorFVec4
, vl::LinearInterpolatorFVec3
, vl::LinearInterpolatorFVec2
, vl::LinearInterpolatorFloat
, vl::LinearInterpolatorDVec4
, vl::LinearInterpolatorDVec3
, vl::LinearInterpolatorDVec2
, vl::LinearInterpolatorDouble
  • mIntersectionPoint : vl::RayIntersection , vl::RayIntersectionGeometry
  • mIntersections : vl::RayIntersector
  • mInverseViewMatrix : vl::Camera
  • mInvert : vl::SampleCoverage
  • mIsCrease : vl::EdgeExtractor::Edge
  • mIsCubemap : vl::Image
  • mIsOccludee : vl::Actor
  • mIsOpen : vl::MemoryFile , vl::Portal
  • mIsosurfaceActor : vlVolume::VolumePlot
  • mIsosurfaceEffect : vlVolume::VolumePlot
  • mIsosurfaceGeometry : vlVolume::VolumePlot
  • mKa : vl::ObjMaterial
  • mKd : vl::ObjMaterial
  • mKerningEnabled : vl::Text
  • mKeyboard : vl::OpenGLContext
  • mKeymap : vlGLUT::GLUTWindow
  • mKeysBackward : vl::GhostCameraManipulator
  • mKeysDown : vl::GhostCameraManipulator
  • mKeysForward : vl::GhostCameraManipulator
  • mKeysLeft : vl::GhostCameraManipulator
  • mKeysRight : vl::GhostCameraManipulator
  • mKeysUp : vl::GhostCameraManipulator
  • mKeyValues : vl::KeyValues
  • mKs : vl::ObjMaterial
  • mLabelFont : vlVolume::VolumePlot
  • mLabelFormat : vlVolume::VolumePlot
  • mLastTime : vl::GhostCameraManipulator
  • mLastUpdate : vl::MorphingActor
  • mLastUpdateTime : vl::Actor , vl::Shader
  • mLayer : vl::FBOTexture3DAttachment , vl::FBOTextureLayerAttachment
  • mLayout : vl::Text
  • mLeft : vl::Glyph
  • mLevel
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage2D
, vl::CopyTexSubImage3D
, vl::FBOTexture1DAttachment
, vl::FBOTexture2DAttachment
, vl::FBOTextureAttachment
  • mLight : vlVolume::SlicedVolume
  • mLightIndex : vl::Light
  • mLinearAttenuation : vl::Light
  • mLinearFilteringEnabled : vl::BlitFramebuffer
  • mLinearSpline : vl::LinearInterpolator< T >
  • mLineLoops : vl::Tessellator
  • mLineSmoothHint : vl::Hint
  • mLineWidth
: vl::EdgeRenderer
, vl::LineWidth
, vlMolecule::Molecule
  • mList : vl::RenderQueue
  • mListMP : vl::RenderQueue
  • mLittleEndian : vl::PlyLoader
  • mLoadCallbacks : vl::LoadWriterManager
  • mLoadExtensions : vl::ResourceLoadWriter
  • mLoadWriters : vl::LoadWriterManager
  • mLocalMatrix : vl::Transform
  • mLocalViewer : vl::LightModel
  • mLodBias : vl::TexEnv
  • mLODEvaluator : vl::Actor , vl::Effect
  • mLODShaders : vl::Effect
  • mLogFile : vl::StandardLog
  • mLogger : vl::Log
  • mLogicOp : vl::LogicOp
  • mMagfilter : vl::TexParameter
  • mMap_Bump : vl::ObjMaterial
  • mMap_d : vl::ObjMaterial
  • mMap_Decal : vl::ObjMaterial
  • mMap_Disp : vl::ObjMaterial
  • mMap_Ka : vl::ObjMaterial
  • mMap_Kd : vl::ObjMaterial
  • mMap_Ks : vl::ObjMaterial
  • mMap_Ns : vl::ObjMaterial
  • mMapColor : vl::PixelTransfer
  • mMapNewToOld : vl::DoubleVertexRemover
  • mMapOldToNew : vl::DoubleVertexRemover
  • mMappedFace : vl::A3DSMaterialFaceMapping
  • mMapStencil : vl::PixelTransfer
  • mMargin : vl::Text
  • mMask : vl::PolygonStipple
  • mMask_Back : vl::StencilFunc , vl::StencilMask
  • mMask_Front : vl::StencilFunc , vl::StencilMask
  • mMaterial : vl::ObjMesh
  • mMaterialIndex : vl::A3DSTriFace
  • mMaterialName
: vl::A3DSMaterial
, vl::A3DSMaterialFaceMapping
, vl::A3DSObject
  • mMaterials : vl::A3DSLoader , vl::ObjLoader
  • mMatFaceMap : vl::A3DSObject
  • mMatrix
: vl::GeometryLoadCallback
, vl::TextureMatrix
, vl::Text
  • mMax : vl::AABB
  • mMaxCorner : vlVolume::VolumePlot
  • mMaximum : vlVolume::Volume
  • mMD5 : vl::MD5CheckSum
  • mMeltingPoint : vlMolecule::AtomInfo
  • mMemoryFile : vl::Font
  • mMeshes : vl::ObjLoader
  • mMicrosecond : vl::Time
  • mMin : vl::AABB
  • mMinCorner : vlVolume::VolumePlot
  • mMinFilter : vl::TexParameter
  • mMinimum : vlVolume::Volume
  • mMinute : vl::Time , vl::ZippedFileInfo
  • mMipmapLevel : vl::FBOTexture3DAttachment , vl::FBOTextureLayerAttachment
  • mMipmaps : vl::Image
  • mMM_Base : vl::ObjTexture
  • mMM_Gain : vl::ObjTexture
  • mMode
: vl::TexEnv
, vl::GZipCodec
, vl::Fog
, vl::Text
, vl::TrackballManipulator
  • mModeAlpha : vl::BlendEquation
  • mModeRGB : vl::BlendEquation
  • mMolecule : vlMolecule::RingExtractor
  • mMoleculeName : vlMolecule::Molecule
  • mMoleculeStyle : vlMolecule::Molecule
  • mMonth : vl::Time , vl::ZippedFileInfo
  • mMouseDownCount : vlWin32::Win32Window , vlMFC::MFCWindow
  • mMouseStart : vl::TrackballManipulator
  • mMouseVisible : vl::OpenGLContext
  • mMovementSpeed : vl::GhostCameraManipulator
  • mMultisampleSamples : vl::OpenGLContextFormat
  • mName
: vl::PlyLoader::PlyPropertyAbstract
, vl::PlyLoader::PlyElement
, vlMolecule::AtomInfo
, vl::Object
  • mNearFarClippingPlanesOptimized : vl::Camera
  • mNearPlane : vl::Camera
  • mNextPass : vl::RenderToken
  • mNi : vl::ObjMaterial
  • mNodes : vl::ShaderNode
  • mNormal
: vl::Billboard
, vl::Plane
, vl::PolygonSimplifier::Triangle
, vl::PlyLoader::PlyElement
, vl::Portal
  • mNormal1 : vl::EdgeExtractor::Edge
  • mNormal2 : vl::EdgeExtractor::Edge
  • mNormal2_Binding : vl::MorphingActor
  • mNormalFrames : vl::MorphingActor
  • mNormalize : vl::VertexAttributeArray
  • mNormals
: vl::MorphingActor
, vl::ObjLoader
, vl::PlyLoader
  • mNormFlags : vlWin32::Win32Context
  • mNormPosit : vlWin32::Win32Context
  • mNormsArray : vlVolume::MarchingCubes
  • mNormSize : vlWin32::Win32Context
  • mNs : vl::ObjMaterial
  • mO_UVW : vl::ObjTexture
  • mObject : vl::ref< T >
  • mObjectPlaneQ : vl::TexGen
  • mObjectPlaneR : vl::TexGen
  • mObjectPlaneS : vl::TexGen
  • mObjectPlaneT : vl::TexGen
  • mObjects : vl::A3DSLoader
  • mOcclusionCullingEnabled : vl::Renderer
  • mOcclusionQuery : vl::Actor
  • mOcclusionQueryTick : vl::Actor , vl::Renderer
  • mOcclusionQueryTickPrev : vl::Renderer
  • mOcclusionShader : vl::Renderer
  • mOcclusionThreshold : vl::Renderer
  • mOpenGLContext
: vl::Renderer
, vl::RenderTarget
, vl::UIEventListener
  • mOperand0Alpha : vl::TexEnv
  • mOperand0RGB : vl::TexEnv
  • mOperand1Alpha : vl::TexEnv
  • mOperand1RGB : vl::TexEnv
  • mOperand2Alpha : vl::TexEnv
  • mOperand2RGB : vl::TexEnv
  • mOpt_decal : vl::A3DSTexture
  • mOpt_ignore_alpha : vl::A3DSTexture
  • mOpt_mirror : vl::A3DSTexture
  • mOpt_negative : vl::A3DSTexture
  • mOpt_one_channel_tint : vl::A3DSTexture
  • mOpt_rgb_tint : vl::A3DSTexture
  • mOpt_summed_area : vl::A3DSTexture
  • mOpt_tile : vl::A3DSTexture
  • mOpt_use_alpha : vl::A3DSTexture
  • mOrigin
: vl::Plane
, vl::Terrain
, vl::Ray
  • mOriginalIndex : vl::PolygonSimplifier::Vertex
  • mOutlineColor : vl::Text
  • mOutlineEnabled : vl::Text
  • mParent
: vl::ActorTreeAbstract
, vl::ShaderNode
, vl::Transform
  • mPatches : vl::BezierSurface
  • mPath
: vl::CatmullRomInterpolator< T >
, vl::LinearInterpolator< T >
, vl::VirtualDirectory
, vl::VirtualFile
  • mPattern : vl::LineStipple
  • mPerspectiveCorrectionHint : vl::Hint
  • mPitch : vl::Image
  • mPivot : vl::TrackballManipulator
  • mPivotPoint : vl::A3DSObject
  • mPixelRangeSet : vl::PixelLODEvaluator
  • mPixels : vl::Image
  • mPlane : vl::ClipPlane , vl::ActorKdTree
  • mPlaneIndex : vl::ClipPlane
  • mPlanes : vl::Frustum
  • mPlotTransform : vlVolume::VolumePlot
  • mPointSize : vl::PointSize
  • mPointSmoothHint : vl::Hint
  • mPointSpriteCoordReplace : vl::TexEnv
  • mPolygonOffsetFactor : vl::EdgeRenderer
  • mPolygonOffsetUnits : vl::EdgeRenderer
  • mPolygonSmoothHint : vl::Hint
  • mPortalActorMap : vl::SceneManagerPortals
  • mPortalGeometry : vl::Portal
  • mPortals : vl::Sector
  • mPos : vl::A3DSVertex
  • mPosition
: vl::DrawPixels::Pixels
, vl::Light
, vl::PolygonSimplifier::Vertex
, vl::GhostCameraManipulator
  • mPositionPath : vl::Extrusion
  • mPostColorMatrixAlphaBias : vl::PixelTransfer
  • mPostColorMatrixAlphaScale : vl::PixelTransfer
  • mPostColorMatrixBlueBias : vl::PixelTransfer
  • mPostColorMatrixBlueScale : vl::PixelTransfer
  • mPostColorMatrixGreenBias : vl::PixelTransfer
  • mPostColorMatrixGreenScale : vl::PixelTransfer
  • mPostColorMatrixRedBias : vl::PixelTransfer
  • mPostColorMatrixRedScale : vl::PixelTransfer
  • mPostConvolutionAlphaBias : vl::PixelTransfer
  • mPostConvolutionAlphaScale : vl::PixelTransfer
  • mPostConvolutionBlueBias : vl::PixelTransfer
  • mPostConvolutionBlueScale : vl::PixelTransfer
  • mPostConvolutionGreenBias : vl::PixelTransfer
  • mPostConvolutionGreenScale : vl::PixelTransfer
  • mPostConvolutionRedBias : vl::PixelTransfer
  • mPostConvolutionRedScale : vl::PixelTransfer
  • mPrimitiveIndex : vl::RayIntersectionGeometry
  • mPrimitives : vl::RayIntersectionGeometry
  • mPrimitiveType : vl::Tessellator
  • mPrimitiveZ : vl::DepthSortCallback
  • mProjectionMatrix : vl::Camera
  • mProperties : vl::PlyLoader::PlyElement
  • mProtected : vl::PolygonSimplifier::Vertex
  • mProtectedVerts : vl::PolygonSimplifier
  • mPtr
: vl::BufferedStream< Element_Type, Chunk_Size >
, vl::MemoryFile
, vl::Buffer
  • mPureInteger : vl::VertexAttributeArray
  • mQErr : vl::PolygonSimplifier::Vertex
  • mQuadraticAttenuation : vl::Light
  • mQuality : vl::LoadWriterJPG
  • mQuick : vl::PolygonSimplifier
  • mRadius
: vl::Sphere
, vlMolecule::Atom
, vlMolecule::Bond
  • mRank : vl::RenderingCallback , vl::UIEventListener
  • mRasMolColor : vlMolecule::AtomInfo
  • mRay : vl::RayIntersector
  • mReadBuffer : vl::CopyTexSubImage , vl::ReadPixels
  • mReadBytes : vl::GZipCodec , vl::ZippedFile
  • mReadFramebuffer : vl::BlitFramebuffer
  • mReallocateRenderbuffer : vl::FBORenderbufferAttachment
  • mRed : vl::ColorMask
  • mRedBias : vl::PixelTransfer
  • mRedScale : vl::PixelTransfer
  • mRefValue : vl::AlphaFunc
  • mRefValue_Back : vl::StencilFunc
  • mRefValue_Front : vl::StencilFunc
  • mRemoveAfterCall : vl::RenderingCallback
  • mRemoved : vl::PolygonSimplifier::Vertex , vl::PolygonSimplifier::Triangle
  • mRemoveDoubles : vl::GeometryLoadCallback , vl::PolygonSimplifier
  • mRemoveOrder : vl::PolygonSimplifier::Vertex
  • mRenderable : vl::RenderToken
  • mRenderables : vl::Actor
  • mRenderBlock : vl::Actor
  • mRenderedLineCount : vl::Renderer
  • mRenderedPointCount : vl::Renderer
  • mRenderedRenderableCount : vl::Renderer
  • mRenderedTriangleCount : vl::Renderer
  • mRenderer : vl::Rendering
  • mRenderingCallbacks : vl::RenderingAbstract , vl::Actor
  • mRenderQueue : vl::Rendering
  • mRenderQueueSorter : vl::Rendering
  • mRenderRank : vl::Effect , vl::Actor
  • mRenderStates : vl::RenderStateSet , vl::ShaderNode
  • mRenderStates_Final : vl::ShaderNode
  • mRenderStateSet : vl::Shader
  • mRenderStateTable : vl::Renderer
  • mRenderTarget : vl::OpenGLContext , vl::Rendering
  • mResources : vl::ResourceDatabase
  • mRGBABits : vl::OpenGLContextFormat
  • mRGBScale : vl::TexEnv
  • mRingOffset : vlMolecule::Molecule
  • mRotation : vl::A3DSTexture
  • mRotationButton : vl::TrackballManipulator
  • mRotationPath : vl::Extrusion
  • mRotationSpeed : vl::TrackballManipulator , vl::GhostCameraManipulator
  • mS0 : vl::Glyph
  • mS1 : vl::Glyph
  • mS_UVW : vl::ObjTexture
  • mSamples : vl::FBORenderbufferAttachment
  • mSamplingResolution : vlVolume::VolumePlot
  • mSavePath : vl::ReadPixels
  • mScalar
: vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
, vl::Vector2< scalar_type >
  • mScalars : vl::PlyLoader::PlyScalarList
  • mScalarType : vl::PlyLoader::PlyScalarList , vl::PlyLoader::PlyScalar
  • mScalingPath : vl::Extrusion
  • mSceneBoundingSphere : vl::Camera
  • mSceneManagerActorTree : vlut::Applet
  • mSceneManagers : vl::Rendering
  • mScheduleLink : vl::GLSLProgram
  • mScissor
: vl::Shader
, vl::Scissor
, vl::Actor
  • mScissorBox : vl::Clear
  • mScreen : vlSDL::SDLWindow
  • mSecond : vl::Time , vl::ZippedFileInfo
  • mSectors : vl::SceneManagerPortals
  • mSetupParams : vl::Texture
  • mSFail_Back : vl::StencilOp
  • mSFail_Front : vl::StencilOp
  • mShadeModel : vl::ShadeModel
  • mShader : vl::ShaderNode , vl::RenderToken
  • mShaderAnimationEnabled : vl::Rendering
  • mShaderNode : vl::Terrain
  • mShaders : vl::GLSLProgram
  • mShadowColor : vl::Text
  • mShadowEnabled : vl::Text
  • mShadowVector : vl::Text
  • mShininess : vl::A3DSMaterial
  • mShininessStrength : vl::A3DSMaterial
  • mShort : vl::PlyLoader::PlyScalar
  • mShowAtomName : vlMolecule::Atom
  • mShowAtomNames : vlMolecule::Molecule
  • mShowCreases : vl::EdgeRenderer
  • mShowHiddenLines : vl::EdgeRenderer
  • mShowPortals : vl::SceneManagerPortals
  • mSilhouette : vl::Extrusion
  • mSilhouetteMode : vl::Extrusion
  • mSimplifiedIndex : vl::PolygonSimplifier::Vertex
  • mSimplifiedTriangles : vl::PolygonSimplifier
  • mSimplifiedVertices : vl::PolygonSimplifier
  • mSize
: vl::RenderQueue
, vl::Font
, vl::DrawPixels::Pixels
, vl::BufferedStream< Element_Type, Chunk_Size >
, vlVolume::Volume
  • mSizeMax : vl::PointParameter
  • mSizeMin : vl::PointParameter
  • mSizeMP : vl::RenderQueue
  • mSliceCount : vlVolume::SlicedVolume
  • mSlices : vlVolume::Volume
  • mSmooth : vl::Font , vl::Extrusion
  • mSmoothingGroup : vl::A3DSVertex , vl::A3DSTriFace
  • mSmoothLines : vlMolecule::Molecule , vl::EdgeRenderer
  • mSortedLinesUByte : vl::DepthSortCallback
  • mSortedLinesUInt : vl::DepthSortCallback
  • mSortedLinesUShort : vl::DepthSortCallback
  • mSortedPointsUByte : vl::DepthSortCallback
  • mSortedPointsUInt : vl::DepthSortCallback
  • mSortedPointsUShort : vl::DepthSortCallback
  • mSortedQuadsUByte : vl::DepthSortCallback
  • mSortedQuadsUInt : vl::DepthSortCallback
  • mSortedQuadsUShort : vl::DepthSortCallback
  • mSortedTrianglesUByte : vl::DepthSortCallback
  • mSortedTrianglesUInt : vl::DepthSortCallback
  • mSortedTrianglesUShort : vl::DepthSortCallback
  • mSortMode : vl::DepthSortCallback
  • mSortTriangles : vl::GeometryLoadCallback
  • mSortVertices : vl::GeometryLoadCallback
  • mSource : vl::GLSLShader
  • mSource0Alpha : vl::TexEnv
  • mSource0RGB : vl::TexEnv
  • mSource1Alpha : vl::TexEnv
  • mSource1RGB : vl::TexEnv
  • mSource2Alpha : vl::TexEnv
  • mSource2RGB : vl::TexEnv
  • mSourceZipFile : vl::ZippedDirectory , vl::ZippedFileInfo
  • mSpecular : vl::A3DSMaterial , vl::Light
  • mSphere : vl::Actor , vl::SceneManager
  • mSpotCutoff : vl::Light
  • mSpotDirection : vl::Light
  • mSpotExponent : vl::Light
  • mSrcAlpha : vl::BlendFunc
  • mSrcRect : vl::BlitFramebuffer
  • mSrcRGB : vl::BlendFunc
  • mStart
: vl::Fog
, vl::Time
, vl::DrawPixels::Pixels
, vl::DrawArrays
  • mStartCameraPos : vl::TrackballManipulator
  • mStartMatrix : vl::TrackballManipulator
  • mStartPivot : vl::TrackballManipulator
  • mStartTime : vlut::Applet
  • mStencilBufferBits : vl::OpenGLContextFormat
  • mStereo : vl::OpenGLContextFormat
  • mStoreInPixelBufferObject : vl::ReadPixels
  • mStream : vl::GZipCodec
  • mStreamSize : vl::GZipCodec
  • mStripfy : vl::GeometryLoadCallback
  • mStyle : vlWin32::Win32Window
  • mSubRendering : vl::RenderingTree
  • mSymbol : vlMolecule::AtomInfo
  • mT0 : vl::Glyph
  • mT1 : vl::Glyph
  • mT_UVW : vl::ObjTexture
  • mTags : vl::Image , vlMolecule::Molecule
  • mTarget : vl::CopyTexSubImage2D
  • mTargetSector : vl::Portal
  • mTempActors : vl::SceneManagerPortals
  • mTerrainTexture : vl::Terrain
  • mTerrainTextureFormat : vl::Terrain
  • mTessellatedTris : vl::Tessellator
  • mTessellateIntoSinglePolygon : vl::Tessellator
  • mTessNormal : vl::Tessellator
  • mTexCoord : vlVolume::SlicedVolume
  • mTexCoords : vl::ObjLoader
  • mTexParameter : vl::Texture
  • mTexres_Value : vl::ObjTexture
  • mText : vl::Text
  • mTextAlignment : vl::Text
  • mTextTemplate : vlVolume::VolumePlot
  • mTexture
: vl::CopyTexSubImage2D
, vl::CopyTexSubImage1D
, vl::FBOTexture3DAttachment
, vl::FBOTexture1DAttachment
, vl::TextureUnit
, vl::FBOTexture2DAttachment
, vl::FBOTextureLayerAttachment
, vl::CopyTexSubImage3D
, vl::FBOTextureAttachment
  • mTexture1 : vl::A3DSMaterial
  • mTexture2 : vl::A3DSMaterial
  • mTextureHandle : vl::Glyph
  • mTextureTarget : vl::FBOTexture2DAttachment
  • mTextureUnit : vl::RenderState
  • mTextureUnitCount : vl::OpenGLContext
  • mThreshold : vlVolume::VolumeInfo
  • mTmpStdStr : vl::TextStream
  • mTmpStr : vl::TextStream
  • mTolerance : vl::Tessellator
  • mTop : vl::Glyph
  • mTopRight : vlVolume::Volume
  • mTr : vl::ObjMaterial
  • mTrackball : vlut::Applet
  • mTransferFunction : vlVolume::SlicedVolume
  • mTransform
: vl::TrackballManipulator
, vl::Actor
, vl::Rendering
  • mTransformGeometry : vl::GeometryLoadCallback
  • mTransformTree : vlMolecule::Molecule
  • mTransformUpdateTick : vl::Actor
  • mTranslationButton : vl::TrackballManipulator
  • mTranslationSpeed : vl::TrackballManipulator
  • mTransparency : vl::A3DSMaterial
  • mTriangleConnectionTable : vlVolume::MarchingCubes
  • mTriStrips : vl::Tessellator
  • mTwoSide : vl::LightModel
  • mType
: vl::Primitives
, vl::Uniform
, vlMolecule::AtomInfo
, vl::Billboard
, vl::FBODepthBufferAttachment
, vl::FBOColorBufferAttachment
, vlMolecule::Bond
, vl::FBOStencilBufferAttachment
, vl::FBODepthStencilBufferAttachment
, vl::Image
, vl::GLSLShader
  • mUChar : vl::PlyLoader::PlyScalar
  • mUInt : vl::PlyLoader::PlyScalar
  • mUIntData : vl::Uniform
  • mUncompressedBuffer : vl::ZippedFile , vl::GZipCodec
  • mUncompressedBufferPtr : vl::GZipCodec , vl::ZippedFile
  • mUncompressedSize : vl::GZipCodec , vl::ZippedFileInfo
  • mUngetBuffer : vl::BufferedStream< Element_Type, Chunk_Size >
  • mUniformLocation : vl::GLSLProgram
  • mUniforms : vl::UniformSet , vl::ShaderNode
  • mUniforms_Final : vl::ShaderNode
  • mUniformSet
: vl::Shader
, vl::Actor
, vl::GLSLProgram
  • mUnits : vl::PolygonOffset
  • mUOffset : vl::A3DSTexture
  • mUpdateTime : vl::RenderingAbstract
  • mUpdateTimer : vlQt4::Qt4Widget
  • mUsage : vl::GLBufferObject
  • mUScale : vl::A3DSTexture
  • mUseAtomColors : vlMolecule::Bond
  • mUseCameraRotationInverse : vl::TextureMatrix
  • mUseDisplayLists : vl::GeometryLoadCallback
  • mUseGLSL : vl::Terrain
  • mUsePixelBufferObject : vl::DrawPixels
  • mUseVBOs : vl::GeometryLoadCallback
  • mUShort : vl::PlyLoader::PlyScalar
  • mUV : vl::A3DSVertex
  • mValence : vlMolecule::AtomInfo
  • mValue : vl::SampleCoverage
  • mValues : vlVolume::Volume
  • mVanDerWaalsRadius : vlMolecule::AtomInfo
  • mVBODirty : vl::ArrayAbstract
  • mVBOUsage : vl::ArrayAbstract
  • mVec
: vl::Matrix4< scalar_type >
, vl::Matrix2< scalar_type >
, vl::Matrix3< scalar_type >
  • mVector : vl::Collection< T >
  • mVectorGraphicObjects : vlVG::SceneManagerVectorGraphics
  • mVerbose : vl::PolygonSimplifier
  • mVersionNeeded : vl::ZippedFileInfo
  • mVert0 : vlVolume::VolumeInfo
  • mVertC : vlVolume::VolumeInfo
  • mVertex : vl::PlyLoader::PlyElement
  • mVertex1 : vl::EdgeExtractor::Edge
  • mVertex2 : vl::EdgeExtractor::Edge
  • mVertex2_Binding : vl::MorphingActor
  • mVertexFrames : vl::MorphingActor
  • mVertexIndex : vl::PlyLoader
  • mVertexShader : vl::Terrain
  • mVertices
: vl::PolygonSimplifier::Triangle
, vl::A3DSObject
, vl::MorphingActor
  • mVerts : vl::PlyLoader
  • mVertsArray : vlVolume::MarchingCubes
  • mViewMatrix : vl::Camera
  • mViewport : vl::Camera
  • mViewportAlignment : vl::Text
  • mVisible : vlMolecule::Atom , vlMolecule::Bond
  • mVisibleActors : vl::EdgeRenderer
  • mVisited : vlMolecule::Atom
  • mVisitTick : vl::SceneManagerPortals , vl::Portal
  • mVOffset : vl::A3DSTexture
  • mVolume : vlVolume::VolumeInfo
  • mVolumes : vl::Sector
  • mVScale : vl::A3DSTexture
  • mVSync : vl::OpenGLContextFormat
  • mWarnNonManifold : vl::EdgeExtractor
  • mWarnOnSeek : vl::GZipCodec
  • mWidth
: vl::FBORenderbufferAttachment
, vl::Glyph
, vl::Terrain
, vl::Rect< T >
, vl::CopyTexSubImage2D
, vl::RenderTarget
, vl::Viewport
, vl::CopyTexSubImage3D
, vl::ReadPixels
, vl::Texture
, vl::CopyTexSubImage1D
, vl::Image
  • mWindingRule : vl::Tessellator
  • mWindowClassName : vlWin32::Win32Window
  • mWinMap : vlGLUT::GLUTWindow , vlWin32::Win32Window
  • mWorldMatrix : vl::Transform
  • mWorldMatrixUpdateTick : vl::Transform
  • mWrapR : vl::TexParameter
  • mWrapS : vl::TexParameter
  • mWrapT : vl::TexParameter
  • mWriteCallbacks : vl::LoadWriterManager
  • mWriteExtensions : vl::ResourceLoadWriter
  • mWrittenBytes : vl::GZipCodec
  • mX
: vl::BezierPatch
, vl::Viewport
, vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage2D
, vl::ReadPixels
, vl::Rect< T >
  • mXDegrees : vl::GhostCameraManipulator
  • mXOffset
: vl::CopyTexSubImage1D
, vl::CopyTexSubImage3D
, vl::CopyTexSubImage2D
  • mXYZW : vl::quat
  • mY
: vl::BezierPatch
, vl::Rect< T >
, vl::CopyTexSubImage1D
, vl::ReadPixels
, vl::CopyTexSubImage3D
, vl::Viewport
, vl::CopyTexSubImage2D
  • mYDegrees : vl::GhostCameraManipulator
  • mYear : vl::Time , vl::ZippedFileInfo
  • mYOffset : vl::CopyTexSubImage2D , vl::CopyTexSubImage3D
  • mZBufferBits : vl::OpenGLContextFormat
  • mZFar : vl::DepthRange
  • mZipBufferIn : vl::ZippedFile , vl::GZipCodec
  • mZipBufferOut : vl::GZipCodec , vl::ZippedFile
  • mZippedFileInfo : vl::ZippedFile
  • mZippedFileOffset : vl::ZippedFileInfo
  • mZNear : vl::DepthRange
  • mZOffset : vl::CopyTexSubImage3D
  • mZoomButton : vl::TrackballManipulator
  • mZoomSpeed : vl::TrackballManipulator
  • mZStream : vl::GZipCodec , vl::ZippedFile
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- b -

  • b2 : vl::PolygonSimplifier::QErr
  • bc : vl::PolygonSimplifier::QErr
  • bd : vl::PolygonSimplifier::QErr
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- c -

  • c2 : vl::PolygonSimplifier::QErr
  • cd : vl::PolygonSimplifier::QErr
  • CHUNK_SIZE : vl::ZippedFile , vl::GZipCodec
  • crc32_table : vl::CRC32CheckSum
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- d -

  • d2 : vl::PolygonSimplifier::QErr
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- f -

  • float64 : vl::SayArg
  • format_string : vl::Say
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- s -

  • scalar_count
: vl::Vector2< scalar_type >
, vl::Vector3< scalar_type >
, vl::Vector4< scalar_type >
  • slonglong : vl::SayArg
  • str : vl::SayArg
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- t -

  • type : vl::SayArg
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- u -

  • ulonglong : vl::SayArg
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • m
  • s
  • t
  • u
  • w

- w -

  • Win32WindowClassName : vlWin32::Win32Window
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:08 2009.


Visualization Library: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Defines
  • f
  • g
  • i
  • l
  • o
  • s
  • v

- f -

  • FT_ERROR_END_LIST : Font.cpp
  • FT_ERROR_START_LIST : Font.cpp
  • FT_ERRORDEF : Font.cpp

- g -

  • GET_OR_CREATE : Shader.cpp
  • GET_OR_CREATE_IDX : Shader.cpp
  • GLEW_STATIC : OpenGL.hpp

- i -

  • INPUT_BUF_SIZE : vlJPG.cpp
  • ioBMP_INCLUDE_ONCE : vlBMP.hpp
  • ioDAT_INCLUDE_ONCE : vlDAT.hpp
  • ioDDS_INCLUDE_ONCE : vlDDS.hpp
  • ioDICOM_INCLUDE_ONCE : vlDICOM.hpp
  • ioJPG_INCLUDE_ONCE : vlJPG.hpp
  • ioPNG_INCLUDE_ONCE : vlPNG.hpp
  • ioTGA_INCLUDE_ONCE : vlTGA.hpp
  • ioTIFF_INCLUDE_ONCE : vlTIFF.hpp
  • IS_BGR8 : vlDDS.cpp
  • IS_BGRA8 : vlDDS.cpp
  • IS_BGRX8 : vlDDS.cpp
  • IS_DXT1 : vlDDS.cpp
  • IS_DXT3 : vlDDS.cpp
  • IS_DXT5 : vlDDS.cpp
  • IS_GRAY8 : vlDDS.cpp
  • IS_GRAY8_ALPHA8 : vlDDS.cpp
  • IS_PALETTE8 : vlDDS.cpp

- l -

  • Load3DS_INCLUDE_ONCE : vl3DS.hpp
  • LoadAC3D_INCLUDE_ONCE : vlAC3D.hpp
  • LoadMD2_INCLUDE_ONCE : vlMD2.hpp
  • LoadOBJ_INCLUDE_ONCE : vlOBJ.hpp
  • LoadPLY_INCLUDE_ONCE : vlPLY.hpp
  • LoadSTL_INCLUDE_ONCE : vlSTL.hpp

- o -

  • OUTPUT_BUF_SIZE : vlJPG.cpp

- s -

  • SHUFFLE_VERTICES : PolygonSimplifier.cpp

- v -

  • VL_Build : version.hpp
  • VL_BuildType : version.hpp
  • VL_CHECK : checks.hpp
  • VL_CHECK_OGL : OpenGL.hpp
  • VL_DEBUG_LIVING_OBJECTS : config.hpp
  • VL_DEFAULT_BUFFER_BYTE_ALIGNMENT : config.hpp
  • VL_FAST_SQUARE_ROOTS : config.hpp
  • VL_FLOAT_INVSQRT : Vector2.hpp
  • VL_FLOAT_SQRT : Vector2.hpp
  • VL_FORCE_CHECKS : config.hpp
  • VL_glLoadMatrix : config.hpp
  • VL_glMultMatrix : config.hpp
  • VL_Major : version.hpp
  • VL_MAX_ACTOR_LOD : config.hpp
  • VL_MAX_EFFECT_LOD : config.hpp
  • VL_MAX_TEXTURE_UNIT_COUNT : config.hpp
  • VL_MAX_TIMERS : config.hpp
  • VL_MESSAGEBOX_CHECK : config.hpp
  • VL_Minor : version.hpp
  • VL_PIPELINE_PRECISION : config.hpp
  • VL_PLATFORM_DEFAULT_ENCODING : String.hpp
  • VL_STRING_COPY_ON_WRITE : config.hpp
  • VL_TRAP : checks.hpp
  • VL_VERBOSITY_LEVEL : config.hpp
  • VL_Version : version.hpp
  • VL_WARN : checks.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Defines
  • f
  • t
  • v

- f -

  • func() : Geometry.cpp

- t -

  • translateKey() : vlWXGLCanvas.cpp

- v -

  • VL_glActiveTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glBindBuffer() : OpenGL.hpp , OpenGL.cpp
  • VL_glBindFragDataLocation() : OpenGL.cpp , OpenGL.hpp
  • VL_glBindFramebuffer() : OpenGL.hpp , OpenGL.cpp
  • VL_glBindRenderbuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendColor() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendEquation() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlendEquationSeparate() : OpenGL.hpp , OpenGL.cpp
  • VL_glBlendFuncSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glBlitFramebuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glBufferData() : OpenGL.cpp , OpenGL.hpp
  • VL_glBufferSubData() : OpenGL.cpp , OpenGL.hpp
  • VL_glCheckFramebufferStatus() : OpenGL.cpp , OpenGL.hpp
  • VL_glClientActiveTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glDeleteBuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glDeleteFramebuffers() : OpenGL.hpp , OpenGL.cpp
  • VL_glDeleteRenderbuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glDisableVertexAttribArray() : OpenGL.cpp , OpenGL.hpp
  • VL_glDrawArraysInstanced() : OpenGL.cpp , OpenGL.hpp
  • VL_glDrawElementsInstanced() : OpenGL.cpp , OpenGL.hpp
  • VL_glEnableVertexAttribArray() : OpenGL.cpp , OpenGL.hpp
  • VL_glFogCoordPointer() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferRenderbuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture1D() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture2D() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTexture3D() : OpenGL.cpp , OpenGL.hpp
  • VL_glFramebufferTextureLayer() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenBuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenerateMipmap() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenFramebuffers() : OpenGL.cpp , OpenGL.hpp
  • VL_glGenRenderbuffers() : OpenGL.hpp , OpenGL.cpp
  • VL_glGetFramebufferAttachmentParameteriv() : OpenGL.cpp , OpenGL.hpp
  • VL_glGetRenderbufferParameteriv() : OpenGL.cpp , OpenGL.hpp
  • VL_glIsFramebuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glMapBuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glPointParameterf() : OpenGL.cpp , OpenGL.hpp
  • VL_glPointParameterfv() : OpenGL.cpp , OpenGL.hpp
  • VL_glProgramParameteri() : OpenGL.cpp , OpenGL.hpp
  • VL_glRenderbufferStorage() : OpenGL.cpp , OpenGL.hpp
  • VL_glRenderbufferStorageMultisample() : OpenGL.hpp , OpenGL.cpp
  • VL_glSampleCoverage() : OpenGL.hpp , OpenGL.cpp
  • VL_glSecondaryColor3f() : OpenGL.cpp , OpenGL.hpp
  • VL_glSecondaryColorPointer() : OpenGL.hpp , OpenGL.cpp
  • VL_glStencilFuncSeparate() : OpenGL.hpp , OpenGL.cpp
  • VL_glStencilOpSeparate() : OpenGL.cpp , OpenGL.hpp
  • VL_glUniform1uiv() : OpenGL.cpp , OpenGL.hpp
  • VL_glUniform2uiv() : OpenGL.cpp , OpenGL.hpp
  • VL_glUniform3uiv() : OpenGL.hpp , OpenGL.cpp
  • VL_glUniform4uiv() : OpenGL.cpp , OpenGL.hpp
  • VL_glUnmapBuffer() : OpenGL.cpp , OpenGL.hpp
  • VL_glVertexAttribIPointer() : OpenGL.hpp , OpenGL.cpp
  • VL_glVertexAttribPointer() : OpenGL.hpp , OpenGL.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Defines

  • FT_Face : Font.hpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Defines

  • err_code : Font.cpp
  • err_msg : Font.cpp
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: dox/mainpage.dox File Reference

  • File List
  • File Members

dox/mainpage.dox File Reference

Namespaces

namespace | vl
Visualization Library namespace.
namespace | vlut
Visualization Library utility namespace.
namespace | vlVG
The Vector Graphics namespace.
namespace | vlMolecule
The Molecule Visualization namespace.
namespace | vlVolume
The Volume Rendering namespace.
namespace | vlQt4
The Qt4 bindings namespace.
namespace | vlMFC
The MFC bindings namespace.
namespace | vlWin32
The Win32 bindings namespace.
namespace | vlSDL
The SDL bindings namespace.
namespace | vlGLUT
The GLUT bindings namespace.
namespace | vlWX
The wxWidgets bindings namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- k -

  • Key_0 : vl
  • Key_1 : vl
  • Key_2 : vl
  • Key_3 : vl
  • Key_4 : vl
  • Key_5 : vl
  • Key_6 : vl
  • Key_7 : vl
  • Key_8 : vl
  • Key_9 : vl
  • Key_A : vl
  • Key_Alt : vl
  • Key_Ampersand : vl
  • Key_Asterisk : vl
  • Key_At : vl
  • Key_B : vl
  • Key_BackSlash : vl
  • Key_BackSpace : vl
  • Key_C : vl
  • Key_Caret : vl
  • Key_Clear : vl
  • Key_Colon : vl
  • Key_Comma : vl
  • Key_Ctrl : vl
  • Key_D : vl
  • Key_Delete : vl
  • Key_Dollar : vl
  • Key_Down : vl
  • Key_E : vl
  • Key_End : vl
  • Key_Equal : vl
  • Key_Escape : vl
  • Key_Exclam : vl
  • Key_F : vl
  • Key_F1 : vl
  • Key_F10 : vl
  • Key_F11 : vl
  • Key_F12 : vl
  • Key_F2 : vl
  • Key_F3 : vl
  • Key_F4 : vl
  • Key_F5 : vl
  • Key_F6 : vl
  • Key_F7 : vl
  • Key_F8 : vl
  • Key_F9 : vl
  • Key_G : vl
  • Key_Greater : vl
  • Key_H : vl
  • Key_Hash : vl
  • Key_Home : vl
  • Key_I : vl
  • Key_Insert : vl
  • Key_J : vl
  • Key_K : vl
  • Key_L : vl
  • Key_Left : vl
  • Key_LeftAlt : vl
  • Key_LeftBracket : vl
  • Key_LeftCtrl : vl
  • Key_LeftParen : vl
  • Key_LeftShift : vl
  • Key_Less : vl
  • Key_M : vl
  • Key_Minus : vl
  • Key_N : vl
  • Key_None : vl
  • Key_NumberOfKeys : vl
  • Key_O : vl
  • Key_P : vl
  • Key_PageDown : vl
  • Key_PageUp : vl
  • Key_Pause : vl
  • Key_Period : vl
  • Key_Plus : vl
  • Key_Print : vl
  • Key_Q : vl
  • Key_Question : vl
  • Key_Quote : vl
  • Key_QuoteDbl : vl
  • Key_QuoteLeft : vl
  • Key_R : vl
  • Key_Return : vl
  • Key_Right : vl
  • Key_RightAlt : vl
  • Key_RightBracket : vl
  • Key_RightCtrl : vl
  • Key_RightParen : vl
  • Key_RightShift : vl
  • Key_S : vl
  • Key_Semicolon : vl
  • Key_Shift : vl
  • Key_Slash : vl
  • Key_Space : vl
  • Key_T : vl
  • Key_Tab : vl
  • Key_U : vl
  • Key_Underscore : vl
  • Key_Unknown : vl
  • Key_Up : vl
  • Key_V : vl
  • Key_W : vl
  • Key_X : vl
  • Key_Y : vl
  • Key_Z : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- l -

  • LeftButton : vl
  • LeftToRightText : vl
  • length() : vl
  • lessThan() : vl
  • lessThanEqual() : vl
  • LinearInterpolatorDouble_T : vl
  • LinearInterpolatorDVec2_T : vl
  • LinearInterpolatorDVec3_T : vl
  • LinearInterpolatorDVec4_T : vl
  • LinearInterpolatorFloat_T : vl
  • LinearInterpolatorFVec2_T : vl
  • LinearInterpolatorFVec3_T : vl
  • LinearInterpolatorFVec4_T : vl
  • LineStipple_Dash : vlVG
  • LineStipple_Dash4 : vlVG
  • LineStipple_Dash8 : vlVG
  • LineStipple_DashDot : vlVG
  • LineStipple_DashDotDot : vlVG
  • LineStipple_Dot : vlVG
  • LineStipple_Solid : vlVG
  • LO_AND : vl
  • LO_AND_INVERTED : vl
  • LO_AND_REVERSE : vl
  • LO_CLEAR : vl
  • LO_COPY : vl
  • LO_COPY_INVERTED : vl
  • LO_EQUIV : vl
  • LO_INVERT : vl
  • LO_NAND : vl
  • LO_NOOP : vl
  • LO_NOR : vl
  • LO_OR : vl
  • LO_OR_INVERTED : vl
  • LO_OR_REVERSE : vl
  • LO_SET : vl
  • LO_XOR : vl
  • load3DS() : vl
  • loadAC3D() : vl
  • loadBMP() : vl
  • loadCubemap() : vl
  • loadDAT() : vl
  • loadDDS() : vl
  • loadDICOM() : vl
  • loadImage() : vl
  • loadImagesFromDir() : vl
  • loadJPG() : vl
  • loadMD2() : vl
  • loadMOL2() : vlMolecule
  • loadOBJ() : vl
  • loadPLY() : vl
  • loadPNG() : vl
  • loadRAW() : vl
  • loadResource() : vl
  • loadSTL() : vl
  • loadTGA() : vl
  • loadTIFF() : vl
  • locateFile() : vl
  • log() : vl
  • log10() : vl
  • log2() : vl
  • log_failed_check() : vl
  • LogBug : vl
  • LogDebug : vl
  • LogError : vl
  • LogInfo : vl
  • LogNormal : vl
  • LogWarning : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- m -

  • makeBox() : vlut
  • makeCapsule() : vlut
  • makeCircle() : vlut
  • makeColor() : vlut
  • makeCone() : vlut
  • makeCylinder() : vlut
  • makeGrid() : vlut
  • makeIcosahedron() : vlut
  • makeIcosphere() : vlut
  • makePoints() : vlut
  • makePyramid() : vlut
  • makeTorus() : vlut
  • makeUVSphere() : vlut
  • mat2 : vl
  • mat3 : vl
  • mat4 : vl
  • matrixCompMult() : vl
  • max() : vl
  • messageLoop() : vlWin32 , vlSDL
  • MiddleButton : vl
  • min() : vl
  • mix() : vl
  • mod() : vl
  • modf() : vl
  • MS_AtomsOnly : vlMolecule
  • MS_BallAndStick : vlMolecule
  • MS_Sticks : vlMolecule
  • MS_Wireframe : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- n -

  • NeverDepthSort : vl
  • NoButton : vl
  • normalize() : vl
  • notEqual() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- o -

  • OM_ReadOnly : vl
  • OM_WriteOnly : vl
  • operator!=() : vl
  • operator*() : vl
  • operator+() : vl
  • operator==() : vl
  • outerProduct() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- b -

  • BB_COLOR_BUFFER_BIT : vl
  • BB_DEPTH_BUFFER_BIT : vl
  • BB_STENCIL_BUFFER_BIT : vl
  • BE_FUNC_ADD : vl
  • BE_FUNC_REVERSE_SUBTRACT : vl
  • BE_FUNC_SUBTRACT : vl
  • BE_MAX : vl
  • BE_MIN : vl
  • BF_CONSTANT_ALPHA : vl
  • BF_CONSTANT_COLOR : vl
  • BF_DST_ALPHA : vl
  • BF_DST_COLOR : vl
  • BF_ONE : vl
  • BF_ONE_MINUS_CONSTANT_ALPHA : vl
  • BF_ONE_MINUS_CONSTANT_COLOR : vl
  • BF_ONE_MINUS_DST_ALPHA : vl
  • BF_ONE_MINUS_DST_COLOR : vl
  • BF_ONE_MINUS_SRC_ALPHA : vl
  • BF_ONE_MINUS_SRC_COLOR : vl
  • BF_SRC_ALPHA : vl
  • BF_SRC_ALPHA_SATURATE : vl
  • BF_SRC_COLOR : vl
  • BF_ZERO : vl
  • BT_Amide : vlMolecule
  • BT_Aromatic : vlMolecule
  • BT_AxisAlignedBillboard : vl
  • BT_Double : vlMolecule
  • BT_Dummy : vlMolecule
  • BT_None : vlMolecule
  • BT_Single : vlMolecule
  • BT_SphericalBillboard : vl
  • BT_Triple : vlMolecule
  • BT_Unknown : vlMolecule
  • bvec2 : vl
  • bvec3 : vl
  • bvec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- c -

  • canLoad() : vl
  • canWrite() : vl
  • CatmullRomInterpolatorDouble_T : vl
  • CatmullRomInterpolatorDVec2_T : vl
  • CatmullRomInterpolatorDVec3_T : vl
  • CatmullRomInterpolatorDVec4_T : vl
  • CatmullRomInterpolatorFloat_T : vl
  • CatmullRomInterpolatorFVec2_T : vl
  • CatmullRomInterpolatorFVec3_T : vl
  • CatmullRomInterpolatorFVec4_T : vl
  • CBF_11F_G11F_B10F : vl
  • CBF_FLOAT_R16_NV : vl
  • CBF_FLOAT_R32_NV : vl
  • CBF_FLOAT_R_NV : vl
  • CBF_FLOAT_RG16_NV : vl
  • CBF_FLOAT_RG32_NV : vl
  • CBF_FLOAT_RG_NV : vl
  • CBF_FLOAT_RGB16_NV : vl
  • CBF_FLOAT_RGB32_NV : vl
  • CBF_FLOAT_RGB_NV : vl
  • CBF_FLOAT_RGBA16_NV : vl
  • CBF_FLOAT_RGBA32_NV : vl
  • CBF_FLOAT_RGBA_NV : vl
  • CBF_R3_G3_B2 : vl
  • CBF_RGB : vl
  • CBF_RGB10 : vl
  • CBF_RGB10_A2 : vl
  • CBF_RGB12 : vl
  • CBF_RGB16 : vl
  • CBF_RGB4 : vl
  • CBF_RGB5 : vl
  • CBF_RGB5_A1 : vl
  • CBF_RGB8 : vl
  • CBF_RGB9_E5 : vl
  • CBF_RGBA : vl
  • CBF_RGBA12 : vl
  • CBF_RGBA16 : vl
  • CBF_RGBA2 : vl
  • CBF_RGBA4 : vl
  • CBF_RGBA8 : vl
  • CC_FlatCap : vlut
  • CC_NoCap : vlut
  • CC_RoundedCap : vlut
  • CC_SEPARATE_SPECULAR_COLOR : vl
  • CC_SINGLE_COLOR : vl
  • CCM_Float : vl
  • CCM_Int : vl
  • CCM_UInt : vl
  • ceil() : vl
  • CF_CLEAR_COLOR : vl
  • CF_CLEAR_COLOR_DEPTH : vl
  • CF_CLEAR_COLOR_DEPTH_STENCIL : vl
  • CF_CLEAR_COLOR_STENCIL : vl
  • CF_CLEAR_DEPTH : vl
  • CF_CLEAR_DEPTH_STENCIL : vl
  • CF_CLEAR_STENCIL : vl
  • CF_DO_NOT_CLEAR : vl
  • choosePixelFormat() : vlWin32
  • clamp() : vl
  • CM_AMBIENT : vl
  • CM_AMBIENT_AND_DIFFUSE : vl
  • CM_DIFFUSE : vl
  • CM_EMISSION : vl
  • CM_SPECULAR : vl
  • cos() : vl
  • cosh() : vl
  • cross() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- d -

  • dDEG_TO_RAD : vl
  • degrees() : vl
  • dispatchUpdate() : vlWin32
  • distance() : vl
  • dmat2 : vl
  • dmat3 : vl
  • dmat4 : vl
  • dot() : vl
  • dPi : vl
  • dRAD_TO_DEG : vl
  • DrawElementsUByte : vl
  • DrawElementsUInt : vl
  • DrawElementsUShort : vl
  • DST_DEPTH24_STENCIL8 : vl
  • DST_DEPTH32F_STENCIL8 : vl
  • DST_DEPTH_STENCIL : vl
  • DT_DEPTH_COMPONENT : vl
  • DT_DEPTH_COMPONENT16 : vl
  • DT_DEPTH_COMPONENT24 : vl
  • DT_DEPTH_COMPONENT32 : vl
  • DT_DEPTH_COMPONENT32F : vl
  • DTM_ALPHA : vl
  • DTM_INTENSITY : vl
  • DTM_LUMINANCE : vl
  • dvec2 : vl
  • dvec3 : vl
  • dvec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- e -

  • EAlign : vl
  • EAtomType : vlMolecule
  • EAttachmentPoint : vl
  • EBillboardType : vl
  • EBlendEquation : vl
  • EBlendFactor : vl
  • EBondType : vlMolecule
  • EBufferBits : vl
  • ECapsuleCap : vlut
  • EClearColorMode : vl
  • EClearFlags : vl
  • EColorBufferFormat : vl
  • EColorControl : vl
  • EColorMaterial : vl
  • EDepthSortMode : vl
  • EDepthStencilType : vl
  • EDepthTextureMode : vl
  • EDepthType : vl
  • EEnable : vl
  • EFogMode : vl
  • EFrontFace : vl
  • EFunction : vl
  • EGeometryInputType : vl
  • EGeometryOutputType : vl
  • EGetMode : vl
  • EGLBufferAccess : vl
  • EGLBufferUsage : vl
  • EHintMode : vl
  • EImageDimension : vl
  • EImageFormat : vl
  • EImageType : vl
  • EInheritance : vl
  • EKey : vl
  • ELineStipple : vlVG
  • ELogicOp : vl
  • ELogLevel : vl
  • EMoleculeStyle : vlMolecule
  • EMouseButton : vl
  • EN_ALPHA_TEST : vl
  • EN_BLEND : vl
  • EN_COLOR_LOGIC_OP : vl
  • EN_COLOR_SUM : vl
  • EN_CULL_FACE : vl
  • EN_DEPTH_TEST : vl
  • EN_EnableCount : vl
  • EN_FOG : vl
  • EN_LIGHTING : vl
  • EN_LINE_SMOOTH : vl
  • EN_LINE_STIPPLE : vl
  • EN_MULTISAMPLE : vl
  • EN_NORMALIZE : vl
  • EN_POINT_SMOOTH : vl
  • EN_POINT_SPRITE : vl
  • EN_POLYGON_OFFSET_FILL : vl
  • EN_POLYGON_OFFSET_LINE : vl
  • EN_POLYGON_OFFSET_POINT : vl
  • EN_POLYGON_SMOOTH : vl
  • EN_POLYGON_STIPPLE : vl
  • EN_RESCALE_NORMAL : vl
  • EN_SAMPLE_ALPHA_TO_COVERAGE : vl
  • EN_SAMPLE_ALPHA_TO_ONE : vl
  • EN_SAMPLE_COVERAGE : vl
  • EN_STENCIL_TEST : vl
  • EN_UnknownEnable : vl
  • EN_VERTEX_PROGRAM_POINT_SIZE : vl
  • EN_VERTEX_PROGRAM_TWO_SIDE : vl
  • EOpenMode : vl
  • EPolygonFace : vl
  • EPolygonMode : vl
  • EPolygonStipple : vlVG
  • EPrimitiveType : vl
  • equal() : vl
  • EReadDrawBuffer : vl
  • ERenderingCallback : vl
  • ERenderState : vl
  • EShadeModel : vl
  • EShaderType : vl
  • ESilhouetteMode : vl
  • ESortMode : vl
  • EStateType : vl
  • EStencilOp : vl
  • EStencilType : vl
  • EStringEncoding : vl
  • ETessellationWinding : vl
  • ETex2DTarget : vl
  • ETexCompareFunc : vl
  • ETexCompareMode : vl
  • ETexEnvMode : vl
  • ETexEnvOperand : vl
  • ETexEnvSource : vl
  • ETexGenMode : vl
  • ETexParamFilter : vl
  • ETexParamWrap : vl
  • ETextAlign : vl
  • ETextLayout : vl
  • ETextMode : vl
  • ETextureDimension : vl
  • ETextureFormat : vl
  • ETextureMode : vlVG
  • exp() : vl
  • exp2() : vl
  • extractPlanes() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- f -

  • faceforward() : vl
  • fast1_inversesqrt() : vl
  • fast2_inversesqrt() : vl
  • fast_sqrt() : vl
  • fDEG_TO_RAD : vl
  • FF_CCW : vl
  • FF_CW : vl
  • floor() : vl
  • FM_EXP : vl
  • FM_EXP2 : vl
  • FM_LINEAR : vl
  • fmat2 : vl
  • fmat3 : vl
  • fmat4 : vl
  • fPi : vl
  • fract() : vl
  • fRAD_TO_DEG : vl
  • ft_errors : vl
  • FU_ALWAYS : vl
  • FU_EQUAL : vl
  • FU_GEQUAL : vl
  • FU_GREATER : vl
  • FU_LEQUAL : vl
  • FU_LESS : vl
  • FU_NEVER : vl
  • FU_NOTEQUAL : vl
  • fvec2 : vl
  • fvec3 : vl
  • fvec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- g -

  • GBA_READ_ONLY : vl
  • GBA_READ_WRITE : vl
  • GBA_WRITE_ONLY : vl
  • GBU_DYNAMIC_COPY : vl
  • GBU_DYNAMIC_DRAW : vl
  • GBU_DYNAMIC_READ : vl
  • GBU_STATIC_COPY : vl
  • GBU_STATIC_DRAW : vl
  • GBU_STATIC_READ : vl
  • GBU_STREAM_COPY : vl
  • GBU_STREAM_DRAW : vl
  • GBU_STREAM_READ : vl
  • GIT_LINES : vl
  • GIT_LINES_ADJACENCY : vl
  • GIT_POINTS : vl
  • GIT_TRIANGLES : vl
  • GIT_TRIANGLES_ADJACENCY : vl
  • glcheck() : vl
  • GM_DontCreate : vl
  • GM_GetOrCreate : vl
  • GOT_LINE_STRIP : vl
  • GOT_POINTS : vl
  • GOT_TRIANGLE_STRIP : vl
  • greaterEqualPow2() : vl
  • greaterThan() : vl
  • greaterThanEqual() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- h -

  • HM_DONT_CARE : vl
  • HM_FASTEST : vl
  • HM_NICEST : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- i -

  • ID_1D : vl
  • ID_2D : vl
  • ID_3D : vl
  • ID_Cubemap : vl
  • ID_Error : vl
  • IF_ALPHA : vl
  • IF_ALPHA_INTEGER : vl
  • IF_BGR : vl
  • IF_BGR_INTEGER : vl
  • IF_BGRA : vl
  • IF_BGRA_INTEGER : vl
  • IF_BLUE : vl
  • IF_BLUE_INTEGER : vl
  • IF_COMPRESSED_RGB_S3TC_DXT1 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT1 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT3 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT5 : vl
  • IF_DEPTH_COMPONENT : vl
  • IF_DEPTH_STENCIL : vl
  • IF_GREEN : vl
  • IF_GREEN_INTEGER : vl
  • IF_LUMINANCE : vl
  • IF_LUMINANCE_ALPHA : vl
  • IF_LUMINANCE_ALPHA_INTEGER : vl
  • IF_LUMINANCE_INTEGER : vl
  • IF_RED : vl
  • IF_RED_INTEGER : vl
  • IF_RGB : vl
  • IF_RGB_INTEGER : vl
  • IF_RGBA : vl
  • IF_RGBA_INTEGER : vl
  • IF_STENCIL_INDEX : vl
  • imat2 : vl
  • imat3 : vl
  • imat4 : vl
  • IN_Local : vl
  • IN_Propagate : vl
  • IN_Propagate_Overrides : vl
  • IN_Propagate_Overrides_Sticky : vl
  • IN_Propagate_Sticky : vl
  • IN_Sticky : vl
  • inversesqrt() : vl
  • isBMP() : vl
  • isDAT() : vl
  • isDDS() : vl
  • isDICOM() : vl
  • isinf() : vl
  • isinf_neg() : vl
  • isinf_pos() : vl
  • isJPG() : vl
  • isnan() : vl
  • isPNG() : vl
  • isTGA() : vl
  • isTIFF() : vl
  • IT_BYTE : vl
  • IT_COMPRESSED_TYPE : vl
  • IT_FLOAT : vl
  • IT_FLOAT_32_UNSIGNED_INT_24_8_REV : vl
  • IT_INT : vl
  • IT_SHORT : vl
  • IT_UNSIGNED_BYTE : vl
  • IT_UNSIGNED_BYTE_2_3_3_REV : vl
  • IT_UNSIGNED_BYTE_3_3_2 : vl
  • IT_UNSIGNED_INT : vl
  • IT_UNSIGNED_INT_10_10_10_2 : vl
  • IT_UNSIGNED_INT_10F_11F_11F_REV : vl
  • IT_UNSIGNED_INT_24_8 : vl
  • IT_UNSIGNED_INT_2_10_10_10_REV : vl
  • IT_UNSIGNED_INT_5_9_9_9_REV : vl
  • IT_UNSIGNED_INT_8_8_8_8 : vl
  • IT_UNSIGNED_INT_8_8_8_8_REV : vl
  • IT_UNSIGNED_SHORT : vl
  • IT_UNSIGNED_SHORT_1_5_5_5_REV : vl
  • IT_UNSIGNED_SHORT_4_4_4_4 : vl
  • IT_UNSIGNED_SHORT_4_4_4_4_REV : vl
  • IT_UNSIGNED_SHORT_5_5_5_1 : vl
  • IT_UNSIGNED_SHORT_5_6_5 : vl
  • IT_UNSIGNED_SHORT_5_6_5_REV : vl
  • ivec2 : vl
  • ivec3 : vl
  • ivec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- p -

  • peekMessage() : vlWin32
  • PF_BACK : vl
  • PF_FRONT : vl
  • PF_FRONT_AND_BACK : vl
  • PM_FILL : vl
  • PM_LINE : vl
  • PM_POINT : vl
  • PolygonStipple_Chain : vlVG
  • PolygonStipple_Dot : vlVG
  • PolygonStipple_HLine : vlVG
  • PolygonStipple_Solid : vlVG
  • PolygonStipple_VLine : vlVG
  • pow() : vl
  • PT_LINE_LOOP : vl
  • PT_LINE_STRIP : vl
  • PT_LINE_STRIP_ADJACENCY : vl
  • PT_LINES : vl
  • PT_LINES_ADJACENCY : vl
  • PT_POINTS : vl
  • PT_POLYGON : vl
  • PT_QUAD_STRIP : vl
  • PT_QUADS : vl
  • PT_TRIANGLE_FAN : vl
  • PT_TRIANGLE_STRIP : vl
  • PT_TRIANGLE_STRIP_ADJACENCY : vl
  • PT_TRIANGLES : vl
  • PT_TRIANGLES_ADJACENCY : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- r -

  • radians() : vl
  • randomMinMax() : vl
  • RC_PostRendering : vl
  • RC_PreRendering : vl
  • RDB_AUX0 : vl
  • RDB_AUX1 : vl
  • RDB_AUX2 : vl
  • RDB_AUX3 : vl
  • RDB_BACK_LEFT : vl
  • RDB_BACK_RIGHT : vl
  • RDB_COLOR_ATTACHMENT0 : vl
  • RDB_COLOR_ATTACHMENT1 : vl
  • RDB_COLOR_ATTACHMENT10 : vl
  • RDB_COLOR_ATTACHMENT11 : vl
  • RDB_COLOR_ATTACHMENT12 : vl
  • RDB_COLOR_ATTACHMENT13 : vl
  • RDB_COLOR_ATTACHMENT14 : vl
  • RDB_COLOR_ATTACHMENT15 : vl
  • RDB_COLOR_ATTACHMENT2 : vl
  • RDB_COLOR_ATTACHMENT3 : vl
  • RDB_COLOR_ATTACHMENT4 : vl
  • RDB_COLOR_ATTACHMENT5 : vl
  • RDB_COLOR_ATTACHMENT6 : vl
  • RDB_COLOR_ATTACHMENT7 : vl
  • RDB_COLOR_ATTACHMENT8 : vl
  • RDB_COLOR_ATTACHMENT9 : vl
  • RDB_FRONT_LEFT : vl
  • RDB_FRONT_RIGHT : vl
  • RDB_NONE : vl
  • Real : vl
  • reflect() : vl
  • refract() : vl
  • RightButton : vl
  • RightToLeftText : vl
  • round() : vl
  • roundEven() : vl
  • RS_AlphaFunc : vl
  • RS_BlendColor : vl
  • RS_BlendEquation : vl
  • RS_BlendFunc : vl
  • RS_ClipPlane0 : vl
  • RS_ClipPlane1 : vl
  • RS_ClipPlane2 : vl
  • RS_ClipPlane3 : vl
  • RS_ClipPlane4 : vl
  • RS_ClipPlane5 : vl
  • RS_ColorMask : vl
  • RS_COUNT : vl
  • RS_CullFace : vl
  • RS_DepthFunc : vl
  • RS_DepthMask : vl
  • RS_DepthRange : vl
  • RS_Fog : vl
  • RS_FrontFace : vl
  • RS_GLSLProgram : vl
  • RS_Hint : vl
  • RS_Light0 : vl
  • RS_Light1 : vl
  • RS_Light2 : vl
  • RS_Light3 : vl
  • RS_Light4 : vl
  • RS_Light5 : vl
  • RS_Light6 : vl
  • RS_Light7 : vl
  • RS_LightModel : vl
  • RS_LineStipple : vl
  • RS_LineWidth : vl
  • RS_LogicOp : vl
  • RS_Material : vl
  • RS_NONE : vl
  • RS_PixelTransfer : vl
  • RS_PointParameter : vl
  • RS_PointSize : vl
  • RS_PolygonMode : vl
  • RS_PolygonOffset : vl
  • RS_PolygonStipple : vl
  • RS_SampleCoverage : vl
  • RS_ShadeModel : vl
  • RS_StencilFunc : vl
  • RS_StencilMask : vl
  • RS_StencilOp : vl
  • RS_TexEnv0 : vl
  • RS_TexGen0 : vl
  • RS_TextureMatrix0 : vl
  • RS_TextureUnit0 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- s -

  • saveDICOM() : vl
  • saveImage() : vl
  • saveJPG() : vl
  • savePNG() : vl
  • saveTGA() : vl
  • saveTIFF() : vl
  • SE_ASCII : vl
  • SE_LATIN1 : vl
  • SE_Unknown : vl
  • SE_UTF16_BE : vl
  • SE_UTF16_LE : vl
  • SE_UTF32_BE : vl
  • SE_UTF32_LE : vl
  • SE_UTF8 : vl
  • showWin32Console() : vl
  • sign() : vl
  • SilhouetteClosed : vl
  • SilhouetteOpen : vl
  • sin() : vl
  • sinh() : vl
  • SM_FLAT : vl
  • SM_SMOOTH : vl
  • SM_SortBackToFront : vl
  • SM_SortFrontToBack : vl
  • smallerEqualPow2() : vl
  • smoothstep() : vl
  • SO_DECR : vl
  • SO_DECR_WRAP : vl
  • SO_INCR : vl
  • SO_INCR_WRAP : vl
  • SO_INVERT : vl
  • SO_KEEP : vl
  • SO_REPLACE : vl
  • SO_ZERO : vl
  • sqrt() : vl
  • ST_ClipPlanes : vl
  • ST_Enables : vl
  • ST_FRAGMENT_SHADER : vl
  • ST_GEOMETRY_SHADER : vl
  • ST_Lights : vl
  • ST_RenderStates : vl
  • ST_STENCIL_INDEX1 : vl
  • ST_STENCIL_INDEX16 : vl
  • ST_STENCIL_INDEX4 : vl
  • ST_STENCIL_INDEX8 : vl
  • ST_TextureUnits : vl
  • ST_VERTEX_SHADER : vl
  • step() : vl
  • svec2 : vl
  • svec3 : vl
  • svec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- t -

  • T2DT_TEXTURE_1D_ARRAY : vl
  • T2DT_TEXTURE_2D : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_X : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Y : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Z : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_X : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_Y : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_Z : vl
  • T2DT_TEXTURE_RECTANGLE : vl
  • tan() : vl
  • tanh() : vl
  • TCF_ALWAYS : vl
  • TCF_EQUAL : vl
  • TCF_GEQUAL : vl
  • TCF_GREATER : vl
  • TCF_LEQUAL : vl
  • TCF_LESS : vl
  • TCF_NEVER : vl
  • TCF_NOTEQUAL : vl
  • TCM_COMPARE_R_TO_TEXTURE : vl
  • TCM_COMPARE_REF_DEPTH_TO_TEXTURE : vl
  • TCM_NONE : vl
  • TD_TEXTURE_1D : vl
  • TD_TEXTURE_1D_ARRAY : vl
  • TD_TEXTURE_2D : vl
  • TD_TEXTURE_2D_ARRAY : vl
  • TD_TEXTURE_3D : vl
  • TD_TEXTURE_CUBE_MAP : vl
  • TD_TEXTURE_RECTANGLE : vl
  • TEM_ADD : vl
  • TEM_ADD_SIGN : vl
  • TEM_BLEND : vl
  • TEM_COMBINE : vl
  • TEM_DECAL : vl
  • TEM_DOT3_RGB : vl
  • TEM_DOT3_RGBA : vl
  • TEM_INTERPOLATE : vl
  • TEM_MODULATE : vl
  • TEM_REPLACE : vl
  • TEM_SUBTRACT : vl
  • TEO_ONE_MINUS_SRC_ALPHA : vl
  • TEO_ONE_MINUS_SRC_COLOR : vl
  • TEO_SRC_ALPHA : vl
  • TEO_SRC_COLOR : vl
  • TES_CONSTANT : vl
  • TES_PREVIOUS : vl
  • TES_PRIMARY_COLOR : vl
  • TES_TEXTURE : vl
  • TES_TEXTURE0 : vl
  • TES_TEXTURE1 : vl
  • TES_TEXTURE2 : vl
  • TES_TEXTURE3 : vl
  • TES_TEXTURE4 : vl
  • TES_TEXTURE5 : vl
  • TES_TEXTURE6 : vl
  • TES_TEXTURE7 : vl
  • Text2D : vl
  • Text3D : vl
  • TextAlignCenter : vl
  • TextAlignJustify : vl
  • TextAlignLeft : vl
  • TextAlignRight : vl
  • TextureMode_Clamp : vlVG
  • TextureMode_Repeat : vlVG
  • TF_11F_G11F_B10F : vl
  • TF_ALPHA : vl
  • TF_ALPHA12 : vl
  • TF_ALPHA16 : vl
  • TF_ALPHA16F : vl
  • TF_ALPHA16I : vl
  • TF_ALPHA16UI : vl
  • TF_ALPHA32F : vl
  • TF_ALPHA32I : vl
  • TF_ALPHA32UI : vl
  • TF_ALPHA4 : vl
  • TF_ALPHA8 : vl
  • TF_ALPHA8I : vl
  • TF_ALPHA8UI : vl
  • TF_ALPHA_FLOAT16_ATI : vl
  • TF_ALPHA_FLOAT32_ATI : vl
  • TF_COMPRESSED_ALPHA : vl
  • TF_COMPRESSED_INTENSITY : vl
  • TF_COMPRESSED_LUMINANCE : vl
  • TF_COMPRESSED_LUMINANCE_ALPHA : vl
  • TF_COMPRESSED_LUMINANCE_ALPHA_LATC2 : vl
  • TF_COMPRESSED_LUMINANCE_LATC1 : vl
  • TF_COMPRESSED_RED_GREEN_RGTC2 : vl
  • TF_COMPRESSED_RED_RGTC1 : vl
  • TF_COMPRESSED_RGB : vl
  • TF_COMPRESSED_RGB_FXT1_3DFX : vl
  • TF_COMPRESSED_RGB_S3TC_DXT1 : vl
  • TF_COMPRESSED_RGBA : vl
  • TF_COMPRESSED_RGBA_FXT1_3DFX : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT1 : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT3 : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT5 : vl
  • TF_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 : vl
  • TF_COMPRESSED_SIGNED_LUMINANCE_LATC1 : vl
  • TF_COMPRESSED_SIGNED_RED_GREEN_RGTC2 : vl
  • TF_COMPRESSED_SIGNED_RED_RGTC1 : vl
  • TF_DEPTH32F_STENCIL8 : vl
  • TF_DEPTH_COMPONENT : vl
  • TF_DEPTH_COMPONENT16 : vl
  • TF_DEPTH_COMPONENT24 : vl
  • TF_DEPTH_COMPONENT32 : vl
  • TF_DEPTH_COMPONENT32F : vl
  • TF_DEPTH_STENCIL : vl
  • TF_INTENSITY : vl
  • TF_INTENSITY12 : vl
  • TF_INTENSITY16 : vl
  • TF_INTENSITY16F : vl
  • TF_INTENSITY16I : vl
  • TF_INTENSITY16UI : vl
  • TF_INTENSITY32F : vl
  • TF_INTENSITY32I : vl
  • TF_INTENSITY32UI : vl
  • TF_INTENSITY4 : vl
  • TF_INTENSITY8 : vl
  • TF_INTENSITY8I : vl
  • TF_INTENSITY8UI : vl
  • TF_INTENSITY_FLOAT16_ATI : vl
  • TF_INTENSITY_FLOAT32_ATI : vl
  • TF_LUMINANCE : vl
  • TF_LUMINANCE12 : vl
  • TF_LUMINANCE12_ALPHA12 : vl
  • TF_LUMINANCE12_ALPHA4 : vl
  • TF_LUMINANCE16 : vl
  • TF_LUMINANCE16_ALPHA16 : vl
  • TF_LUMINANCE16F : vl
  • TF_LUMINANCE16I : vl
  • TF_LUMINANCE16UI : vl
  • TF_LUMINANCE32F : vl
  • TF_LUMINANCE32I : vl
  • TF_LUMINANCE32UI : vl
  • TF_LUMINANCE4 : vl
  • TF_LUMINANCE4_ALPHA4 : vl
  • TF_LUMINANCE6_ALPHA2 : vl
  • TF_LUMINANCE8 : vl
  • TF_LUMINANCE8_ALPHA8 : vl
  • TF_LUMINANCE8I : vl
  • TF_LUMINANCE8UI : vl
  • TF_LUMINANCE_ALPHA : vl
  • TF_LUMINANCE_ALPHA16F : vl
  • TF_LUMINANCE_ALPHA16I : vl
  • TF_LUMINANCE_ALPHA16UI : vl
  • TF_LUMINANCE_ALPHA32F : vl
  • TF_LUMINANCE_ALPHA32I : vl
  • TF_LUMINANCE_ALPHA32UI : vl
  • TF_LUMINANCE_ALPHA8I : vl
  • TF_LUMINANCE_ALPHA8UI : vl
  • TF_LUMINANCE_ALPHA_FLOAT16_ATI : vl
  • TF_LUMINANCE_ALPHA_FLOAT32_ATI : vl
  • TF_LUMINANCE_FLOAT16_ATI : vl
  • TF_LUMINANCE_FLOAT32_ATI : vl
  • TF_R3_G3_B2 : vl
  • TF_RGB : vl
  • TF_RGB10 : vl
  • TF_RGB10_A2 : vl
  • TF_RGB12 : vl
  • TF_RGB16 : vl
  • TF_RGB16F : vl
  • TF_RGB16I : vl
  • TF_RGB16UI : vl
  • TF_RGB32F : vl
  • TF_RGB32I : vl
  • TF_RGB32UI : vl
  • TF_RGB4 : vl
  • TF_RGB5 : vl
  • TF_RGB5_A1 : vl
  • TF_RGB8 : vl
  • TF_RGB8I : vl
  • TF_RGB8UI : vl
  • TF_RGB9_E5 : vl
  • TF_RGB_FLOAT16_ATI : vl
  • TF_RGB_FLOAT32_ATI : vl
  • TF_RGBA : vl
  • TF_RGBA12 : vl
  • TF_RGBA16 : vl
  • TF_RGBA16F : vl
  • TF_RGBA16I : vl
  • TF_RGBA16UI : vl
  • TF_RGBA2 : vl
  • TF_RGBA32F : vl
  • TF_RGBA32I : vl
  • TF_RGBA32UI : vl
  • TF_RGBA4 : vl
  • TF_RGBA8 : vl
  • TF_RGBA8I : vl
  • TF_RGBA8UI : vl
  • TF_RGBA_FLOAT16_ATI : vl
  • TF_RGBA_FLOAT32_ATI : vl
  • TGM_DISABLED : vl
  • TGM_EYE_LINEAR : vl
  • TGM_NORMAL_MAP : vl
  • TGM_OBJECT_LINEAR : vl
  • TGM_REFLECTION_MAP : vl
  • TGM_SPHERE_MAP : vl
  • TopToBottomText : vl
  • TPF_LINEAR : vl
  • TPF_LINEAR_MIPMAP_LINEAR : vl
  • TPF_LINEAR_MIPMAP_NEAREST : vl
  • TPF_NEAREST : vl
  • TPF_NEAREST_MIPMAP_LINEAR : vl
  • TPF_NEAREST_MIPMAP_NEAREST : vl
  • TPW_CLAMP : vl
  • TPW_CLAMP_TO_BORDER : vl
  • TPW_CLAMP_TO_EDGE : vl
  • TPW_MIRRORED_REPEAT : vl
  • TPW_REPEAT : vl
  • translateKeyEvent() : vlWin32
  • transpose() : vl
  • TRenderQueueMap : vl
  • trunc() : vl
  • TW_TESS_WINDING_ABS_GEQ_TWO : vl
  • TW_TESS_WINDING_NEGATIVE : vl
  • TW_TESS_WINDING_NONZERO : vl
  • TW_TESS_WINDING_ODD : vl
  • TW_TESS_WINDING_POSITIVE : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- u -

  • ubvec2 : vl
  • ubvec3 : vl
  • ubvec4 : vl
  • umat2 : vl
  • umat3 : vl
  • umat4 : vl
  • UnknownButton : vl
  • usvec2 : vl
  • usvec3 : vl
  • usvec4 : vl
  • uvec2 : vl
  • uvec3 : vl
  • uvec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- v -

  • vec2 : vl
  • vec3 : vl
  • vec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • e

- e -

  • EAlign : vl
  • EAtomType : vlMolecule
  • EAttachmentPoint : vl
  • EBillboardType : vl
  • EBlendEquation : vl
  • EBlendFactor : vl
  • EBondType : vlMolecule
  • EBufferBits : vl
  • ECapsuleCap : vlut
  • EClearColorMode : vl
  • EClearFlags : vl
  • EColorBufferFormat : vl
  • EColorControl : vl
  • EColorMaterial : vl
  • EDepthSortMode : vl
  • EDepthStencilType : vl
  • EDepthTextureMode : vl
  • EDepthType : vl
  • EEnable : vl
  • EFogMode : vl
  • EFrontFace : vl
  • EFunction : vl
  • EGeometryInputType : vl
  • EGeometryOutputType : vl
  • EGetMode : vl
  • EGLBufferAccess : vl
  • EGLBufferUsage : vl
  • EHintMode : vl
  • EImageDimension : vl
  • EImageFormat : vl
  • EImageType : vl
  • EInheritance : vl
  • EKey : vl
  • ELineStipple : vlVG
  • ELogicOp : vl
  • ELogLevel : vl
  • EMoleculeStyle : vlMolecule
  • EMouseButton : vl
  • EOpenMode : vl
  • EPolygonFace : vl
  • EPolygonMode : vl
  • EPolygonStipple : vlVG
  • EPrimitiveType : vl
  • EReadDrawBuffer : vl
  • ERenderingCallback : vl
  • ERenderState : vl
  • EShadeModel : vl
  • EShaderType : vl
  • ESilhouetteMode : vl
  • ESortMode : vl
  • EStateType : vl
  • EStencilOp : vl
  • EStencilType : vl
  • EStringEncoding : vl
  • ETessellationWinding : vl
  • ETex2DTarget : vl
  • ETexCompareFunc : vl
  • ETexCompareMode : vl
  • ETexEnvMode : vl
  • ETexEnvOperand : vl
  • ETexEnvSource : vl
  • ETexGenMode : vl
  • ETexParamFilter : vl
  • ETexParamWrap : vl
  • ETextAlign : vl
  • ETextLayout : vl
  • ETextMode : vl
  • ETextureDimension : vl
  • ETextureFormat : vl
  • ETextureMode : vlVG
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- a -

  • AlignBottom : vl
  • AlignHCenter : vl
  • AlignLeft : vl
  • AlignRight : vl
  • AlignTop : vl
  • AlignVCenter : vl
  • AlphaDepthSort : vl
  • AlwaysDepthSort : vl
  • AP_COLOR_ATTACHMENT0 : vl
  • AP_COLOR_ATTACHMENT1 : vl
  • AP_COLOR_ATTACHMENT10 : vl
  • AP_COLOR_ATTACHMENT11 : vl
  • AP_COLOR_ATTACHMENT12 : vl
  • AP_COLOR_ATTACHMENT13 : vl
  • AP_COLOR_ATTACHMENT14 : vl
  • AP_COLOR_ATTACHMENT15 : vl
  • AP_COLOR_ATTACHMENT2 : vl
  • AP_COLOR_ATTACHMENT3 : vl
  • AP_COLOR_ATTACHMENT4 : vl
  • AP_COLOR_ATTACHMENT5 : vl
  • AP_COLOR_ATTACHMENT6 : vl
  • AP_COLOR_ATTACHMENT7 : vl
  • AP_COLOR_ATTACHMENT8 : vl
  • AP_COLOR_ATTACHMENT9 : vl
  • AP_DEPTH_ATTACHMENT : vl
  • AP_NO_ATTACHMENT : vl
  • AP_STENCIL_ATTACHMENT : vl
  • AT_Actinium : vlMolecule
  • AT_Aluminium : vlMolecule
  • AT_Americium : vlMolecule
  • AT_Antimony : vlMolecule
  • AT_Argon : vlMolecule
  • AT_Arsenic : vlMolecule
  • AT_Astatine : vlMolecule
  • AT_Barium : vlMolecule
  • AT_Berkelium : vlMolecule
  • AT_Beryllium : vlMolecule
  • AT_Bismuth : vlMolecule
  • AT_Bohrium : vlMolecule
  • AT_Boron : vlMolecule
  • AT_Bromine : vlMolecule
  • AT_Cadmium : vlMolecule
  • AT_Caesium : vlMolecule
  • AT_Calcium : vlMolecule
  • AT_Californium : vlMolecule
  • AT_Carbon : vlMolecule
  • AT_Cerium : vlMolecule
  • AT_Chlorine : vlMolecule
  • AT_Chromium : vlMolecule
  • AT_Cobalt : vlMolecule
  • AT_Copper : vlMolecule
  • AT_Count : vlMolecule
  • AT_Curium : vlMolecule
  • AT_Darmstadtium : vlMolecule
  • AT_Dubnium : vlMolecule
  • AT_Dysprosium : vlMolecule
  • AT_Einsteinium : vlMolecule
  • AT_Erbium : vlMolecule
  • AT_Europium : vlMolecule
  • AT_Fermium : vlMolecule
  • AT_Fluorine : vlMolecule
  • AT_Francium : vlMolecule
  • AT_Gadolinium : vlMolecule
  • AT_Gallium : vlMolecule
  • AT_Germanium : vlMolecule
  • AT_Gold : vlMolecule
  • AT_Hafnium : vlMolecule
  • AT_Hassium : vlMolecule
  • AT_Helium : vlMolecule
  • AT_Holmium : vlMolecule
  • AT_Hydrogen : vlMolecule
  • AT_Indium : vlMolecule
  • AT_Iodine : vlMolecule
  • AT_Iridium : vlMolecule
  • AT_Iron : vlMolecule
  • AT_Krypton : vlMolecule
  • AT_Lanthanum : vlMolecule
  • AT_Lawrencium : vlMolecule
  • AT_Lead : vlMolecule
  • AT_Lithium : vlMolecule
  • AT_Lutetium : vlMolecule
  • AT_Magnesium : vlMolecule
  • AT_Manganese : vlMolecule
  • AT_Meitnerium : vlMolecule
  • AT_Mendelevium : vlMolecule
  • AT_Mercury : vlMolecule
  • AT_Molybdenum : vlMolecule
  • AT_Neodymium : vlMolecule
  • AT_Neon : vlMolecule
  • AT_Neptunium : vlMolecule
  • AT_Nickel : vlMolecule
  • AT_Niobium : vlMolecule
  • AT_Nitrogen : vlMolecule
  • AT_Nobelium : vlMolecule
  • AT_Osmium : vlMolecule
  • AT_Oxygen : vlMolecule
  • AT_Palladium : vlMolecule
  • AT_Phosphorus : vlMolecule
  • AT_Platinum : vlMolecule
  • AT_Plutonium : vlMolecule
  • AT_Polonium : vlMolecule
  • AT_Potassium : vlMolecule
  • AT_Praseodymium : vlMolecule
  • AT_Promethium : vlMolecule
  • AT_Protactinium : vlMolecule
  • AT_Radium : vlMolecule
  • AT_Radon : vlMolecule
  • AT_Rhenium : vlMolecule
  • AT_Rhodium : vlMolecule
  • AT_Roentgenium : vlMolecule
  • AT_Rubidium : vlMolecule
  • AT_Ruthenium : vlMolecule
  • AT_Rutherfordium : vlMolecule
  • AT_Samarium : vlMolecule
  • AT_Scandium : vlMolecule
  • AT_Seaborgium : vlMolecule
  • AT_Selenium : vlMolecule
  • AT_Silicon : vlMolecule
  • AT_Silver : vlMolecule
  • AT_Sodium : vlMolecule
  • AT_Strontium : vlMolecule
  • AT_Sulfur : vlMolecule
  • AT_Tantalum : vlMolecule
  • AT_Technetium : vlMolecule
  • AT_Tellurium : vlMolecule
  • AT_Terbium : vlMolecule
  • AT_Thallium : vlMolecule
  • AT_Thorium : vlMolecule
  • AT_Thulium : vlMolecule
  • AT_Tin : vlMolecule
  • AT_Titanium : vlMolecule
  • AT_Tungsten : vlMolecule
  • AT_Unknown : vlMolecule
  • AT_Ununbium : vlMolecule
  • AT_Ununhexium : vlMolecule
  • AT_Ununoctium : vlMolecule
  • AT_Ununpentium : vlMolecule
  • AT_Ununquadium : vlMolecule
  • AT_Ununseptium : vlMolecule
  • AT_Ununtrium : vlMolecule
  • AT_Uranium : vlMolecule
  • AT_Vanadium : vlMolecule
  • AT_Xenon : vlMolecule
  • AT_Ytterbium : vlMolecule
  • AT_Yttrium : vlMolecule
  • AT_Zinc : vlMolecule
  • AT_Zirconium : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- k -

  • Key_0 : vl
  • Key_1 : vl
  • Key_2 : vl
  • Key_3 : vl
  • Key_4 : vl
  • Key_5 : vl
  • Key_6 : vl
  • Key_7 : vl
  • Key_8 : vl
  • Key_9 : vl
  • Key_A : vl
  • Key_Alt : vl
  • Key_Ampersand : vl
  • Key_Asterisk : vl
  • Key_At : vl
  • Key_B : vl
  • Key_BackSlash : vl
  • Key_BackSpace : vl
  • Key_C : vl
  • Key_Caret : vl
  • Key_Clear : vl
  • Key_Colon : vl
  • Key_Comma : vl
  • Key_Ctrl : vl
  • Key_D : vl
  • Key_Delete : vl
  • Key_Dollar : vl
  • Key_Down : vl
  • Key_E : vl
  • Key_End : vl
  • Key_Equal : vl
  • Key_Escape : vl
  • Key_Exclam : vl
  • Key_F : vl
  • Key_F1 : vl
  • Key_F10 : vl
  • Key_F11 : vl
  • Key_F12 : vl
  • Key_F2 : vl
  • Key_F3 : vl
  • Key_F4 : vl
  • Key_F5 : vl
  • Key_F6 : vl
  • Key_F7 : vl
  • Key_F8 : vl
  • Key_F9 : vl
  • Key_G : vl
  • Key_Greater : vl
  • Key_H : vl
  • Key_Hash : vl
  • Key_Home : vl
  • Key_I : vl
  • Key_Insert : vl
  • Key_J : vl
  • Key_K : vl
  • Key_L : vl
  • Key_Left : vl
  • Key_LeftAlt : vl
  • Key_LeftBracket : vl
  • Key_LeftCtrl : vl
  • Key_LeftParen : vl
  • Key_LeftShift : vl
  • Key_Less : vl
  • Key_M : vl
  • Key_Minus : vl
  • Key_N : vl
  • Key_None : vl
  • Key_NumberOfKeys : vl
  • Key_O : vl
  • Key_P : vl
  • Key_PageDown : vl
  • Key_PageUp : vl
  • Key_Pause : vl
  • Key_Period : vl
  • Key_Plus : vl
  • Key_Print : vl
  • Key_Q : vl
  • Key_Question : vl
  • Key_Quote : vl
  • Key_QuoteDbl : vl
  • Key_QuoteLeft : vl
  • Key_R : vl
  • Key_Return : vl
  • Key_Right : vl
  • Key_RightAlt : vl
  • Key_RightBracket : vl
  • Key_RightCtrl : vl
  • Key_RightParen : vl
  • Key_RightShift : vl
  • Key_S : vl
  • Key_Semicolon : vl
  • Key_Shift : vl
  • Key_Slash : vl
  • Key_Space : vl
  • Key_T : vl
  • Key_Tab : vl
  • Key_U : vl
  • Key_Underscore : vl
  • Key_Unknown : vl
  • Key_Up : vl
  • Key_V : vl
  • Key_W : vl
  • Key_X : vl
  • Key_Y : vl
  • Key_Z : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- l -

  • LeftButton : vl
  • LeftToRightText : vl
  • LineStipple_Dash : vlVG
  • LineStipple_Dash4 : vlVG
  • LineStipple_Dash8 : vlVG
  • LineStipple_DashDot : vlVG
  • LineStipple_DashDotDot : vlVG
  • LineStipple_Dot : vlVG
  • LineStipple_Solid : vlVG
  • LO_AND : vl
  • LO_AND_INVERTED : vl
  • LO_AND_REVERSE : vl
  • LO_CLEAR : vl
  • LO_COPY : vl
  • LO_COPY_INVERTED : vl
  • LO_EQUIV : vl
  • LO_INVERT : vl
  • LO_NAND : vl
  • LO_NOOP : vl
  • LO_NOR : vl
  • LO_OR : vl
  • LO_OR_INVERTED : vl
  • LO_OR_REVERSE : vl
  • LO_SET : vl
  • LO_XOR : vl
  • LogBug : vl
  • LogDebug : vl
  • LogError : vl
  • LogInfo : vl
  • LogNormal : vl
  • LogWarning : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- m -

  • MiddleButton : vl
  • MS_AtomsOnly : vlMolecule
  • MS_BallAndStick : vlMolecule
  • MS_Sticks : vlMolecule
  • MS_Wireframe : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- n -

  • NeverDepthSort : vl
  • NoButton : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- o -

  • OM_ReadOnly : vl
  • OM_WriteOnly : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- b -

  • BB_COLOR_BUFFER_BIT : vl
  • BB_DEPTH_BUFFER_BIT : vl
  • BB_STENCIL_BUFFER_BIT : vl
  • BE_FUNC_ADD : vl
  • BE_FUNC_REVERSE_SUBTRACT : vl
  • BE_FUNC_SUBTRACT : vl
  • BE_MAX : vl
  • BE_MIN : vl
  • BF_CONSTANT_ALPHA : vl
  • BF_CONSTANT_COLOR : vl
  • BF_DST_ALPHA : vl
  • BF_DST_COLOR : vl
  • BF_ONE : vl
  • BF_ONE_MINUS_CONSTANT_ALPHA : vl
  • BF_ONE_MINUS_CONSTANT_COLOR : vl
  • BF_ONE_MINUS_DST_ALPHA : vl
  • BF_ONE_MINUS_DST_COLOR : vl
  • BF_ONE_MINUS_SRC_ALPHA : vl
  • BF_ONE_MINUS_SRC_COLOR : vl
  • BF_SRC_ALPHA : vl
  • BF_SRC_ALPHA_SATURATE : vl
  • BF_SRC_COLOR : vl
  • BF_ZERO : vl
  • BT_Amide : vlMolecule
  • BT_Aromatic : vlMolecule
  • BT_AxisAlignedBillboard : vl
  • BT_Double : vlMolecule
  • BT_Dummy : vlMolecule
  • BT_None : vlMolecule
  • BT_Single : vlMolecule
  • BT_SphericalBillboard : vl
  • BT_Triple : vlMolecule
  • BT_Unknown : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- c -

  • CBF_11F_G11F_B10F : vl
  • CBF_FLOAT_R16_NV : vl
  • CBF_FLOAT_R32_NV : vl
  • CBF_FLOAT_R_NV : vl
  • CBF_FLOAT_RG16_NV : vl
  • CBF_FLOAT_RG32_NV : vl
  • CBF_FLOAT_RG_NV : vl
  • CBF_FLOAT_RGB16_NV : vl
  • CBF_FLOAT_RGB32_NV : vl
  • CBF_FLOAT_RGB_NV : vl
  • CBF_FLOAT_RGBA16_NV : vl
  • CBF_FLOAT_RGBA32_NV : vl
  • CBF_FLOAT_RGBA_NV : vl
  • CBF_R3_G3_B2 : vl
  • CBF_RGB : vl
  • CBF_RGB10 : vl
  • CBF_RGB10_A2 : vl
  • CBF_RGB12 : vl
  • CBF_RGB16 : vl
  • CBF_RGB4 : vl
  • CBF_RGB5 : vl
  • CBF_RGB5_A1 : vl
  • CBF_RGB8 : vl
  • CBF_RGB9_E5 : vl
  • CBF_RGBA : vl
  • CBF_RGBA12 : vl
  • CBF_RGBA16 : vl
  • CBF_RGBA2 : vl
  • CBF_RGBA4 : vl
  • CBF_RGBA8 : vl
  • CC_FlatCap : vlut
  • CC_NoCap : vlut
  • CC_RoundedCap : vlut
  • CC_SEPARATE_SPECULAR_COLOR : vl
  • CC_SINGLE_COLOR : vl
  • CCM_Float : vl
  • CCM_Int : vl
  • CCM_UInt : vl
  • CF_CLEAR_COLOR : vl
  • CF_CLEAR_COLOR_DEPTH : vl
  • CF_CLEAR_COLOR_DEPTH_STENCIL : vl
  • CF_CLEAR_COLOR_STENCIL : vl
  • CF_CLEAR_DEPTH : vl
  • CF_CLEAR_DEPTH_STENCIL : vl
  • CF_CLEAR_STENCIL : vl
  • CF_DO_NOT_CLEAR : vl
  • CM_AMBIENT : vl
  • CM_AMBIENT_AND_DIFFUSE : vl
  • CM_DIFFUSE : vl
  • CM_EMISSION : vl
  • CM_SPECULAR : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- d -

  • DST_DEPTH24_STENCIL8 : vl
  • DST_DEPTH32F_STENCIL8 : vl
  • DST_DEPTH_STENCIL : vl
  • DT_DEPTH_COMPONENT : vl
  • DT_DEPTH_COMPONENT16 : vl
  • DT_DEPTH_COMPONENT24 : vl
  • DT_DEPTH_COMPONENT32 : vl
  • DT_DEPTH_COMPONENT32F : vl
  • DTM_ALPHA : vl
  • DTM_INTENSITY : vl
  • DTM_LUMINANCE : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- e -

  • EN_ALPHA_TEST : vl
  • EN_BLEND : vl
  • EN_COLOR_LOGIC_OP : vl
  • EN_COLOR_SUM : vl
  • EN_CULL_FACE : vl
  • EN_DEPTH_TEST : vl
  • EN_EnableCount : vl
  • EN_FOG : vl
  • EN_LIGHTING : vl
  • EN_LINE_SMOOTH : vl
  • EN_LINE_STIPPLE : vl
  • EN_MULTISAMPLE : vl
  • EN_NORMALIZE : vl
  • EN_POINT_SMOOTH : vl
  • EN_POINT_SPRITE : vl
  • EN_POLYGON_OFFSET_FILL : vl
  • EN_POLYGON_OFFSET_LINE : vl
  • EN_POLYGON_OFFSET_POINT : vl
  • EN_POLYGON_SMOOTH : vl
  • EN_POLYGON_STIPPLE : vl
  • EN_RESCALE_NORMAL : vl
  • EN_SAMPLE_ALPHA_TO_COVERAGE : vl
  • EN_SAMPLE_ALPHA_TO_ONE : vl
  • EN_SAMPLE_COVERAGE : vl
  • EN_STENCIL_TEST : vl
  • EN_UnknownEnable : vl
  • EN_VERTEX_PROGRAM_POINT_SIZE : vl
  • EN_VERTEX_PROGRAM_TWO_SIDE : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- f -

  • FF_CCW : vl
  • FF_CW : vl
  • FM_EXP : vl
  • FM_EXP2 : vl
  • FM_LINEAR : vl
  • FU_ALWAYS : vl
  • FU_EQUAL : vl
  • FU_GEQUAL : vl
  • FU_GREATER : vl
  • FU_LEQUAL : vl
  • FU_LESS : vl
  • FU_NEVER : vl
  • FU_NOTEQUAL : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- g -

  • GBA_READ_ONLY : vl
  • GBA_READ_WRITE : vl
  • GBA_WRITE_ONLY : vl
  • GBU_DYNAMIC_COPY : vl
  • GBU_DYNAMIC_DRAW : vl
  • GBU_DYNAMIC_READ : vl
  • GBU_STATIC_COPY : vl
  • GBU_STATIC_DRAW : vl
  • GBU_STATIC_READ : vl
  • GBU_STREAM_COPY : vl
  • GBU_STREAM_DRAW : vl
  • GBU_STREAM_READ : vl
  • GIT_LINES : vl
  • GIT_LINES_ADJACENCY : vl
  • GIT_POINTS : vl
  • GIT_TRIANGLES : vl
  • GIT_TRIANGLES_ADJACENCY : vl
  • GM_DontCreate : vl
  • GM_GetOrCreate : vl
  • GOT_LINE_STRIP : vl
  • GOT_POINTS : vl
  • GOT_TRIANGLE_STRIP : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- h -

  • HM_DONT_CARE : vl
  • HM_FASTEST : vl
  • HM_NICEST : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- i -

  • ID_1D : vl
  • ID_2D : vl
  • ID_3D : vl
  • ID_Cubemap : vl
  • ID_Error : vl
  • IF_ALPHA : vl
  • IF_ALPHA_INTEGER : vl
  • IF_BGR : vl
  • IF_BGR_INTEGER : vl
  • IF_BGRA : vl
  • IF_BGRA_INTEGER : vl
  • IF_BLUE : vl
  • IF_BLUE_INTEGER : vl
  • IF_COMPRESSED_RGB_S3TC_DXT1 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT1 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT3 : vl
  • IF_COMPRESSED_RGBA_S3TC_DXT5 : vl
  • IF_DEPTH_COMPONENT : vl
  • IF_DEPTH_STENCIL : vl
  • IF_GREEN : vl
  • IF_GREEN_INTEGER : vl
  • IF_LUMINANCE : vl
  • IF_LUMINANCE_ALPHA : vl
  • IF_LUMINANCE_ALPHA_INTEGER : vl
  • IF_LUMINANCE_INTEGER : vl
  • IF_RED : vl
  • IF_RED_INTEGER : vl
  • IF_RGB : vl
  • IF_RGB_INTEGER : vl
  • IF_RGBA : vl
  • IF_RGBA_INTEGER : vl
  • IF_STENCIL_INDEX : vl
  • IN_Local : vl
  • IN_Propagate : vl
  • IN_Propagate_Overrides : vl
  • IN_Propagate_Overrides_Sticky : vl
  • IN_Propagate_Sticky : vl
  • IN_Sticky : vl
  • IT_BYTE : vl
  • IT_COMPRESSED_TYPE : vl
  • IT_FLOAT : vl
  • IT_FLOAT_32_UNSIGNED_INT_24_8_REV : vl
  • IT_INT : vl
  • IT_SHORT : vl
  • IT_UNSIGNED_BYTE : vl
  • IT_UNSIGNED_BYTE_2_3_3_REV : vl
  • IT_UNSIGNED_BYTE_3_3_2 : vl
  • IT_UNSIGNED_INT : vl
  • IT_UNSIGNED_INT_10_10_10_2 : vl
  • IT_UNSIGNED_INT_10F_11F_11F_REV : vl
  • IT_UNSIGNED_INT_24_8 : vl
  • IT_UNSIGNED_INT_2_10_10_10_REV : vl
  • IT_UNSIGNED_INT_5_9_9_9_REV : vl
  • IT_UNSIGNED_INT_8_8_8_8 : vl
  • IT_UNSIGNED_INT_8_8_8_8_REV : vl
  • IT_UNSIGNED_SHORT : vl
  • IT_UNSIGNED_SHORT_1_5_5_5_REV : vl
  • IT_UNSIGNED_SHORT_4_4_4_4 : vl
  • IT_UNSIGNED_SHORT_4_4_4_4_REV : vl
  • IT_UNSIGNED_SHORT_5_5_5_1 : vl
  • IT_UNSIGNED_SHORT_5_6_5 : vl
  • IT_UNSIGNED_SHORT_5_6_5_REV : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- p -

  • PF_BACK : vl
  • PF_FRONT : vl
  • PF_FRONT_AND_BACK : vl
  • PM_FILL : vl
  • PM_LINE : vl
  • PM_POINT : vl
  • PolygonStipple_Chain : vlVG
  • PolygonStipple_Dot : vlVG
  • PolygonStipple_HLine : vlVG
  • PolygonStipple_Solid : vlVG
  • PolygonStipple_VLine : vlVG
  • PT_LINE_LOOP : vl
  • PT_LINE_STRIP : vl
  • PT_LINE_STRIP_ADJACENCY : vl
  • PT_LINES : vl
  • PT_LINES_ADJACENCY : vl
  • PT_POINTS : vl
  • PT_POLYGON : vl
  • PT_QUAD_STRIP : vl
  • PT_QUADS : vl
  • PT_TRIANGLE_FAN : vl
  • PT_TRIANGLE_STRIP : vl
  • PT_TRIANGLE_STRIP_ADJACENCY : vl
  • PT_TRIANGLES : vl
  • PT_TRIANGLES_ADJACENCY : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- r -

  • RC_PostRendering : vl
  • RC_PreRendering : vl
  • RDB_AUX0 : vl
  • RDB_AUX1 : vl
  • RDB_AUX2 : vl
  • RDB_AUX3 : vl
  • RDB_BACK_LEFT : vl
  • RDB_BACK_RIGHT : vl
  • RDB_COLOR_ATTACHMENT0 : vl
  • RDB_COLOR_ATTACHMENT1 : vl
  • RDB_COLOR_ATTACHMENT10 : vl
  • RDB_COLOR_ATTACHMENT11 : vl
  • RDB_COLOR_ATTACHMENT12 : vl
  • RDB_COLOR_ATTACHMENT13 : vl
  • RDB_COLOR_ATTACHMENT14 : vl
  • RDB_COLOR_ATTACHMENT15 : vl
  • RDB_COLOR_ATTACHMENT2 : vl
  • RDB_COLOR_ATTACHMENT3 : vl
  • RDB_COLOR_ATTACHMENT4 : vl
  • RDB_COLOR_ATTACHMENT5 : vl
  • RDB_COLOR_ATTACHMENT6 : vl
  • RDB_COLOR_ATTACHMENT7 : vl
  • RDB_COLOR_ATTACHMENT8 : vl
  • RDB_COLOR_ATTACHMENT9 : vl
  • RDB_FRONT_LEFT : vl
  • RDB_FRONT_RIGHT : vl
  • RDB_NONE : vl
  • RightButton : vl
  • RightToLeftText : vl
  • RS_AlphaFunc : vl
  • RS_BlendColor : vl
  • RS_BlendEquation : vl
  • RS_BlendFunc : vl
  • RS_ClipPlane0 : vl
  • RS_ClipPlane1 : vl
  • RS_ClipPlane2 : vl
  • RS_ClipPlane3 : vl
  • RS_ClipPlane4 : vl
  • RS_ClipPlane5 : vl
  • RS_ColorMask : vl
  • RS_COUNT : vl
  • RS_CullFace : vl
  • RS_DepthFunc : vl
  • RS_DepthMask : vl
  • RS_DepthRange : vl
  • RS_Fog : vl
  • RS_FrontFace : vl
  • RS_GLSLProgram : vl
  • RS_Hint : vl
  • RS_Light0 : vl
  • RS_Light1 : vl
  • RS_Light2 : vl
  • RS_Light3 : vl
  • RS_Light4 : vl
  • RS_Light5 : vl
  • RS_Light6 : vl
  • RS_Light7 : vl
  • RS_LightModel : vl
  • RS_LineStipple : vl
  • RS_LineWidth : vl
  • RS_LogicOp : vl
  • RS_Material : vl
  • RS_NONE : vl
  • RS_PixelTransfer : vl
  • RS_PointParameter : vl
  • RS_PointSize : vl
  • RS_PolygonMode : vl
  • RS_PolygonOffset : vl
  • RS_PolygonStipple : vl
  • RS_SampleCoverage : vl
  • RS_ShadeModel : vl
  • RS_StencilFunc : vl
  • RS_StencilMask : vl
  • RS_StencilOp : vl
  • RS_TexEnv0 : vl
  • RS_TexGen0 : vl
  • RS_TextureMatrix0 : vl
  • RS_TextureUnit0 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- s -

  • SE_ASCII : vl
  • SE_LATIN1 : vl
  • SE_Unknown : vl
  • SE_UTF16_BE : vl
  • SE_UTF16_LE : vl
  • SE_UTF32_BE : vl
  • SE_UTF32_LE : vl
  • SE_UTF8 : vl
  • SilhouetteClosed : vl
  • SilhouetteOpen : vl
  • SM_FLAT : vl
  • SM_SMOOTH : vl
  • SM_SortBackToFront : vl
  • SM_SortFrontToBack : vl
  • SO_DECR : vl
  • SO_DECR_WRAP : vl
  • SO_INCR : vl
  • SO_INCR_WRAP : vl
  • SO_INVERT : vl
  • SO_KEEP : vl
  • SO_REPLACE : vl
  • SO_ZERO : vl
  • ST_ClipPlanes : vl
  • ST_Enables : vl
  • ST_FRAGMENT_SHADER : vl
  • ST_GEOMETRY_SHADER : vl
  • ST_Lights : vl
  • ST_RenderStates : vl
  • ST_STENCIL_INDEX1 : vl
  • ST_STENCIL_INDEX16 : vl
  • ST_STENCIL_INDEX4 : vl
  • ST_STENCIL_INDEX8 : vl
  • ST_TextureUnits : vl
  • ST_VERTEX_SHADER : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- t -

  • T2DT_TEXTURE_1D_ARRAY : vl
  • T2DT_TEXTURE_2D : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_X : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Y : vl
  • T2DT_TEXTURE_CUBE_MAP_NEGATIVE_Z : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_X : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_Y : vl
  • T2DT_TEXTURE_CUBE_MAP_POSITIVE_Z : vl
  • T2DT_TEXTURE_RECTANGLE : vl
  • TCF_ALWAYS : vl
  • TCF_EQUAL : vl
  • TCF_GEQUAL : vl
  • TCF_GREATER : vl
  • TCF_LEQUAL : vl
  • TCF_LESS : vl
  • TCF_NEVER : vl
  • TCF_NOTEQUAL : vl
  • TCM_COMPARE_R_TO_TEXTURE : vl
  • TCM_COMPARE_REF_DEPTH_TO_TEXTURE : vl
  • TCM_NONE : vl
  • TD_TEXTURE_1D : vl
  • TD_TEXTURE_1D_ARRAY : vl
  • TD_TEXTURE_2D : vl
  • TD_TEXTURE_2D_ARRAY : vl
  • TD_TEXTURE_3D : vl
  • TD_TEXTURE_CUBE_MAP : vl
  • TD_TEXTURE_RECTANGLE : vl
  • TEM_ADD : vl
  • TEM_ADD_SIGN : vl
  • TEM_BLEND : vl
  • TEM_COMBINE : vl
  • TEM_DECAL : vl
  • TEM_DOT3_RGB : vl
  • TEM_DOT3_RGBA : vl
  • TEM_INTERPOLATE : vl
  • TEM_MODULATE : vl
  • TEM_REPLACE : vl
  • TEM_SUBTRACT : vl
  • TEO_ONE_MINUS_SRC_ALPHA : vl
  • TEO_ONE_MINUS_SRC_COLOR : vl
  • TEO_SRC_ALPHA : vl
  • TEO_SRC_COLOR : vl
  • TES_CONSTANT : vl
  • TES_PREVIOUS : vl
  • TES_PRIMARY_COLOR : vl
  • TES_TEXTURE : vl
  • TES_TEXTURE0 : vl
  • TES_TEXTURE1 : vl
  • TES_TEXTURE2 : vl
  • TES_TEXTURE3 : vl
  • TES_TEXTURE4 : vl
  • TES_TEXTURE5 : vl
  • TES_TEXTURE6 : vl
  • TES_TEXTURE7 : vl
  • Text2D : vl
  • Text3D : vl
  • TextAlignCenter : vl
  • TextAlignJustify : vl
  • TextAlignLeft : vl
  • TextAlignRight : vl
  • TextureMode_Clamp : vlVG
  • TextureMode_Repeat : vlVG
  • TF_11F_G11F_B10F : vl
  • TF_ALPHA : vl
  • TF_ALPHA12 : vl
  • TF_ALPHA16 : vl
  • TF_ALPHA16F : vl
  • TF_ALPHA16I : vl
  • TF_ALPHA16UI : vl
  • TF_ALPHA32F : vl
  • TF_ALPHA32I : vl
  • TF_ALPHA32UI : vl
  • TF_ALPHA4 : vl
  • TF_ALPHA8 : vl
  • TF_ALPHA8I : vl
  • TF_ALPHA8UI : vl
  • TF_ALPHA_FLOAT16_ATI : vl
  • TF_ALPHA_FLOAT32_ATI : vl
  • TF_COMPRESSED_ALPHA : vl
  • TF_COMPRESSED_INTENSITY : vl
  • TF_COMPRESSED_LUMINANCE : vl
  • TF_COMPRESSED_LUMINANCE_ALPHA : vl
  • TF_COMPRESSED_LUMINANCE_ALPHA_LATC2 : vl
  • TF_COMPRESSED_LUMINANCE_LATC1 : vl
  • TF_COMPRESSED_RED_GREEN_RGTC2 : vl
  • TF_COMPRESSED_RED_RGTC1 : vl
  • TF_COMPRESSED_RGB : vl
  • TF_COMPRESSED_RGB_FXT1_3DFX : vl
  • TF_COMPRESSED_RGB_S3TC_DXT1 : vl
  • TF_COMPRESSED_RGBA : vl
  • TF_COMPRESSED_RGBA_FXT1_3DFX : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT1 : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT3 : vl
  • TF_COMPRESSED_RGBA_S3TC_DXT5 : vl
  • TF_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 : vl
  • TF_COMPRESSED_SIGNED_LUMINANCE_LATC1 : vl
  • TF_COMPRESSED_SIGNED_RED_GREEN_RGTC2 : vl
  • TF_COMPRESSED_SIGNED_RED_RGTC1 : vl
  • TF_DEPTH32F_STENCIL8 : vl
  • TF_DEPTH_COMPONENT : vl
  • TF_DEPTH_COMPONENT16 : vl
  • TF_DEPTH_COMPONENT24 : vl
  • TF_DEPTH_COMPONENT32 : vl
  • TF_DEPTH_COMPONENT32F : vl
  • TF_DEPTH_STENCIL : vl
  • TF_INTENSITY : vl
  • TF_INTENSITY12 : vl
  • TF_INTENSITY16 : vl
  • TF_INTENSITY16F : vl
  • TF_INTENSITY16I : vl
  • TF_INTENSITY16UI : vl
  • TF_INTENSITY32F : vl
  • TF_INTENSITY32I : vl
  • TF_INTENSITY32UI : vl
  • TF_INTENSITY4 : vl
  • TF_INTENSITY8 : vl
  • TF_INTENSITY8I : vl
  • TF_INTENSITY8UI : vl
  • TF_INTENSITY_FLOAT16_ATI : vl
  • TF_INTENSITY_FLOAT32_ATI : vl
  • TF_LUMINANCE : vl
  • TF_LUMINANCE12 : vl
  • TF_LUMINANCE12_ALPHA12 : vl
  • TF_LUMINANCE12_ALPHA4 : vl
  • TF_LUMINANCE16 : vl
  • TF_LUMINANCE16_ALPHA16 : vl
  • TF_LUMINANCE16F : vl
  • TF_LUMINANCE16I : vl
  • TF_LUMINANCE16UI : vl
  • TF_LUMINANCE32F : vl
  • TF_LUMINANCE32I : vl
  • TF_LUMINANCE32UI : vl
  • TF_LUMINANCE4 : vl
  • TF_LUMINANCE4_ALPHA4 : vl
  • TF_LUMINANCE6_ALPHA2 : vl
  • TF_LUMINANCE8 : vl
  • TF_LUMINANCE8_ALPHA8 : vl
  • TF_LUMINANCE8I : vl
  • TF_LUMINANCE8UI : vl
  • TF_LUMINANCE_ALPHA : vl
  • TF_LUMINANCE_ALPHA16F : vl
  • TF_LUMINANCE_ALPHA16I : vl
  • TF_LUMINANCE_ALPHA16UI : vl
  • TF_LUMINANCE_ALPHA32F : vl
  • TF_LUMINANCE_ALPHA32I : vl
  • TF_LUMINANCE_ALPHA32UI : vl
  • TF_LUMINANCE_ALPHA8I : vl
  • TF_LUMINANCE_ALPHA8UI : vl
  • TF_LUMINANCE_ALPHA_FLOAT16_ATI : vl
  • TF_LUMINANCE_ALPHA_FLOAT32_ATI : vl
  • TF_LUMINANCE_FLOAT16_ATI : vl
  • TF_LUMINANCE_FLOAT32_ATI : vl
  • TF_R3_G3_B2 : vl
  • TF_RGB : vl
  • TF_RGB10 : vl
  • TF_RGB10_A2 : vl
  • TF_RGB12 : vl
  • TF_RGB16 : vl
  • TF_RGB16F : vl
  • TF_RGB16I : vl
  • TF_RGB16UI : vl
  • TF_RGB32F : vl
  • TF_RGB32I : vl
  • TF_RGB32UI : vl
  • TF_RGB4 : vl
  • TF_RGB5 : vl
  • TF_RGB5_A1 : vl
  • TF_RGB8 : vl
  • TF_RGB8I : vl
  • TF_RGB8UI : vl
  • TF_RGB9_E5 : vl
  • TF_RGB_FLOAT16_ATI : vl
  • TF_RGB_FLOAT32_ATI : vl
  • TF_RGBA : vl
  • TF_RGBA12 : vl
  • TF_RGBA16 : vl
  • TF_RGBA16F : vl
  • TF_RGBA16I : vl
  • TF_RGBA16UI : vl
  • TF_RGBA2 : vl
  • TF_RGBA32F : vl
  • TF_RGBA32I : vl
  • TF_RGBA32UI : vl
  • TF_RGBA4 : vl
  • TF_RGBA8 : vl
  • TF_RGBA8I : vl
  • TF_RGBA8UI : vl
  • TF_RGBA_FLOAT16_ATI : vl
  • TF_RGBA_FLOAT32_ATI : vl
  • TGM_DISABLED : vl
  • TGM_EYE_LINEAR : vl
  • TGM_NORMAL_MAP : vl
  • TGM_OBJECT_LINEAR : vl
  • TGM_REFLECTION_MAP : vl
  • TGM_SPHERE_MAP : vl
  • TopToBottomText : vl
  • TPF_LINEAR : vl
  • TPF_LINEAR_MIPMAP_LINEAR : vl
  • TPF_LINEAR_MIPMAP_NEAREST : vl
  • TPF_NEAREST : vl
  • TPF_NEAREST_MIPMAP_LINEAR : vl
  • TPF_NEAREST_MIPMAP_NEAREST : vl
  • TPW_CLAMP : vl
  • TPW_CLAMP_TO_BORDER : vl
  • TPW_CLAMP_TO_EDGE : vl
  • TPW_MIRRORED_REPEAT : vl
  • TPW_REPEAT : vl
  • TW_TESS_WINDING_ABS_GEQ_TWO : vl
  • TW_TESS_WINDING_NEGATIVE : vl
  • TW_TESS_WINDING_NONZERO : vl
  • TW_TESS_WINDING_ODD : vl
  • TW_TESS_WINDING_POSITIVE : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u

- u -

  • UnknownButton : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- a -

  • abs() : vl
  • acos() : vl
  • acosh() : vl
  • all() : vl
  • any() : vl
  • asin() : vl
  • asinh() : vl
  • assemble3DImage() : vl
  • atan() : vl
  • atanh() : vl
  • atexit_visualization_library_shutdown() : vlGLUT
  • atomInfo() : vlMolecule
  • atomType() : vlMolecule
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- l -

  • length() : vl
  • lessThan() : vl
  • lessThanEqual() : vl
  • load3DS() : vl
  • loadAC3D() : vl
  • loadBMP() : vl
  • loadCubemap() : vl
  • loadDAT() : vl
  • loadDDS() : vl
  • loadDICOM() : vl
  • loadImage() : vl
  • loadImagesFromDir() : vl
  • loadJPG() : vl
  • loadMD2() : vl
  • loadMOL2() : vlMolecule
  • loadOBJ() : vl
  • loadPLY() : vl
  • loadPNG() : vl
  • loadRAW() : vl
  • loadResource() : vl
  • loadSTL() : vl
  • loadTGA() : vl
  • loadTIFF() : vl
  • locateFile() : vl
  • log() : vl
  • log10() : vl
  • log2() : vl
  • log_failed_check() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- m -

  • makeBox() : vlut
  • makeCapsule() : vlut
  • makeCircle() : vlut
  • makeColor() : vlut
  • makeCone() : vlut
  • makeCylinder() : vlut
  • makeGrid() : vlut
  • makeIcosahedron() : vlut
  • makeIcosphere() : vlut
  • makePoints() : vlut
  • makePyramid() : vlut
  • makeTorus() : vlut
  • makeUVSphere() : vlut
  • matrixCompMult() : vl
  • max() : vl
  • messageLoop() : vlWin32 , vlSDL
  • min() : vl
  • mix() : vl
  • mod() : vl
  • modf() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- n -

  • normalize() : vl
  • notEqual() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- o -

  • operator!=() : vl
  • operator*() : vl
  • operator+() : vl
  • operator==() : vl
  • outerProduct() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- c -

  • canLoad() : vl
  • canWrite() : vl
  • ceil() : vl
  • choosePixelFormat() : vlWin32
  • clamp() : vl
  • cos() : vl
  • cosh() : vl
  • cross() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- d -

  • degrees() : vl
  • dispatchUpdate() : vlWin32
  • distance() : vl
  • dot() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- e -

  • equal() : vl
  • exp() : vl
  • exp2() : vl
  • extractPlanes() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- f -

  • faceforward() : vl
  • fast1_inversesqrt() : vl
  • fast2_inversesqrt() : vl
  • fast_sqrt() : vl
  • floor() : vl
  • fract() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- g -

  • glcheck() : vl
  • greaterEqualPow2() : vl
  • greaterThan() : vl
  • greaterThanEqual() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- i -

  • inversesqrt() : vl
  • isBMP() : vl
  • isDAT() : vl
  • isDDS() : vl
  • isDICOM() : vl
  • isinf() : vl
  • isinf_neg() : vl
  • isinf_pos() : vl
  • isJPG() : vl
  • isnan() : vl
  • isPNG() : vl
  • isTGA() : vl
  • isTIFF() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- p -

  • peekMessage() : vlWin32
  • pow() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- r -

  • radians() : vl
  • randomMinMax() : vl
  • reflect() : vl
  • refract() : vl
  • round() : vl
  • roundEven() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- s -

  • saveDICOM() : vl
  • saveImage() : vl
  • saveJPG() : vl
  • savePNG() : vl
  • saveTGA() : vl
  • saveTIFF() : vl
  • showWin32Console() : vl
  • sign() : vl
  • sin() : vl
  • sinh() : vl
  • smallerEqualPow2() : vl
  • smoothstep() : vl
  • sqrt() : vl
  • step() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • c
  • d
  • e
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t

- t -

  • tan() : vl
  • tanh() : vl
  • translateKeyEvent() : vlWin32
  • transpose() : vl
  • trunc() : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • f
  • i
  • l
  • m
  • r
  • s
  • t
  • u
  • v

- a -

  • ActorCollection : vl
  • ArrayBVec2 : vl
  • ArrayBVec3 : vl
  • ArrayBVec4 : vl
  • ArrayByte : vl
  • ArrayDouble : vl
  • ArrayDVec2 : vl
  • ArrayDVec3 : vl
  • ArrayDVec4 : vl
  • ArrayFloat : vl
  • ArrayFVec2 : vl
  • ArrayFVec3 : vl
  • ArrayFVec4 : vl
  • ArrayInt : vl
  • ArrayIVec2 : vl
  • ArrayIVec3 : vl
  • ArrayIVec4 : vl
  • ArrayShort : vl
  • ArraySVec2 : vl
  • ArraySVec3 : vl
  • ArraySVec4 : vl
  • ArrayUBVec2 : vl
  • ArrayUBVec3 : vl
  • ArrayUBVec4 : vl
  • ArrayUByte : vl
  • ArrayUInt : vl
  • ArrayUShort : vl
  • ArrayUSVec2 : vl
  • ArrayUSVec3 : vl
  • ArrayUSVec4 : vl
  • ArrayUVec2 : vl
  • ArrayUVec3 : vl
  • ArrayUVec4 : vl

- b -

  • bvec2 : vl
  • bvec3 : vl
  • bvec4 : vl

- c -

  • CatmullRomInterpolatorDouble_T : vl
  • CatmullRomInterpolatorDVec2_T : vl
  • CatmullRomInterpolatorDVec3_T : vl
  • CatmullRomInterpolatorDVec4_T : vl
  • CatmullRomInterpolatorFloat_T : vl
  • CatmullRomInterpolatorFVec2_T : vl
  • CatmullRomInterpolatorFVec3_T : vl
  • CatmullRomInterpolatorFVec4_T : vl

- d -

  • dmat2 : vl
  • dmat3 : vl
  • dmat4 : vl
  • DrawElementsUByte : vl
  • DrawElementsUInt : vl
  • DrawElementsUShort : vl
  • dvec2 : vl
  • dvec3 : vl
  • dvec4 : vl

- f -

  • fmat2 : vl
  • fmat3 : vl
  • fmat4 : vl
  • fvec2 : vl
  • fvec3 : vl
  • fvec4 : vl

- i -

  • imat2 : vl
  • imat3 : vl
  • imat4 : vl
  • ivec2 : vl
  • ivec3 : vl
  • ivec4 : vl

- l -

  • LinearInterpolatorDouble_T : vl
  • LinearInterpolatorDVec2_T : vl
  • LinearInterpolatorDVec3_T : vl
  • LinearInterpolatorDVec4_T : vl
  • LinearInterpolatorFloat_T : vl
  • LinearInterpolatorFVec2_T : vl
  • LinearInterpolatorFVec3_T : vl
  • LinearInterpolatorFVec4_T : vl

- m -

  • mat2 : vl
  • mat3 : vl
  • mat4 : vl

- r -

  • Real : vl

- s -

  • svec2 : vl
  • svec3 : vl
  • svec4 : vl

- t -

  • TRenderQueueMap : vl

- u -

  • ubvec2 : vl
  • ubvec3 : vl
  • ubvec4 : vl
  • umat2 : vl
  • umat3 : vl
  • umat4 : vl
  • usvec2 : vl
  • usvec3 : vl
  • usvec4 : vl
  • uvec2 : vl
  • uvec3 : vl
  • uvec4 : vl

- v -

  • vec2 : vl
  • vec3 : vl
  • vec4 : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • dDEG_TO_RAD : vl
  • dPi : vl
  • dRAD_TO_DEG : vl
  • fDEG_TO_RAD : vl
  • fPi : vl
  • fRAD_TO_DEG : vl
  • ft_errors : vl
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:26 2009.


Visualization Library: dox/namespaces.dox File Reference

  • File List
  • File Members

dox/namespaces.dox File Reference

Namespaces

namespace | vl
Visualization Library namespace.
namespace | vlut
Visualization Library utility namespace.
namespace | vlVG
The Vector Graphics namespace.
namespace | vlMolecule
The Molecule Visualization namespace.
namespace | vlVolume
The Volume Rendering namespace.
namespace | vlQt4
The Qt4 bindings namespace.
namespace | vlMFC
The MFC bindings namespace.
namespace | vlWin32
The Win32 bindings namespace.
namespace | vlSDL
The SDL bindings namespace.
namespace | vlGLUT
The GLUT bindings namespace.
namespace | vlWX
The wxWidgets bindings namespace.
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagChangelog.dox File Reference

  • File List
  • File Members

dox/pagChangelog.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagContacts.dox File Reference

  • File List
  • File Members

dox/pagContacts.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagContributing.dox File Reference

  • File List
  • File Members

dox/pagContributing.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagCredits.dox File Reference

  • File List
  • File Members

dox/pagCredits.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagDesign.dox File Reference

  • File List
  • File Members

dox/pagDesign.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGPL3.dox File Reference

  • File List
  • File Members

dox/pagGPL3.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideAntialiasing.dox File Reference

  • File List
  • File Members

dox/pagGuideAntialiasing.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideBezierSurfaces.dox File Reference

  • File List
  • File Members

dox/pagGuideBezierSurfaces.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideBillboards.dox File Reference

  • File List
  • File Members

dox/pagGuideBillboards.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideClipping.dox File Reference

  • File List
  • File Members

dox/pagGuideClipping.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideEdgeRendering.dox File Reference

  • File List
  • File Members

dox/pagGuideEdgeRendering.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideExtrusion.dox File Reference

  • File List
  • File Members

dox/pagGuideExtrusion.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideGLSL.dox File Reference

  • File List
  • File Members

dox/pagGuideGLSL.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideIO.dox File Reference

  • File List
  • File Members

dox/pagGuideIO.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideInterpolators.dox File Reference

  • File List
  • File Members

dox/pagGuideInterpolators.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideLights.dox File Reference

  • File List
  • File Members

dox/pagGuideLights.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideMarchingCubes.dox File Reference

  • File List
  • File Members

dox/pagGuideMarchingCubes.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideMath.dox File Reference

  • File List
  • File Members

dox/pagGuideMath.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideMemory.dox File Reference

  • File List
  • File Members

dox/pagGuideMemory.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideMolecule.dox File Reference

  • File List
  • File Members

dox/pagGuideMolecule.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideOcclusionCulling.dox File Reference

  • File List
  • File Members

dox/pagGuideOcclusionCulling.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuidePicking.dox File Reference

  • File List
  • File Members

dox/pagGuidePicking.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuidePolygonDepthSorting.dox File Reference

  • File List
  • File Members

dox/pagGuidePolygonDepthSorting.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuidePortals.dox File Reference

  • File List
  • File Members

dox/pagGuidePortals.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuidePrimitives.dox File Reference

  • File List
  • File Members

dox/pagGuidePrimitives.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideRenderOrder.dox File Reference

  • File List
  • File Members

dox/pagGuideRenderOrder.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideRotatingCube.dox File Reference

  • File List
  • File Members

dox/pagGuideRotatingCube.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideSlicedVolume.dox File Reference

  • File List
  • File Members

dox/pagGuideSlicedVolume.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideTerrain.dox File Reference

  • File List
  • File Members

dox/pagGuideTerrain.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideTessellation.dox File Reference

  • File List
  • File Members

dox/pagGuideTessellation.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideText.dox File Reference

  • File List
  • File Members

dox/pagGuideText.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideTextures.dox File Reference

  • File List
  • File Members

dox/pagGuideTextures.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuideVectorGraphics.dox File Reference

  • File List
  • File Members

dox/pagGuideVectorGraphics.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagGuides.dox File Reference

  • File List
  • File Members

dox/pagGuides.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagInstall.dox File Reference

  • File List
  • File Members

dox/pagInstall.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagIntro.dox File Reference

  • File List
  • File Members

dox/pagIntro.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagKeyFeatures.dox File Reference

  • File List
  • File Members

dox/pagKeyFeatures.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagLearning.dox File Reference

  • File List
  • File Members

dox/pagLearning.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagLicensing.dox File Reference

  • File List
  • File Members

dox/pagLicensing.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagMainClasses.dox File Reference

  • File List
  • File Members

dox/pagMainClasses.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagOpenGL.dox File Reference

  • File List
  • File Members

dox/pagOpenGL.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: dox/pagVPL.dox File Reference

  • File List
  • File Members

dox/pagVPL.dox File Reference

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.


Visualization Library: Page Index

Related Pages

Here is a list of all related documentation pages:
  • Loading and Saving Resources Tutorial
  • 3D Maths Tutorial
  • Geometry Primitives Gallery
  • Text Rendering and Manipulation Tutorial
Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Fri Aug 28 10:14:04 2009.