source: GTP/trunk/Lib/Vis/Preprocessing/src/HashPvs.h @ 2102

#ifndef __HASHPVS_H
#define __HASHPVS_H

#include <hash_map>
#include <vector>
#include "common.h"
#include <math.h>
#include "PvsBase.h"


using namespace std;

namespace GtpVisibilityPreprocessor {

class KdNode;
class BspNode;
class Ray;
class Intersectable;
class ViewCell;


/** Template class representing the Potentially Visible Set (PVS) 
        mainly from a view cell, but also e.g., from objects.
*/
template<typename T>
class HashPvs: public PvsBase<T>
{
        template<typename T>
                friend class PvsIterator2;

public:

        HashPvs() {};
        //virtual ~HashPvs() {};

        int GetSize() const;
        bool Empty() const;

        /** Adds sample to PVS.
                @returns contribution of sample (0 or 1)
        */
        float AddSample(T sample);

        /** Adds sample to PVS without checking for presence of the sample
                warning: pvs remains unsorted!
        */
        void AddSampleDirty(T sample);

        /** Adds sample dirty (on the end of the vector) but
                first checks if sample is already in clean part of the pvs.
        */
        bool AddSampleDirtyCheck(T sample);

        /** Sort pvs entries - this should always be called after a
                sequence of AddSampleDirty calls 
        */
        void Sort();

        /** Clears the pvs.
        */
        void Clear(const bool trim = true);

        //static void Merge(PvsBase &mergedPvs, const PvsBase &a, const PvsBase &b);

        bool IsDirty() const;

        bool RequiresResort() const;

        //typename PvsIterator<T> GetIterator() const;

protected:

        /// vector of PVS entries
        vector<T> mEntries; 

        /// Number of samples used to create the PVS
        int mSamples;
};


template <typename T>
int HashPvs<T>::GetSize() const
{
        return 0;
}


template <typename T>
bool HashPvs<T>::Empty() const
{
        return false;
}


template <typename T>
float HashPvs<T>::AddSample(T sample)
{
        return 0;
}
        

template <typename T>
void HashPvs<T>::AddSampleDirty(T sample)
{
}


template <typename T>
bool HashPvs<T>::AddSampleDirtyCheck(T sample)
{
        return false;
}


template <typename T>
void HashPvs<T>::Sort()
{
}


template <typename T>
void HashPvs<T>::Clear(const bool trim = true)
{
}


template <typename T>
bool HashPvs<T>::IsDirty() const
{
        return false;
}


template <typename T>
bool HashPvs<T>::RequiresResort() const
{
        return false;
}

//typename PvsIterator<T> GetIterator() const;

}

#endif