1) include following libs into your application:

Preprocessor.lib zdll.lib zziplib.lib xerces-c_2.lib devil.lib glut32.lib OpenGL32.Lib glu32.lib glew32.lib glew32s.lib


2) view cells are loaded using a similar piece of code like this:

   OctreeBoundingBoxConverter bconverter(this);
   ObjectContainer objects;

   // load the view cells assigning the found objects to the pvss

   GtpVisibilityPreprocessor::ViewCellsManager *viewCellsManager = 
      GtpVisibilityPreprocessor::ViewCellsManager::LoadViewCells(filename, &objects, &bconverter);

      The bouning box converter is used to associate entities in the
      engine and connect them to entities of the visibility
      preprocessing file.

3) The parameter objects:

      The parameter objects of the type ObjectContainer contains the primitives which
      will be set visible / invisible accoring to the pvs.
      
      They are given as pointers to an Intersectable. 
      It is therefore necessary to write wrapper for the primitives in
      your engine. Something like:

 
/**
	Wrapper for Ogre object intances for use with the preprocessed view cells.
*/
class __declspec(dllexport) OgreMeshInstance: public GtpVisibilityPreprocessor::Intersectable
{
public:
	/** The default constructor taking an entity into account.
	*/
	OgreMeshInstance(Entity *ent);
	
	/** Returns 'mesh' associated with this instance. 
	*/
	Entity *GetEntity() const;

	/** See get.
	*/
	void SetEntity(Entity *entity);


	/////////////////////////////
	//-- inherited functions from Intersectable

	GtpVisibilityPreprocessor::AxisAlignedBox3 GetBox() const;
	
	int CastRay(GtpVisibilityPreprocessor::Ray &ray);
	
	bool IsConvex() const;
	bool IsWatertight() const;
	float IntersectionComplexity();
  
	int NumberOfFaces() const;
	int Type() const;

	int GetRandomSurfacePoint(GtpVisibilityPreprocessor::Vector3 &point, 
							  GtpVisibilityPreprocessor::Vector3 &normal);

	int GetRandomVisibleSurfacePoint(GtpVisibilityPreprocessor::Vector3 &point,
									 GtpVisibilityPreprocessor::Vector3 &normal,
									 const GtpVisibilityPreprocessor::Vector3 &viewpoint,
									 const int maxTries);
  
	ostream &Describe(ostream &s);
	

protected:
	
	Entity *mEntity;
};


4) The bounding box converter has to implement the following interface:
  

/** Class used to assign unique indices to objects using a comparison of bounding boxes.
*/
class BoundingBoxConverter
{
public:
	/** Takes a vector of indexed bounding boxes and uses it to identify objects with a similar bounding box
		and to assign them their index (id).
		The objects are returned in the object container.
		
		@returns true if conversion was successful
	*/
	virtual bool IdentifyObjects(const IndexedBoundingBoxContainer &iboxes,
				ObjectContainer &objects) const
	{
		// default: do nothing as we assume that a unique id is already assigned to the objects.
		return true;
	}
};


The interface only contains the method IdentifyObjects, which will be
responsible for the conversion.

5) The ViewCellsManager:

This class is there to control the view cells. You can get a view
point by using something like the following:

GtpVisibilityPreprocessor::Vector3 viewPoint;

ViewCell *currentViewCell = viewCellsManager->GetViewCell(const Vector3 &viewPoint);


6) The view cell: the Pvs of the current view cell can be received by using

ObjectPvs pvs = viewCell->GetPvs();

Then objects of the pvs can be iterated over and set visibible like in
this example for Ogre:


     GtpVisibilityPreprocessor::ObjectPvsMap::const_iterator oit, oit_end = viewCell->GetPvs().mEntries.end();

     ////////////
     //-- set PVS of view cell to visible

     for (oit = viewCell->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
     {
	GtpVisibilityPreprocessor::Intersectable *entry = (*oit).first;
	// no associated geometry found
	if (!entry) continue;
	
	OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(entry);
	omi->GetEntity()->setVisible(load);
     }