propclass/linmove.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2001 PlaneShift Team (info@planeshift.it,
    Copyright (C) 2001-2003 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

/*
 * This code is heavily based on pslinmove from the PlaneShift project.
 * Thanks a lot for making this!
 */

#ifndef __CEL_PF_LINEAR_MOVE__
#define __CEL_PF_LINEAR_MOVE__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/strhash.h"

class csReversibleTransform;
struct iDataBuffer;
struct iSector;
struct iPath;
struct iPcCollisionDetection;
struct iPcMesh;
struct iMeshWrapper;


struct iPcGravityCallback : public virtual iBase
{
  SCF_INTERFACE (iPcGravityCallback, 0, 0, 2);

  virtual void Callback () = 0;
};

struct iPcLinearMovement : public virtual iBase
{
  SCF_INTERFACE (iPcLinearMovement, 0, 0, 3);

  virtual void SetAnchor (iPcMesh* pcmesh) = 0;

  virtual iPcMesh* GetAnchor () const = 0;

  virtual void SetAngularVelocity (const csVector3& angle) = 0;

  virtual void SetAngularVelocity (const csVector3& angle,
        const csVector3& angle_to_reach) = 0;

  virtual void SetSpeed (float speedZ) = 0;
  virtual float GetSpeed () const = 0;

  CS_DEPRECATED_METHOD_MSG("Use void SetBodyVelocity () instead.")
  virtual void SetVelocity (const csVector3& vel) = 0;

  virtual void SetBodyVelocity (const csVector3& vel) = 0;

  virtual void SetWorldVelocity (const csVector3& vel) = 0;

  virtual void AddVelocity (const csVector3& vel) = 0;

  virtual void ClearWorldVelocity () = 0;

  CS_DEPRECATED_METHOD_MSG("Use csVector3 GetVelocity () instead.")
  virtual void GetVelocity (csVector3& v) const = 0;

  virtual const csVector3 &GetBodyVelocity () const = 0;

  virtual const csVector3 &GetWorldVelocity () const = 0;

  virtual const csVector3 GetVelocity () const = 0;

  virtual void GetAngularVelocity (csVector3& v) const = 0;

  virtual bool InitCD (iMeshWrapper* mesh, float percentage,
        iPcCollisionDetection* pc_cd = 0) = 0;

  virtual bool InitCD (const csVector3& body, const csVector3& legs,
        const csVector3& shift, iPcCollisionDetection *pc_cd = 0) = 0;

  virtual void GetCDDimensions (csVector3& body, csVector3& legs,
        csVector3& shift, iPcCollisionDetection*& pc_cd) = 0;

  virtual bool InitCD (iPcCollisionDetection *pc_cd=0) = 0;

  virtual csTicks TimeDiff (void) = 0;

  virtual void GetDRData (bool& on_ground, float& speed, csVector3& pos,
        float& yrot, iSector*& sector, csVector3& vel, csVector3& worldVel,
        float& ang_vel) = 0;


  virtual void SetDRData (bool on_ground,float speed, csVector3& pos,
        float yrot, iSector *sector, csVector3& vel, csVector3& worldVel,
        float ang_vel) = 0;

  virtual void SetSoftDRData (bool on_ground,float speed, csVector3& pos,
        float yrot,iSector *sector, csVector3& vel, csVector3& worldVel,
        float ang_vel) = 0;

  virtual void SetFullPosition (const csVector3& pos, float yrot,
        const iSector* sector) = 0;
  virtual void SetPosition (const csVector3& pos, float yrot,
        const iSector* sector) = 0;
  virtual void GetLastPosition (csVector3& pos, float& yrot,
        iSector*& sector) = 0;
  virtual void GetLastFullPosition (csVector3& pos, float& yrot,
        iSector*& sector) = 0;

  virtual float GetYRotation () = 0;
  virtual const csVector3 GetPosition () = 0;
  virtual const csVector3 GetFullPosition () = 0;

  virtual const csReversibleTransform GetFullTransform () = 0;

  virtual bool IsPath () const = 0;

  virtual iSector* GetSector () = 0;

  virtual void ExtrapolatePosition (float delta) = 0;

  virtual void UpdateDRDelta (csTicks ticksdelta) = 0;

  virtual void UpdateDR (csTicks ticks) = 0;

  virtual void UpdateDR () = 0;

  virtual void SetPath (iPath *newpath) = 0;

  virtual void SetPathTime (float timeval) = 0;

  virtual void SetPathSpeed (float speed) = 0;

  virtual void SetPathAction (int which, const char *action) = 0;

  virtual void SetPathSector (const char *sectorname) = 0;

  virtual bool IsOnGround () const = 0;

  virtual void SetOnGround (bool onground) = 0;

  virtual void SetHugGround (bool hugGround) = 0;

  /*
   * Set maximum time delta to use when extrapolating positions.
   */
  virtual void SetDeltaLimit (float deltaLimit) = 0;

  virtual float GetDeltaLimit () const = 0;

  /*
   * Rotates the mesh by a certain amount. This function is intended to be
   * used internally and should not be used.
   */ 
  virtual bool RotateV (float delta) = 0;

  /*
   * Set value of gravity affecting this object.
   */
  virtual void SetGravity (float grav) = 0;

  /*
   * Get current value of gravity affecting this object.
   */
  virtual float GetGravity () = 0;

  /*
   * Reset gravity to default (19.6f) for this object.
   */
  virtual void ResetGravity () = 0;

  virtual void AddGravityCallback (iPcGravityCallback* callback) = 0;

  virtual void RemoveGravityCallback (iPcGravityCallback* callback) = 0;

  virtual csVector3 GetPortalDisplacement () = 0;

  virtual void ClearPortalDisplacement () = 0;

  virtual void SetFullPosition (const char* center_name, float yrot,
        iSector* sector) = 0;
  virtual void SetPosition (const char* center_name, float yrot,
        iSector* sector) = 0;
};

#endif