PortalNode.h

#pragma once
#include <vector>
#include "TileObject.h"

namespace ParaEngine
{
    using namespace std;
    class CZoneNode;
    struct SceneState;

    class CPortalNode : public CTileObject
    {
    public:
        CPortalNode(void);
        virtual ~CPortalNode(void);

        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::PortalNode;};
        virtual string ToString(DWORD nMethod);
        

        virtual bool TestCollisionSphere(CBaseCamera* pCamera, float fFarPlaneDistance);
        virtual bool TestCollision(CBaseCamera* pCamera);

        virtual void GetVertices(Vector3 * pVertices, int* nNumber);

        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CPortalNode;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CPortalNode"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CPortalNode, GetHomeZone_s, const char**) {*p1 = cls->GetHomeZone(); return S_OK;}
        ATTRIBUTE_METHOD1(CPortalNode, SetHomeZone_s, const char*)  {cls->SetHomeZone(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CPortalNode, GetTargetZone_s, const char**)   {*p1 = cls->GetTargetZone(); return S_OK;}
        ATTRIBUTE_METHOD1(CPortalNode, SetTargetZone_s, const char*)    {cls->SetTargetZone(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CPortalNode, GetPortalPoints_s, const char**) {*p1 = cls->GetPortalPoints(); return S_OK;}
        ATTRIBUTE_METHOD1(CPortalNode, SetPortalPoints_s, const char*)  {cls->SetPortalPoints(p1); return S_OK;}

        ATTRIBUTE_METHOD(CPortalNode, AutoGenPortalPoints_s)    {cls->AutoGenPortalPoints(); return S_OK;}
    public:
        CZoneNode * GetZone(CZoneNode * pCurZone = NULL);
        
        int GetZoneCount();

        /* open the portal */
        void Open();
        /* close the portal */
        void Close();
        /* check if portal is open */
        bool IsOpen() {return m_bOpen;}

        void SetCorner( int nIndex, const Vector3& vPos);

        Vector3 & getCorner( int nIndex);

        Vector3 & getDerivedCorner( int nIndex);

        Vector3 & getDerivedDirection( void );

        Vector3 & getDerivedCP( void );

        void updateDerivedValues();


        /* Calculate the local direction and radius of the portal
        */
        void calcDirectionAndRadius( void );

        virtual HRESULT Draw( SceneState * sceneState);

        virtual void UpdateFrameNumber(int nFrameNumber);

        void SetHomeZone(const char* sName);
        const char* GetHomeZone();

        void SetTargetZone(const char* sName);
        const char* GetTargetZone();

        void SetPortalPoints(const char* sVertices);
        const char* GetPortalPoints();

        void AutoGenPortalPoints();
    private:
        // flag open or closed
        bool m_bOpen;

        bool m_LocalsUpToDate;

        Vector3 m_Corners[4];
        // 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
        Vector3 m_Direction;
        // Local Center point of the portal
        Vector3 m_LocalCP;

        // cached per frame data to speed up calculation
        Vector3 m_DerivedCorners[4];
        // NOTE: Only applicable for a Quad portal
        Vector3 m_DerivedDirection;
        Vector3 m_DerivedCP;

        
    };
}