Static Public Member Functions

static void Disable (const RefPtr< Colormap > &Cmap)
Disable this colormap, i.e.
static bool Enable (const RefPtr< Colormap > &Cmap, const RefPtr< GLTexture1D > &CmapTexture, const bool clampP=true)
Enable this colormap, as 1D texture or as colortable.
static RefPtr< GLTexture1D > Enable (const RefPtr< Colormap > &Cmap, TextureCreator &CmapTC, int TextureUnit, const bool clampP=true)
Activate a 1D texture from the virtual color values and put these into the specified texture creator.
static bool EnableColorTable (const RefPtr< Colormap > &Cmap)
Explicitely load the colormap as OpenGL ColorTable.

Detailed Description

A colormap can be used in two ways: as 1D texture, or as colortable.

Which method to use depends on the usage scenario:

Loading as 1D Texture: For each vertex to be rendered, the scalar field needs to be specified as 1D texture coordinate. Multitexturing may well be used. The Colormap class does not deal with any multitexturing operations. This mode requires specifying each vertex explicitely, and color interpolation is done linearly within rendering perspectives. Note that when changing the colormap, only the 1D texture is changed, but the original data that specify the 1D coordinates may stem from some cached OpenGL object, like a display list or vertex buffer object. I.e., original data do not need to be accessed (no RAM or disk access).
Loading as Colortable: When pixels are rendered via a luminance texture, the colortable may be used to map these scalar values to RGB or RGBA values. This mode does not require to set data per pixel, but works indirectly via specifying 2D texture coordinates for the luminance texture. Note that when changing the colormap, the 2D luminance texture needs to be reloaded, due to the way the OpenGL PixelTransfer() function works. Consequently, original data need to be accessed from RAM (or disc).

Activate this colormap in specified shader program under the given name and specified texture unit.

Typical usage scenario:

static const char fragmentshader_src[] =
"\n"
//Reference to the 1D texture that store the colormap
"uniform sampler1D ColormapTexture;\n"
"\n"
"void main (void)\n"
"{\n"
"       gl_FragColor = texture1D(ColormapTexture, gl_TexCoord[1].r );\n"
"}\n"
;
void MyObject::render(VRenderContext&Context) const
{
VColormap Cmap; 
        myColormap << Context >> Cmap;

RefPtr<ValueSet> CmapValues = new ValueSet(myColormap(Context) );
        TextureCreator&TC = Context[ *myState ][ this ][ CmapValues ]( TEXTURE() );

RefPtr<GLTexture1D> CmapTexture = Cmap->Enable(TC, 1);

        try
        {
        RefPtr<Program> MyProgram  = new Program(colormap_vertex_shader, colormap_fragment_shader); 
                MyProgram->setUniformTexture( "ColormapTexture"  , *CmapTexture);


                ... RENDER CODE ...

        }
        catch(const Program::Error&E)
        {
                E.print("Compiled program not usable");
        }
}

This example uses the GLCache of the VRenderContext to store the textures. A colormap requires an OpenGL texture to store its values. This texture needs to be stored somewhere. In theory, it could also be stored in the object's local State object. This would work well when the program is run, but the problem occurs during destruction: The texture object needs to be destroyed within an OpenGL context, but the VObject's local state doesn't have one. The GLCache however will be destructed in an OpenGL context and therefore must be used for proper clean up. Otherwise, the application will terminate with a segfault when closing.

See also:: Colorizer::getColormap()

Member Function Documentation

void Wizt::GLColormap::Disable ( const RefPtr< Colormap > & Cmap ) [static]

Disable this colormap, i.e.

switch off Colortable mode.

bool Wizt::GLColormap::Enable	(	const RefPtr< Colormap > &	Cmap,
		const RefPtr< GLTexture1D > &	CmapTexture,
		const bool	clampP = `true`
	)		`[static]`

Enable this colormap, as 1D texture or as colortable.

Parameters:

Cmap1D	If a valid pointer, set the colormap as 1D texture, otherwise as a colortable.
clampP	clamp values, not repeating

Note:: If the colormap is set via a colortable, then the PixelTransfer() may be applied elsewhere. It affects subsequent operations of loading a texture. Binding an existing texture will however not be affected by the colormap then, it is required to reload the texture.

RefPtr< GLTexture1D > Wizt::GLColormap::Enable	(	const RefPtr< Colormap > &	Cmap,
		TextureCreator &	CmapTC,
		int	TextureUnit,
		const bool	clampP = `true`
	)		`[static]`

Activate a 1D texture from the virtual color values and put these into the specified texture creator.

Parameters:

CmapTC	The Texture creator, as retrieved from an OpenGL Cache
TextureUnit	The Texture unit (OpenGL ActiveTexture) which is to be used for this texture.
clampP	clamp values, not repeating

The documentation for this struct was generated from the following files:

ocean/GLvish/VGLColormap.hpp
ocean/GLvish/VGLColormap.cpp