OpenGL Cacheing Mechanisms

Classes
struct	Wizt::DrawArrays
	An Vertex Buffer Object renderer that implements the glDrawArrays function. More...
class	Wizt::GLCache
	The GLCache is a mapping from certain keys to an OpenGL DisplayList object. More...
class	Wizt::GLCacheFactory
	The 3rd level of the OpenGL Cache, retrieving actual GL objects such as VBO's or TextureCreators. More...
class	Wizt::GLCacheFactoryPtr
	A convenience class which is basically a reference to a GLCacheFactory and forwards all its member properties to this pointer. More...
struct	Wizt::GLPainter
	RenderBasin Painter Object implementing a call to OpenGL's glDrawArrays(). More...
class	Wizt::GLTextureBase
	Base class for OpenGL Texture ID's. More...
class	Wizt::GLTextureID
	Better base class for OpenGL Texture ID's. More...
class	Wizt::TypeSpecificGLCacheFactory
	This is semantically a. More...
class	Wizt::TypeSpecificGLCacheFactoryPtr
	This is semantically. More...
class	Wizt::VBO
	A vertex buffer object, encompassing many vertex buffer arrays and a rendering routine with pre- and post execution code. More...

Detailed Description

See also

The OpenGL Interface of Vish

The GLCache interface is supposed to make display lists relative to some viewer context. Viewers may share their context (if on the same card and screen), or each have their own. Though, a certain VObject might of course well have more than one display list, so the GLCache interface allows to specify some parameters, that correspond to a certain rendering. For instance, imagine you have a "ScaleFactor" double parameter that determines the size of the stars. You switch the star size from 0.2 to 0.4 to 0.6 and then go back to 0.4 . Imagine that this is an algorithm that requires creating a new display list for each "ScaleFactor" value. So, you could indeed create a new one, each time the value is changed. But it were more efficient to re-use the display list for 0.4 when going back to it, as this is work that already has been done. This is what the GLCache interface is for. The interface for this looks like that:

class   SurfaceView
{
        TypedSlot<double> ScaleFactor;
        void render(VRenderContext&Context) const;
};
 
void SurfaceView::render(VRenderContext&Context) const
{
RefPtr<FieldState> myState = getState(Context);
        if (!myState)
                return;
 
RefPtr<DisplayList> DL = Context(*myState->CellField) ( ScaleFactor(Context) );
       if (DL)
       {
                DL->call();
                puts("calling list...");
                return;
       }
       if (DL) puts("CREATE DL");
       else    puts("NO DL Createable!?");
 
        if (DL) DL->begin_compile();
 
        glEnable(GL_LINE_SMOOTH);
 
        ... DO OpenGL rendering ...
 
        if (DL) DL->end_compile();
}

Note that the usage of DisplayLists is deprecated in OpenGL and use of Vertex Buffer Objects (VBO) is encourage. The latter come with some memory management in Vish.