SectorVisibility.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */
 
#ifndef HPL_SECTOR_VISIBILTY_H
#define HPL_SECTOR_VISIBILTY_H
 
#include "hpl1/engine/math/BoundingVolume.h"
#include "hpl1/engine/math/Frustum.h"
 
namespace hpl {
 
class cPortal;
class cSector;
class cPortalContainer;
class cSectorVisibilityContainer;
 
enum eSectorVisibilityType {
    eSectorVisibilityType_BV,
    eSectorVisibilityType_Frustum,
};
 
//----------------------------------------------------
 
class cPortalVisibility {
public:
    cPortalVisibility();
    ~cPortalVisibility();
 
    cShadowVolumeBV mShadow;
    cPortal *mpPortal;
    bool mbNullShadow;
};
 
//----------------------------------------------------
 
class cPortalVisibilitySet {
    friend class cSectorVisibilityContainer;
 
public:
    cPortalVisibilitySet(cSectorVisibilityContainer *apContainer, cPortalVisibilitySet *apParent);
    ~cPortalVisibilitySet();
 
    cPortalVisibilitySet *GetParent() { return mpParent; }
 
    inline cPortalVisibility *GetVisibility(size_t alIdx) { return mvVisibility[alIdx]; }
    inline size_t GetVisibilityNum() { return mvVisibility.size(); }
 
    bool PortalExists(cPortal *apPortal);
 
    int AddPortalVisibility(cPortal *apPortal);
 
private:
    Common::Array<cPortalVisibility *> mvVisibility;
    cPortalVisibilitySet *mpParent;
 
    cSectorVisibilityContainer *mpContainer;
};
 
//----------------------------------------------------
 
class cSectorVisibility {
    friend class cSectorVisibilityContainer;
 
public:
    cSectorVisibility(cSectorVisibilityContainer *apContainer);
    ~cSectorVisibility();
 
    bool PortalExists(cPortal *apPortal);
 
    cPortalVisibilitySet *GetSetConnectingFromSector(cSector *apSector);
 
    void AddVisibilitySet(cPortalVisibilitySet *apSet);
 
    cSector *GetSector() const { return mpSector; }
 
    bool IntersectionBV(cBoundingVolume *apBV);
 
private:
    cSector *mpSector;
    Common::Array<cPortalVisibilitySet *> mvVisibiltySets;
    bool bStart;
 
    cSectorVisibilityContainer *mpContainer;
};
 
typedef Common::StableMap<cSector *, cSectorVisibility *> tSectorVisibilityMap;
typedef tSectorVisibilityMap::iterator tSectorVisibilityMapIt;
 
//----------------------------------------------------
 
typedef Common::List<cPortalVisibilitySet *> tPortalVisibilitySetList;
typedef tPortalVisibilitySetList::iterator tPortalVisibilitySetListIt;
 
typedef Hpl1::Std::set<cSector *> tSectorSet;
typedef tSectorSet::iterator tSectorSetIt;
 
typedef cSTLMapIterator<cSectorVisibility *, tSectorVisibilityMap, tSectorVisibilityMapIt> tSectorVisibilityIterator;
 
class cSectorVisibilityContainer {
public:
    cSectorVisibilityContainer(eSectorVisibilityType aType);
    ~cSectorVisibilityContainer();
 
    void SetFrustum(const cFrustum &aFrustum) { mFrustum = aFrustum; }
    void SetBV(const cBoundingVolume &aBV) { mBoundingVolume = aBV; }
 
    const cVector3f &GetOrigin() { return mvOrigin; }
 
    void Compute(cPortalContainer *apContainer);
 
    cPortalVisibilitySet *CreatePortalVisibiltySet(cPortalVisibilitySet *apParent);
 
    cSectorVisibility *GetSectorVisibilty(cSector *apSector);
 
    tSectorVisibilityIterator GetSectorIterator();
 
    bool IntersectionBV(cBoundingVolume *apBV, cPortalVisibilitySet *apSet);
 
    bool mbLog;
 
private:
    void SearchSector(cSector *apSector, cPortalVisibilitySet *apParentSet, int alPortalIndex);
 
    tString GetTabs();
 
    // cPortalContainer *mpContainer;
 
    tSectorSet m_setStartSectors;
 
    tSectorVisibilityMap m_mapSectors;
    eSectorVisibilityType mType;
 
    tPortalVisibilitySetList mlstPortalVisibilty;
 
    cVector3f mvOrigin;
    cBoundingVolume mBoundingVolume;
    cFrustum mFrustum;
 
    int mlTabs;
};
 
//----------------------------------------------------
 
} // namespace hpl
 
#endif // HPL_SECTOR_VISIBILTY_H