OgrePortalBase.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-2011 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.
-----------------------------------------------------------------------------
PortalBase.h  -  PortalBase is the base class for Portal and AntiPortal.

*/

#ifndef PORTALBASE_H
#define PORTALBASE_H

#include "OgrePCZPrerequisites.h"
#include "OgrePCZSceneNode.h"
#include "OgreMovableObject.h"
#include "OgreAxisAlignedBox.h"
#include "OgreCapsule.h"
#include "OgreSphere.h"

namespace Ogre
{
    class PCZSceneNode;

    class _OgrePCZPluginExport PortalBase : public MovableObject
    {
    public:
        enum PORTAL_TYPE
        {
            PORTAL_TYPE_QUAD,
            PORTAL_TYPE_AABB,
            PORTAL_TYPE_SPHERE,
        };

        PortalBase(const String& name, const PORTAL_TYPE type = PORTAL_TYPE_QUAD);

        virtual ~PortalBase();

        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const;
        virtual const Sphere& getWorldBoundingSphere(bool derive = false) const;

        void setNode(SceneNode* sn);
        void setCurrentHomeZone(PCZone* zone);
        void setNewHomeZone(PCZone* zone);

        void setCorner(int index, const Vector3& point);
        void setCorners(const Vector3* corners);
        void setDirection(const Vector3 &d)
        {
            switch (mType)
            {
            default:
            case PORTAL_TYPE_QUAD:
                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
                    "Cannot setDirection on a Quad type portal", 
                    "Portal::setDirection");
                break;
            case PORTAL_TYPE_AABB:
            case PORTAL_TYPE_SPHERE:
                if (d != Vector3::UNIT_Z &&
                    d != Vector3::NEGATIVE_UNIT_Z)
                {
                    OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
                        "Valid parameters are Vector3::UNIT_Z or Vector3::NEGATIVE_UNIT_Z", 
                        "Portal::setDirection");
                    return;
                }
                mDirection = d;
                break;
            }
        }
        void calcDirectionAndRadius() const;

        const PORTAL_TYPE getType() const {return mType;}
        Real getRadius() const;

        PCZone* getCurrentHomeZone()
        { return mCurrentHomeZone; }
        PCZone* getNewHomeZone()
        { return mNewHomeZone; }

        const Vector3& getCorner(int index) const
        { return mCorners[index]; }
        const Vector3& getDirection() const
        { return mDirection; }

        const Vector3& getDerivedCorner(int index) const
        { return mDerivedCorners[index]; }
        const Vector3& getDerivedDirection() const
        { return mDerivedDirection; }
        const Vector3& getDerivedCP() const
        { return mDerivedCP; }
        const Sphere& getDerivedSphere() const
        { return mDerivedSphere; }
        const Plane& getDerivedPlane() const
        { return mDerivedPlane; }

        const Vector3& getPrevDerivedCP() const
        { return mPrevDerivedCP; }
        const Plane& getPrevDerivedPlane() const
        { return mPrevDerivedPlane; }

        void updateDerivedValues() const;
        void adjustNodeToMatch(SceneNode* node);
        void setEnabled(bool value)
        { mEnabled = value; }
        bool getEnabled() const {return mEnabled;}
        

        enum PortalIntersectResult
        {
            NO_INTERSECT,
            INTERSECT_NO_CROSS,
            INTERSECT_BACK_NO_CROSS,
            INTERSECT_CROSS
        };
        bool intersects(const AxisAlignedBox& aab);

        bool intersects(const Sphere& sphere);

        bool intersects(const PlaneBoundedVolume& pbv);

        bool intersects(const Ray& ray);

        PortalIntersectResult intersects(PCZSceneNode* sn);

        bool crossedPortal(const PortalBase* otherPortal);
        bool closeTo(const PortalBase* otherPortal);

        const AxisAlignedBox& getBoundingBox() const;

        Real getBoundingRadius() const
        { return getRadius(); }

        void _updateRenderQueue(RenderQueue* queue)
        { /* Draw debug info if needed? */ }

        void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables = false)
        { }

        void _notifyMoved()
        {
            updateDerivedValues();
            mWasMoved = true;
        }

        void _notifyAttached(Node* parent, bool isTagPoint = false)
        {
            MovableObject::_notifyAttached(parent, isTagPoint);
            mDerivedUpToDate = false;
        }

        bool needUpdate();

        const Capsule& getCapsule() const;

        const AxisAlignedBox& getAAB();

    protected:
        // Type of portal (quad, aabb, or sphere)
        PORTAL_TYPE mType;
        PCZone * mCurrentHomeZone;
        PCZone * mNewHomeZone;
        // NOTE: there are 4 corners if the portal is a quad type
        //       there are 2 corners if the portal is an AABB type
        //       there are 2 corners if the portal is a sphere type (center and point on sphere)
        Vector3 * mCorners;
        // NOTE: For a Quad portal, determined by the 1st 3 corners.
        // NOTE: For AABB & SPHERE portals, we only have "inward" or "outward" cases.
        //       To indicate "outward", the Direction is UNIT_Z
        //       to indicate "inward", the Direction is NEGATIVE_UNIT_Z
        mutable Vector3 mDirection;
        // NOTE: For aabb portals, this value is the distance from the center of the aab to a corner
        mutable Real mRadius;
        // Local Centerpoint of the portal
        mutable Vector3 mLocalCP;
        // NOTE: there are 4 corners if the portal is a quad type
        //       there are 2 corners if the portal is an AABB type (min corner & max corner)
        //       there are 2 corners if the portal is a sphere type (center and point on sphere)
        Vector3 * mDerivedCorners;
        // NOTE: Only applicable for a Quad portal
        mutable Vector3 mDerivedDirection;
        mutable Vector3 mDerivedCP;
        mutable Sphere mDerivedSphere;
        // NOTE: Only applicable for a Quad portal
        mutable Plane mDerivedPlane;
        mutable Vector3 mPrevDerivedCP;
        // NOTE: Only applicable for a Quad portal
        mutable Plane mPrevDerivedPlane;
        mutable bool mLocalsUpToDate;
        mutable bool mDerivedUpToDate;
        // previous world transform
        mutable Matrix4 mPrevWorldTransform;
        // flag defining if portal is enabled or disabled.
        bool mEnabled;
        // cache of portal's capsule.
        mutable Capsule mPortalCapsule;
        // cache of portal's AAB that contains the bound of portal movement.
        mutable AxisAlignedBox mPortalAAB;
        // cache of portal's previous AAB.
        mutable AxisAlignedBox mPrevPortalAAB;
        // cache of portal's local AAB.
        mutable AxisAlignedBox mLocalPortalAAB;
        // defined if portal was moved previously.
        mutable bool mWasMoved;
    };

    class _OgrePCZPluginExport PortalBaseFactory : public MovableObjectFactory
    {
    protected:
        PortalBase::PORTAL_TYPE getPortalType(const NameValuePairList* params);

    };

}

#endif