OgrePCZone.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2014 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
PCZone.h  -  Portal Connected Zone (PCZone) header file.
-----------------------------------------------------------------------------
Portal Connected Zones are spatial constructs for partitioning space into cross
connected zones.  Each zone is connected to other zones using Portal nodes.

Zones contain references to nodes which touch them.  However, zones do not
care how nodes are arranged hierarchically.  Whether or not a node is 
referenced as being part of a zone is entirely determined by the user or
by the node crossing a portal into or out-of the zone.

Nodes can be referenced by several zones at once, but only one zone is
considered the "home" zone of the node.  Home zone is determined by location
of the centerpoint of the node.  Nodes can "touch" other zones if the node 
BV intersects a portal (this is also called "visiting" a zone).  Nodes keep
a pointer to their home zone and a list of references to zones they are 
"visiting".
-----------------------------------------------------------------------------
begin                : Tue Feb 20 2007
author               : Eric Cha
email                : ericc@xenopi.com
Code Style Update    :
-----------------------------------------------------------------------------
*/

#ifndef PCZONE_H
#define PCZONE_H

#include "OgrePCZPrerequisites.h"
#include "OgrePCZSceneNode.h"
#include "OgrePCZCamera.h"
#include "OgrePCZFrustum.h"

namespace Ogre
{

    class PCZone;
    class Portal;
    class AntiPortal;
    class PCZSceneNode;
    class PCZSceneManager;
    class PCZLight;

    typedef map<String, PCZone*>::type ZoneMap;
    typedef list<PCZone*>::type PCZoneList;
    typedef list<Portal*>::type PortalList;
    typedef list<AntiPortal*>::type AntiPortalList;
    typedef vector<PortalBase*>::type PortalBaseList;
    typedef vector<SceneNode*>::type NodeList;
    typedef set< PCZSceneNode * >::type PCZSceneNodeList;
    typedef map<String, SceneNode*>::type SceneNodeList;

    class _OgrePCZPluginExport PCZone : public SceneCtlAllocatedObject
    {
    public:

        enum NODE_LIST_TYPE
        {
            HOME_NODE_LIST = 1,
            VISITOR_NODE_LIST = 2
        };

        PCZone( PCZSceneManager *, const String& );
        virtual ~PCZone();

        const String& getZoneTypeName() const { return mZoneTypeName; }

        const String& getName(void) const { return mName; }

        SceneNode * getEnclosureNode(void) {return mEnclosureNode;}

        void setHasSky(bool yesno) {mHasSky = yesno;}

        bool hasSky(void) {return mHasSky;}

        void setLastVisibleFrame(unsigned long frameCount) {mLastVisibleFrame = frameCount;}

        unsigned long getLastVisibleFrame(void) {return mLastVisibleFrame;}

        void setLastVisibleFromCamera(PCZCamera * camera) {mLastVisibleFromCamera = camera;}

        PCZCamera* getLastVisibleFromCamera() {return mLastVisibleFromCamera;}

    public:
        virtual void setEnclosureNode(PCZSceneNode *) = 0;

        virtual void _addNode( PCZSceneNode * ) = 0;

        virtual void removeNode( PCZSceneNode * ) = 0;

        virtual void _clearNodeLists(short nodeListTypes);

        virtual bool requiresZoneSpecificNodeData(void) = 0;

        virtual void createNodeZoneData(PCZSceneNode *);

        virtual Portal * findMatchingPortal(Portal *);

        virtual void _addPortal(Portal* newPortal);

        virtual void _removePortal(Portal* removePortal);

        virtual void _addAntiPortal(AntiPortal* newAntiPortal);

        virtual void _removeAntiPortal(AntiPortal* removeAntiPortal);

        virtual void _checkNodeAgainstPortals(PCZSceneNode *, Portal * ) = 0;

        virtual void _checkLightAgainstPortals(PCZLight *, 
                                               unsigned long, 
                                               PCZFrustum *,
                                               Portal *) = 0;

        virtual void updatePortalsZoneData(void) = 0;

        virtual void dirtyNodeByMovingPortals(void) = 0;

        virtual PCZone * updateNodeHomeZone(PCZSceneNode * pczsn, bool allowBackTouces) = 0;

        virtual void findVisibleNodes(PCZCamera *, 
                                      NodeList & visibleNodeList,
                                      RenderQueue * queue,
                                      VisibleObjectsBoundsInfo* visibleBounds, 
                                      bool onlyShadowCasters,
                                      bool displayNodes,
                                      bool showBoundingBoxes) = 0;

        /* Functions for finding Nodes that intersect various shapes */
        virtual void _findNodes( const AxisAlignedBox &t, 
                                 PCZSceneNodeList &list, 
                                 PortalList &visitedPortals,
                                 bool includeVisitors,
                                 bool recurseThruPortals,
                                 PCZSceneNode *exclude) = 0;
        virtual void _findNodes( const Sphere &t, 
                                 PCZSceneNodeList &list, 
                                 PortalList &visitedPortals,
                                 bool includeVisitors,
                                 bool recurseThruPortals,
                                 PCZSceneNode *exclude ) = 0;
        virtual void _findNodes( const PlaneBoundedVolume &t, 
                                 PCZSceneNodeList &list, 
                                 PortalList &visitedPortals,
                                 bool includeVisitors,
                                 bool recurseThruPortals,
                                 PCZSceneNode *exclude ) = 0;
        virtual void _findNodes( const Ray &t, 
                                 PCZSceneNodeList &list, 
                                 PortalList &visitedPortals,
                                 bool includeVisitors,
                                 bool recurseThruPortals,
                                 PCZSceneNode *exclude ) = 0;

        virtual bool setOption( const String &, const void * ) = 0;
        virtual void notifyCameraCreated( Camera* c ) = 0;
        virtual void notifyWorldGeometryRenderQueue(uint8 qid) = 0;
        virtual void notifyBeginRenderScene(void) = 0;
        virtual void setZoneGeometry(const String &filename, PCZSceneNode * parentNode) = 0;
        virtual void getAABB(AxisAlignedBox &);
        void setPortalsUpdated(bool updated)   { mPortalsUpdated = updated;    }
        bool getPortalsUpdated(void)      { return mPortalsUpdated;   }
        void * getUserData(void) {return mUserData;}
        void setUserData(void * userData) {mUserData = userData;}
        PortalList mPortals;
        AntiPortalList mAntiPortals;
        PCZSceneManager * mPCZSM;

    protected:
        struct PortalSortDistance
        {
            const Vector3& cameraPosition;
            PortalSortDistance(const Vector3& inCameraPosition) : cameraPosition(inCameraPosition)
            { }

            bool _OgrePCZPluginExport operator()(const PortalBase* p1, const PortalBase* p2) const
            {
                Real depth1 = p1->getDerivedCP().squaredDistance(cameraPosition);
                Real depth2 = p2->getDerivedCP().squaredDistance(cameraPosition);
                return (depth1 < depth2);
            }
        };

        String mName;
        String mZoneTypeName;
        unsigned long mLastVisibleFrame;
        PCZCamera * mLastVisibleFromCamera;
        bool mHasSky;
        SceneNode * mEnclosureNode;
        PCZSceneNodeList mHomeNodeList;
        PCZSceneNodeList mVisitorNodeList;
        bool mPortalsUpdated;   
        void * mUserData;

    };

    class _OgrePCZPluginExport ZoneData : public SceneCtlAllocatedObject
    {
    public:
        ZoneData(PCZSceneNode *, PCZone * );
        virtual ~ZoneData();
        virtual void update(void);
    public:
        PCZone *        mAssociatedZone;
        PCZSceneNode *  mAssociatedNode;

    };

}

#endif