psworld.h

Go to the documentation of this file.

/*
 * psworld.h - author Matze Braun <[email protected]> and
 *              Keith Fulton <[email protected]>
 *
 * Copyright (C) 2001 Atomic Blue ([email protected], http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * 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.
 *
 */
#ifndef __PSWORLD_H__
#define __PSWORLD_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csgeom/transfrm.h>
#include <csutil/parray.h>
#include <csutil/weakref.h>

//=============================================================================
// Project Includes
//=============================================================================

//=============================================================================
// Local Includes
//=============================================================================

struct iBgLoader;
struct iCollection;
struct iEngine;

class psWorld
{
protected:
    csRef<iStringArray> regions;
    iObjectRegistry* object_reg;
    csWeakRef<iEngine> engine;
    csRef<iBgLoader> loader;

    class sectorTransformation
    {
        // Transformation
        csHash<csReversibleTransform*, csPtrKey<iSector> > trans;

    public:
        csHash<csReversibleTransform*, csPtrKey<iSector> >::GlobalIterator GetIterator()
        {
            return trans.GetIterator();
        }


        void Set(iSector* sector, csReversibleTransform transform)
        {
            csReversibleTransform* transf = trans.Get(csPtrKey<iSector> (sector), NULL);

            if(!transf)
            {
                transf = new csReversibleTransform();
                trans.Put(csPtrKey<iSector> (sector), transf);
            }

            *transf = transform;
        }

        csReversibleTransform* Get(iSector* sector)
        {
            csReversibleTransform* got = trans.Get(csPtrKey<iSector> (sector), NULL);

            return got;
        }

        ~sectorTransformation()
        {
            csHash<csReversibleTransform*, csPtrKey<iSector> >::GlobalIterator iter = trans.GetIterator();
            while(iter.HasNext())
                delete iter.Next();

            trans.Empty();
        }

    };

    csArray<sectorTransformation> transarray;

public:

    psWorld();
    ~psWorld();

    bool Initialize(iObjectRegistry* object_reg);

    bool NewRegion(const char* mapfile);

    void GetAllRegionNames(csString &str);

    bool WarpSpace(const iSector* from, const iSector* to, csVector3 &pos);

    bool WarpSpaceRelative(const iSector* from, const iSector* to, csVector3 &pos);

    bool Connected(const iSector* from, const iSector* to);

    float Distance(const csVector3 &from_pos, const iSector* from_sector, csVector3 to_pos, const iSector* to_sector);

    float Distance2(const csVector3 &from_pos, const iSector* from_sector, csVector3 to_pos, const iSector* to_sector);

    float Distance(iMeshWrapper* ent1, iMeshWrapper* ent2);

    void GetPosition(iMeshWrapper* entity, csVector3 &pos, float* yrot, iSector* &sector);

    static float Matrix2YRot(const csMatrix3 &mat);

    static csVector3 Matrix2Rot(const csMatrix3 &mat);

    iEngine* GetEngine()
    {
        return engine;
    }

    void DumpWarpCache();
    void BuildWarpCache();
};


#endif