source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h @ 462

#ifndef _ViewCell_H__
#define _ViewCell_H__

#include "Mesh.h"
#include "Containers.h"
#include "Ray.h"
#include "Statistics.h"
//namespace GtpVisibilityPreprocessor {
  
class BspInterior;
class BspPvs;
struct Triangle3;
class BspLeaf;
class VspKdTree;
class VspKdLeaf;


/**
        View cell with an optional mesh representation
*/
class ViewCell: public MeshInstance
{
public:
        ViewCell();
        
        /** Constructor taking a mesh representing the shape of the viewcell.
        */
        ViewCell(Mesh *mesh);


        virtual ~ViewCell() {}
        /** Returns Pvs. 
        */
        const ViewCellPvs &GetPvs() const;
        ViewCellPvs &GetPvs();

        int Type() const;
        
        /** Adds a passing ray to the passing ray container.
        */
        void AddPassingRay(const Ray &ray, const int contributions);    


        /// Ray set description of the rays passing through this node.  
        PassingRaySet mPassingRays;

        /// Rays piercing this view cell.
        RayContainer mPiercingRays;

protected:

        /// the potentially visible objects
        ViewCellPvs mPvs;
};

class BspViewCell: public ViewCell
{
public:
        BspViewCell(): mBspLeaves(0) {}
        BspViewCell(Mesh *mesh): 
        ViewCell(mesh), mBspLeaves(0) {}

        /// Leaves which hold this view cell.
        vector<BspLeaf *> mBspLeaves;
};

class VspKdViewCell: public ViewCell
{
public:
        VspKdViewCell(): mVspKdLeaves(0) {}
        VspKdViewCell(Mesh *mesh): 
        ViewCell(mesh), mVspKdLeaves(0) {}

        float GetSize() {return mSize;}
        void SetSize(float size) {mSize = size;}

        /// Leaves which hold this view cell.
        vector<VspKdLeaf *> mVspKdLeaves;

protected:
        float mSize;
};

class ViewCellsStatistics: public StatisticsBase
{
public:

        /// number of view cells
        int viewCells;

        /// size of the PVS
        int pvs;
  
        /// largest PVS of all view cells
        int maxPvs;

        /// smallest PVS of all view cells
        int minPvs;

        /// view cells with empty PVS
        int emptyPvs;

        /// number of leaves covering the view space
        int leaves;

        /// largest number of leaves covered by one view cell  
        int maxLeaves;

    // Constructor
        ViewCellsStatistics() 
        {
                Reset();
        }

        double AvgLeaves() const {return (double)leaves / (double)viewCells;};
        double AvgPvs() const {return (double)pvs / (double)viewCells;};
  
        void Reset() 
        {
                viewCells = 0;  
                pvs = 0;  
                maxPvs = 0;

                minPvs = 999999;
                emptyPvs = 0;
                leaves = 0;
                maxLeaves = 0;
        }

        void Print(ostream &app) const;

        friend ostream &operator<<(ostream &s, const ViewCellsStatistics &stat) 
        {
                stat.Print(s);
                return s;
        }  
};

#endif