Graphics hardware abstraction layer objects
This class encapsulates the rendering equation of a mesh. The equation is described through vertex and pixel shaders in order to be fully hardware accelerated. This is an abstract class bebause the vertex and pixel shaders can be written in several hardware-friendly languages (GLSL,ARB,Cg). You must use GLSLShaderSet for working with shaders written in GLSL and CgShaderSet? for working with shaders written in Cg. The compilation, linking and validation of generated programs (rendering equations) is done with high level interfaces.
This class encapsulates a buffer that can be used to pass per-vertex attributes to a vertex shader. The class manages both static and dynamic vertex buffers.
This class encapsulates a buffer for describing the topology of a triangle mesh. The indices can represent triangle lists, triangle fans or triangle strips. The class manages both static and dynamic index buffers.
This class encapsulates the data and function set of a buffer that can be accessed from a pixel shader. The buffer can specify a set of data in any dimension, resolution and pixel format (including compressed formats) supported by the graphics hardware. Render to texture functionality and multiple render target output is also supported.
See also Texture load management?.
vector2, vector3, vector4
These template classes encapsulate the data and the function set of a vector in two, three and four dimensions. The template argument is used to define the type of each component of the vector.
This class encapsulates the data and the function set of a three dimensional rotation. You can use this class to define, combine and concatenate rotations.
These classes encapsulate a transformation from one space to another space. You can use these classes to define, combine and concatenate transformations.
This class encapsulates the data and the function set of an Axis Aligned Bounding Box. Magnitudes are in world space except indicated. The class can be useful in several common graphics tasks such as frustum culling or collision detection.
This class encapsulates the data and the function set of an Sphere. Magnitudes are in world space except indicated. The class can be useful in several common graphics tasks such as frustum culling or collision detection.
This class encapsulates the equation of a plane in three dimensions. The function set of this class includes overlap tests and distance computations.
This class encapsulates a straight line extending from a point. The function set of this class includes intersection tests and distance computations.
The gti-framework provides TextureManager? as the reference class to be used for texture loading, caching and managing. The TextureManager? operates with TextureCacheManager? and TextureCacheLevel? in order to provide transparent texture load management functionality, handling several levels of detail of the textures.
The gti-framework provides MeshManager? as the reference class to be used for mesh loading, caching and managing when working with .MESH files.
The Scene Manager can store a whole set of nodes from a 3d Scene (like meshes, cameras and lights), ready to render. They can be imported from professional 3d applications using the FBX file format.
The shader manager caches all the shaders in use to allow the user to reuse them in a simple way.
This class is a Pipeline Actions Container plus a Parameter Container. It executes the actions using the parameters as input. The actions are headed to set the rendering flow (activate the shader, set the constants, apply multiple passes, change the rendering state, etc).
See Using the Pipeline?.
Every possible action executed in the pipeline inherits from PipelineAction?, it is the interface for all the common actions like configure through XML or execute.
See Using the Pipeline?.
The parameter container stores a set of variables with a string name. It can store floats, vectors, matrices, even other special classes like Textures or VertexBuffers?.
The Timer class is intended to use as a counter of the interval time passed between two points of execution. This is useful to profile your code.
The class Application wraps the application window interface with the API. Actions like resizing or getting the input are handled from here. All you need to do is inherit your application from an API specific Application class (GlutApplication? or SDLApplication).
See also Creating an application?.
This class encapsulates some messages the operating system can send to your application.
See also Event?.
Communication between applications
NetworkServer?, NetworkClient? and NetworkComponent? create a network layer between applications. Using these classes it is simple to send and receive data between different applications coded using the gti-framework.
The framework contains classes prepared to parse XML files in a DOM way (preparsing the whole file when it is loaded) or in a SAX way (parsing it while it is used). If you want to parse a XML using a DOM approach use the namespace XML with the class Document and Element. IF you want to parse a XML using a SAX approach, use the XMLParser class and the XMLReceiver.
FBXScene classes provide all the features to import scenes from a FBX File exported from any professional application. It supports meshes, cameras, lights, materials and animations.
Image file formats
The framework provides classes for importing DDS and TGA files. DDS is the preferred format by the framework because of its interesting features. The infrastructure for adding new image file formats is also provided.
See also Texture load management?.
This class encapsulates a triangle mesh. An instance of Mesh stores the geometry, texture mapping and topology information of a triangle mesh. The geometry of the triangle mesh must be stored in object space in order to be used by multiple instances with diferent transformations. The class includes serialization methods for simplifying the the data interchange between applications. Note that a triangle mesh cannot be rendered directly, you must use MeshInstance?'s and ShaderSet?'s to render your meshes.
This class encapsulates an instance of a triangle mesh. An instance of a MeshInstance? does not store a triangle mesh. It references an instance of a Mesh instead. A MeshInstance? stores the data that is not shared by all instances of a triangle mesh such as the world transformation, the rendering equation and so on.
The Material class aims to be a generic container of the appearence information (color, textures, etc) of a triangle mesh. This class is provided as a reference for less experienced developers.
This class encapsulates a view space transformation. Magnitudes are in world space except indicated. The class lets to configure the view and projection matrices involved in a view space transformation with high level interfaces. Your application could define as many cameras as you need to render your scene. The class is ready to work in a cluster environment resolving specific problems involved in this kind of scenarios (such as partitioning and extending the frustum to work with fullscreen post-processing effects).
As you may know, the gti-framework does never use internally the fixed pipeline. Neverthless, working without the fixed pipeline could be annoying for the programmer used to the openGL fixed pipeline way of coding. For this reason, the framework provides the classes Painter, PainterStack? and MatricesStack?. These classes are intented to mimic some of the tasks traditionally done with the fixed pipeline.
By using the Painter class the developer cand render most primitives (points, lines, a full-screen quad, etc) without working with vertex buffers. The MatricesStack? class is meant to be used as a matrices stack to store and restore intermediate transformations.
This class provides a convenient interface for mananging morph targets (also referred in literature/modelling packages as blend shapes), one of the best approaches to achieve high-quality facial animation.