Public API Reference

cstool/collider.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2003 by Jorrit Tyberghein
    Written by Alex Pfaffe.

    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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __CS_COLLIDER_H__
#define __CS_COLLIDER_H__

#include "csextern.h"

#include "csgeom/box.h"
#include "csutil/csobject.h"
#include "csutil/leakguard.h"
#include "csutil/array.h"
#include "csutil/scf_implementation.h"
#include "csutil/set.h"

#include "ivaria/collider.h"

struct iCamera;
struct iCollider;
struct iCollideSystem;
struct iEngine;
struct iMeshWrapper;
struct iMovable;
struct iObject;
struct iPolygonMesh;
struct iRegion;
struct iSector;

struct csCollisionPair;
class csReversibleTransform;

struct csIntersectingTriangle;


class CS_CRYSTALSPACE_EXPORT csColliderWrapper : 
  public scfImplementationExt1<csColliderWrapper, 
                               csObject,
                               scfFakeInterface<csColliderWrapper> >
{
private:
  csRef<iCollideSystem> collide_system;
  csRef<iCollider> collider;

public:
  SCF_INTERFACE(csColliderWrapper, 2,0,0);

  CS_LEAKGUARD_DECLARE (csColliderWrapper);

  csColliderWrapper (csObject& parent, iCollideSystem* collide_system,
        iPolygonMesh* mesh);

  csColliderWrapper (iObject* parent, iCollideSystem* collide_system,
        iPolygonMesh* mesh);

  csColliderWrapper (iObject* parent, iCollideSystem* collide_system,
        iTerraFormer* terrain);

  csColliderWrapper (iObject* parent, iCollideSystem* collide_system,
        iCollider* collider);

  virtual ~csColliderWrapper ();

  iCollider* GetCollider () { return collider; }

  iCollideSystem* GetCollideSystem () { return collide_system; }

  bool Collide (csColliderWrapper& pOtherCollider,
                csReversibleTransform* pThisTransform = 0,
                csReversibleTransform* pOtherTransform = 0);
  bool Collide (csObject& otherObject,
                csReversibleTransform* pThisTransform = 0,
                csReversibleTransform* pOtherTransform = 0);
  bool Collide (iObject* otherObject,
                csReversibleTransform* pThisTransform = 0,
                csReversibleTransform* pOtherTransform = 0);

  static csColliderWrapper* GetColliderWrapper (csObject& object);

  static csColliderWrapper* GetColliderWrapper (iObject* object);
};

struct CS_CRYSTALSPACE_EXPORT csTraceBeamResult
{

  csIntersectingTriangle closest_tri;
  csVector3 closest_isect;
  iMeshWrapper* closest_mesh;
  float sqdistance;
  iSector* end_sector;
};

class CS_CRYSTALSPACE_EXPORT csColliderHelper
{
public:
  static csColliderWrapper* InitializeCollisionWrapper (iCollideSystem* colsys,
        iMeshWrapper* mesh);

  static void InitializeCollisionWrappers (iCollideSystem* colsys,
        iEngine* engine, iRegion* region = 0);

  static bool CollideArray (
        iCollideSystem* colsys,
        iCollider* collider,
        const csReversibleTransform* trans,
        int num_colliders,
        iCollider** colliders,
        csReversibleTransform **transforms);

  static int CollidePath (
        iCollideSystem* colsys,
        iCollider* collider, const csReversibleTransform* trans,
        float nbrsteps,
        csVector3& newpos,
        int num_colliders,
        iCollider** colliders,
        csReversibleTransform** transforms);

  static float TraceBeam (iCollideSystem* cdsys, iSector* sector,
        const csVector3& start, const csVector3& end,
        bool traverse_portals,
        csIntersectingTriangle& closest_tri,
        csVector3& closest_isect,
        iMeshWrapper** closest_mesh = 0,
        iSector** end_sector = 0);

  static csTraceBeamResult TraceBeam (iCollideSystem* cdsys, iSector* sector,
        const csVector3& start, const csVector3& end,
        bool traverse_portals);
};

class CS_CRYSTALSPACE_EXPORT csColliderActor
{
private:
  bool revertMove;
  bool onground;
  bool cd;
  csArray<csCollisionPair> our_cd_contact;
  float gravity;
  iMeshWrapper* mesh;
  iCamera* camera;
  iMovable* movable;
  iCollideSystem* cdsys;
  iEngine* engine;
  csVector3 velWorld;
  csSet<csPtrKey<iMeshWrapper> > hit_meshes;
  bool do_hit_meshes;

  csVector3 rotation;

  csRef<iCollider> topCollider;
  csRef<iCollider> bottomCollider;
  csBox3 boundingBox;
  csVector3 shift;
  csVector3 topSize;
  csVector3 bottomSize;
  csVector3 intervalSize;

  int revertCount;

  int CollisionDetect (
        iCollider *collider,
        iSector* sector,
        csReversibleTransform* transform,
        csReversibleTransform* old_transform);

  int CollisionDetectIterative (
        iCollider *collider,
        iSector* sector,
        csReversibleTransform* transform,
        csReversibleTransform* old_transform, csVector3& maxmove);
  bool MoveV (float delta, const csVector3& velBody);
  bool RotateV (float delta, const csVector3& angularVelocity);
  void InitializeColliders (const csVector3& legs,
        const csVector3& body, const csVector3& shift);

public:
  csColliderActor ();

  void SetCollideSystem (iCollideSystem* cdsys)
  {
    csColliderActor::cdsys = cdsys;
  }

  void SetEngine (iEngine* engine)
  {
    csColliderActor::engine = engine;
  }

  void InitializeColliders (iMeshWrapper* mesh, const csVector3& legs,
        const csVector3& body, const csVector3& shift);

  void InitializeColliders (iCamera* camera, const csVector3& legs,
        const csVector3& body, const csVector3& shift);

  void SetCamera (iCamera* camera, bool adjustRotation = true);

  void SetGravity (float g)
  {
    gravity = g;
    velWorld.y = 0;
  }

  float GetGravity () const { return gravity; }

  bool IsOnGround () const { return onground; }

  void SetOnGround (bool og) { onground = og; }

  bool HasCD () const { return cd; }

  void SetCD (bool c) { cd = c; }

  bool CheckRevertMove () const { return revertMove; }

  void EnableHitMeshes (bool hm) { do_hit_meshes = hm; }

  bool CheckHitMeshes () const { return do_hit_meshes; }

  const csSet<csPtrKey<iMeshWrapper> >& GetHitMeshes ()
  { return hit_meshes; }

  bool Move (float delta, float speed, const csVector3& velBody,
        const csVector3& angularVelocity);

  const csVector3& GetRotation () { return rotation; }

  void SetRotation (const csVector3& rot);

  bool AdjustForCollisions (const csVector3& oldpos,
        csVector3& newpos,
        const csVector3& vel,
        float delta);
};

#endif // __CS_COLLIDER_H__

---