K3dGameData.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   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 2 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#pragma once

#include "K3dSystemData.h"
#include "K3dConfData.h"
#include "K3dCameraData.h"
#include "K3dLineData.h"
#include "K3dSceneData.h"
#include "K3dOptionsData.h"
#include "K3dVertexData.h"
#include "K3dPolyPlaneData.h"
#include "K3dRayData.h"


class K3dAddress
{
                TVoidArray m_tAddressArray;     
                TVoidArray::iterator m_it;              

        public:
                K3dAddress();
                ~K3dAddress();

                void AddAddress ( void* _pAddress );
                void *GetAddress ( const int _iId );
                int GetNumAddresses();
                bool FindAddress ( void* _pAddress );
                void DeleteAddress ( void* _pAddress );
                void DeleteAddressArray();
                void ShowAddressArray();
};

class K3dPlaneObj;
class K3dPlane;
class K3dVector2;
class K3dVector3Obj;
class K3dPolyObj;
class K3dPoly;
class K3dVertexObj;
class K3dRay;
class K3dRayObj;
class K3dLineObj;
class K3dColor3;
class K3dColor4;
class K3dMatrix;
class K3dSphereObj;
class K3dFaceObj;
class K3dVorBsp;
class K3dCutPoly;
class K3dTriangle;
class K3dTriangleObj;
class K3dTriangulation;
class K3dTimer;
class K3dKeyMap;
class K3dMouse;
class K3dLua;
class K3dIntrLinePlane;
class K3dIntrLinePlane;
class K3dBoxBuild;
struct TVertsOnPlane;
class K3dVorLeafObj;
class K3dPolyPlane;
class K3dTextureObj;
class K3dBmpFontObj;
class K2dImageObj;
class K3dBlockObj;
class K3dCameraObj;

template <class _T> class K3dSafePointer
{
                K3dAddress m_kAddress;
        public:
                K3dSafePointer() {}
                ~K3dSafePointer() {}

                _T* New()
                {
                        _T* ptr = NULL;
                        try
                        {
                                ptr = new _T;
                        }
                        catch ( ... )
                        {
                                cerr << "Error -- K3dSafePointer::SafeNew() -- Pointer doesn`t allocated !!!" << endl;
                        }
                        // Add address to the array and set true (pointer to array)
                        m_kAddress.AddAddress ( ptr );
                        return ptr;
                }

                void Add ( _T* _ptr )
                {
                        if ( _ptr != NULL )
                        {
                                // Add address to the array and set false (simple pointer)
                                m_kAddress.AddAddress ( _ptr );
                        }
                }

                _T* Delete ( _T* _ptr )
                {
                        if ( _ptr != NULL )
                        {
                                if ( m_kAddress.FindAddress ( _ptr ) )
                                {
                                        delete _ptr;
                                        // Delete address from array
                                        m_kAddress.DeleteAddress ( _ptr );
                                        _ptr = NULL;
                                }
                        }
                        return _ptr;
                }

                bool FindPointer ( _T* _ptr )
                {
                        return m_kAddress.FindAddress ( _ptr );
                }

                _T* Get ( const int _iId )
                {
                        return ( _T* ) m_kAddress.GetAddress ( _iId );
                }

                int GetNum()
                {
                        return m_kAddress.GetNumAddresses();
                }

                int DeleteAll()
                {
                        return m_kAddress.DeleteAddressArray();
                }
};

class K3dGameData:
                        public K3dSystemData,
                        public K3dConfData,
                        public K3dOptionsData,
                        public K3dCameraData,
                        public K3dRayData,
                        public K3dSceneData
{
                K3dSafePointer<int> m_Int;
                K3dSafePointer<K3dVector2> m_Vector2;
                K3dSafePointer<K3dVector3Obj> m_Vector3;
                K3dSafePointer<K3dPlaneObj> m_PlaneObj;
                K3dSafePointer<K3dPlane> m_Plane;
                K3dSafePointer<K3dPolyObj> m_PolyObj;
                K3dSafePointer<K3dPoly> m_Poly;
                K3dSafePointer<K3dVertexObj> m_VertexObj;
                K3dSafePointer<K3dRay> m_Ray;
                K3dSafePointer<K3dRayObj> m_RayObj;
                K3dSafePointer<K3dLineObj> m_LineObj;
                K3dSafePointer<K3dColor3> m_Color3;
                K3dSafePointer<K3dColor4> m_Color4;
                K3dSafePointer<K3dMatrix> m_Matrix;
                K3dSafePointer<K3dSphereObj> m_SphereObj;
                K3dSafePointer<K3dFaceObj> m_FaceObj;
                K3dSafePointer<TIntArray> m_VertexArray;
                K3dSafePointer<K3dVorBsp> m_VorBsp;
                K3dSafePointer<K3dCutPoly> m_CutPoly;
                K3dSafePointer<K3dTriangle> m_Triangle;
                K3dSafePointer<K3dTriangleObj> m_TriangleObj;
                K3dSafePointer<K3dTriangulation> m_Triangulation;
                K3dSafePointer<K3dTimer> m_Timer;
                K3dSafePointer<K3dKeyMap> m_KeyMap;
                K3dSafePointer<K3dMouse> m_Mouse;
                K3dSafePointer<K3dLua> m_Lua;
                K3dSafePointer<K3dIntrLinePlane> m_IntrLinePlane;
                K3dSafePointer<K3dBoxBuild> m_BoxBuild;
                K3dSafePointer<TVertsOnPlane> m_PlaneVerts;
                K3dSafePointer<K3dVorLeafObj> m_VorLeafObj;
                K3dSafePointer<K3dPolyPlane> m_PolyPlane;
                K3dSafePointer<K3dTextureObj> m_TextureObj;
                K3dSafePointer<K3dBmpFontObj> m_BmpFontObj;
                K3dSafePointer<K2dImageObj> m_2dImageObj;
                K3dSafePointer<K3dBlockObj> m_BlockObj;
                K3dSafePointer<K3dCameraObj> m_CameraObj;


        public:
                K3dGameData ( void );
                ~K3dGameData ( void );

                K3dSafePointer<int> &GetIntSP()
                {
                        return m_Int;
                }

                K3dSafePointer<K3dVector2> &GetVector2SP()
                {
                        return m_Vector2;
                }

                K3dSafePointer<K3dVector3Obj> &GetVector3SP()
                {
                        return m_Vector3;
                }

                K3dSafePointer<K3dPlaneObj> &GetPlaneObjSP()
                {
                        return m_PlaneObj;
                }

                K3dSafePointer<K3dPolyObj> &GetPolyObjSP()
                {
                        return m_PolyObj;
                }

                K3dSafePointer<K3dPoly> &GetPolySP()
                {
                        return m_Poly;
                }

                K3dSafePointer<K3dVertexObj> &GetVertexObjSP()
                {
                        return m_VertexObj;
                }

                K3dSafePointer<K3dRay> &GetRaySP()
                {
                        return m_Ray;
                }

                K3dSafePointer<K3dRayObj> &GetRayObjSP()
                {
                        return m_RayObj;
                }

                K3dSafePointer<K3dLineObj> &GetLineObjSP()
                {
                        return m_LineObj;
                }

                K3dSafePointer<K3dColor3> &GetColor3SP()
                {
                        return m_Color3;
                }

                K3dSafePointer<K3dColor4> &GetColor4SP()
                {
                        return m_Color4;
                }

                K3dSafePointer<K3dMatrix> &GetMatrixSP()
                {
                        return m_Matrix;
                }

                K3dSafePointer<K3dSphereObj> &GetSphereObjSP()
                {
                        return m_SphereObj;
                }

                K3dSafePointer<K3dFaceObj> &GetFaceObjSP()
                {
                        return m_FaceObj;
                }

                K3dSafePointer<TIntArray> &GetVertexArraySP()
                {
                        return m_VertexArray;
                }

                K3dSafePointer<K3dVorBsp> &GetVorBspSP()
                {
                        return m_VorBsp;
                }

                K3dSafePointer<K3dCutPoly> &GetCutPolySP()
                {
                        return m_CutPoly;
                }

                K3dSafePointer<K3dTriangle> &GetTriangleSP()
                {
                        return m_Triangle;
                }

                K3dSafePointer<K3dTriangleObj> &GetTriangleObjSP()
                {
                        return m_TriangleObj;
                }

                K3dSafePointer<K3dTriangulation> &GetTriangulationSP()
                {
                        return m_Triangulation;
                }

                K3dSafePointer<K3dTimer> &GetTimerSP()
                {
                        return m_Timer;
                }

                K3dSafePointer<K3dKeyMap> &GetKeyMapSP()
                {
                        return m_KeyMap;
                }

                K3dSafePointer<K3dMouse> &GetMouseSP()
                {
                        return m_Mouse;
                }

                K3dSafePointer<K3dLua> &GetLuaSP()
                {
                        return m_Lua;
                }

                K3dSafePointer<K3dIntrLinePlane> &GetIntrLinePlaneSP()
                {
                        return m_IntrLinePlane;
                }

                K3dSafePointer<K3dBoxBuild> &GetBoxBuildSP()
                {
                        return m_BoxBuild;
                }

                K3dSafePointer<TVertsOnPlane> &GetPlaneVertsSP()
                {
                        return m_PlaneVerts;
                }

                K3dSafePointer<K3dVorLeafObj> &GetVorLeafObjSP()
                {
                        return m_VorLeafObj;
                }

                K3dSafePointer<K3dPolyPlane> &GetPolyPlaneSP()
                {
                        return m_PolyPlane;
                }

                K3dSafePointer<K3dTextureObj> &GetTextureObjSP()
                {
                        return m_TextureObj;
                }

                K3dSafePointer<K3dBmpFontObj> &GetBmpFontObjSP()
                {
                        return m_BmpFontObj;
                }

                K3dSafePointer<K2dImageObj> &Get2dImageObjSP()
                {
                        return m_2dImageObj;
                }

                K3dSafePointer<K3dBlockObj> &GetBlockObjSP()
                {
                        return m_BlockObj;
                }

                K3dSafePointer<K3dCameraObj> &GetCameraObjSP()
                {
                        return m_CameraObj;
                }
};

---