source: GTP/trunk/Lib/Vis/Preprocessing/integration.txt @ 1676

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);
     }