pspath.h

Go to the documentation of this file.

/*
 * pspath.h
 *
 * Copyright (C) 2007 Atomic Blue (info@planeshift.it, 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 __PSPATH_H__
#define __PSPATH_H__

#include <csutil/weakref.h>
#include <csutil/parray.h>
#include <csutil/list.h>
#include <igeom/path.h>
#include <csgeom/vector3.h>

#include <idal.h>
#include <psstdint.h>

class Waypoint;
class psPathAnchor;
class psWorld;
struct iMovable;
struct iSector;
struct iEngine;
class Location;
class psString;
class psPath;

class iEffectIDAllocator
{
public:
    virtual uint32_t GetEffectID() = 0;
};


class psPathPoint
{
    friend class psPathNetwork;
    friend class psPath;
    friend class psLinearPath;
    friend class psPathAnchor;
public:
    psPathPoint(psPath* parentPath);

    bool Load(iResultRow& row, iEngine *engine);
    
    bool Create(iDataConnection * db, int pathID);

    bool Remove(iDataConnection * db);

    bool UpdatePrevPointId(iDataConnection * db, int prevPointId);
    
    bool Adjust(iDataConnection * db, csVector3 & pos, csString sector);
    
    void Adjust(csVector3 & pos, csString sector);
    
    void Adjust(csVector3 & pos, iSector* sector);

    void SetPrevious(int previous) { prevPointId = previous; }

    int GetPreviousPointId() const { return prevPointId; }

    int GetID() const { return id; }
    void SetID(int id) { this->id = id; }

    const csVector3& GetPosition() const { return pos; }
    iSector * GetSector(iEngine *engine);
    iSector * GetSector(iEngine *engine) const;
    float GetRadius();
    float GetRadius() const;

    void SetWaypoint(Waypoint* waypoint);

    Waypoint* GetWaypoint();

    int GetID();

    csString GetName();

    uint32_t GetEffectID(iEffectIDAllocator* allocator);

    psPath* GetPath() const;

    int GetPathIndex() const;
    
private:
    // Database data
    int                    id;
    int                    prevPointId;
    csVector3              pos;
    csString               sectorName;       
    // Internal data
    float                  radius;           
    csWeakRef<iSector>     sector;           
    float                  startDistance[2]; 
    Waypoint*              waypoint;         
    uint32_t               effectID;         
    psPath*                path;             
};

class psPath
{
    friend class psPathAnchor;
public:
    typedef enum {
        FORWARD,
        REVERSE
    } Direction;

    typedef csPDelArray<psPathPoint> PathPointArray;
            
    int                id;
    csString           name;
    Waypoint*          start;   
    Waypoint*          end;     
    PathPointArray     points;  

    bool                   oneWay;
    bool                   noWander;
    bool                   teleport; 
    
    bool                   precalculationValid;
    float                  totalDistance;
    
    psPath(csString name, Waypoint * wp1, Waypoint * wp2, psString flagStr);
    psPath(int pathID, csString name, psString flagStr);
    
    virtual ~psPath();

    bool Load(iDataConnection * db, iEngine *engine);

    bool Create(iDataConnection *db);

    bool Adjust(iDataConnection * db, int index, csVector3 & pos, csString sector);

    psPathPoint* AddPoint(Location * loc, bool first = false);

    psPathPoint* AddPoint(iDataConnection *db, const csVector3& pos, const char * sectorName, bool first = false);
    
    psPathPoint* AddPoint(const csVector3& pos, float radius, const char * sectorName, bool first = false);

    psPathPoint* InsertPoint(iDataConnection *db, int index, const csVector3& pos, const char * sectorName);

    bool RemovePoint(iDataConnection *db, int index);

    bool RemovePoint(int index);
    
    bool RemovePoint(iDataConnection *db, psPathPoint* point);

    bool UpdatePrevPointIndexes(iDataConnection* db);
    
    void SetStart(Waypoint * wp);

    void SetEnd(Waypoint * wp);

    virtual void Precalculate(psWorld * world, iEngine *engine, bool forceUpdate = false);

    virtual float Distance(psWorld * world, iEngine *engine,const csVector3& pos, const iSector* sector, int * index = NULL, float * fraction = NULL) const;

    virtual float DistancePoint(psWorld * world, iEngine *engine,const csVector3& pos, const iSector* sector, int * index = NULL, bool include_ends = false) const;

    psPathPoint* GetStartPoint(Direction direction);
    
    psPathPoint* GetEndPoint(Direction direction);

    Waypoint* GetStartWaypoint(Direction direction);
    
    Waypoint* GetEndWaypoint(Direction direction);
    
    csVector3 GetEndPos(Direction direction);
    
    float GetEndRot(Direction direction);
    
    iSector* GetEndSector(iEngine * engine, Direction direction);

    
    virtual psPathAnchor* CreatePathAnchor();

    virtual int GetNumPoints () const { return (int)points.GetSize(); }

    virtual const char* GetName() const { return name.GetDataSafe(); }

    int GetID() const { return id; }

    bool Rename(iDataConnection * db,const char* name);
    
    void Rename(const char* name);

    virtual float GetLength(psWorld * world, iEngine *engine, int index);

    virtual float GetLength(psWorld * world, iEngine *engine);

    float CalculateIncidentAngle(csVector3& pos, csVector3& dest);
    
    csString GetFlags() const;

    void SetFlags(const psString & flagStr);

    bool SetFlag(iDataConnection * db, const csString &flagstr, bool enable);

    bool SetFlag(const csString &flagstr, bool enable);

    size_t FindPointsInSector(iEngine * engine, iSector *sector, csList<psPathPoint*>& list);

    psPathPoint* FindPoint(int id);

    int FindPointIndex(int id) const;

    int FindPointIndex(const psPathPoint* point) const;
    
    // Get Path Point by index
    psPathPoint* GetPoint(int index);

    // Get Path Point by index
    const psPathPoint* GetPoint(int index) const;
    
protected:
    virtual void PrecalculatePath(psWorld * world, iEngine *engine) = 0;

    virtual void GetInterpolatedPosition (int index, float fraction, csVector3& pos) = 0;

    virtual void GetInterpolatedUp (int index, float fraction, csVector3& up) = 0;
    
    virtual void GetInterpolatedForward (int index, float fraction, csVector3& forward) = 0;
};

class psLinearPath: public psPath
{
public:
    psLinearPath(csString name, Waypoint * wp1, Waypoint * wp2, psString flagStr);
    psLinearPath(int pathID, csString name, psString flagStr);
    virtual ~psLinearPath(){};

protected:
    virtual void PrecalculatePath(psWorld * world, iEngine *engine);

    virtual void GetInterpolatedPosition (int index, float fraction, csVector3& pos);

    virtual void GetInterpolatedUp (int index, float fraction, csVector3& up);
    
    virtual void GetInterpolatedForward (int index, float fraction, csVector3& forward);
    
private:
    csArray<float> dx;
    csArray<float> dy;
    csArray<float> dz;
};

// Warning: This is BROKEN and does not work across sectors.
class psPathAnchor
{
public:
    psPathAnchor(psPath * path);
    virtual ~psPathAnchor() {}

    virtual bool CalculateAtDistance(psWorld * world, iEngine *engine, float distance, psPath::Direction direction);

    virtual void GetInterpolatedPosition (csVector3& pos);

    virtual void GetInterpolatedUp (csVector3& up);
    
    virtual void GetInterpolatedForward (csVector3& forward);

    virtual bool Extrapolate(psWorld * world, iEngine *engine, float delta, psPath::Direction direction, iMovable* movable);


    float GetDistance(){ return pathDistance; }
    int GetCurrentAtIndex() { return currentAtIndex; }
    psPath::Direction GetCurrentAtDirection() { return currentAtDirection; }
    float GetCurrentAtFraction(){ return currentAtFraction; }

private:
    psPath * path;
    // Internal non reentrant data leagal after calcuateAt operation
    int                    currentAtIndex;
    psPath::Direction      currentAtDirection;
    float                  currentAtFraction;

    float                  pathDistance;    
};

#endif