Public API Reference

ivaria/physics.h

Go to the documentation of this file.

/*
    Copyright (C) 2011 by Liu Lu

    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 __IVARIA_PHYSIH__
#define __IVARIA_PHYSIH__

#include "csutil/scf.h"
#include "csutil/scf_interface.h"
#include "iutil/objreg.h"
#include "iengine/mesh.h"
#include "iengine/engine.h"
#include "imesh/genmesh.h"
#include "csgeom/tri.h"
#include "cstool/primitives.h"
#include "ivaria/collisions.h"

namespace CS 
{
namespace Mesh 
{
struct iAnimatedMesh;
} 
}

namespace CS
{
namespace Collisions
{
struct iCollisionCallback;
struct iCollisionObject;
struct CollisionGroup;
struct iCollisionObject;
}
}

namespace CS
{
namespace Physics
{

struct iJoint;
struct iObject;
struct iRigidBody;
struct iSoftBody;
struct iKinematicCallback;
struct iPhysicalSystem;

enum PhysicalBodyType
{
  BODY_RIGID = 0,
  BODY_SOFT
};

enum RigidBodyState
{
  STATE_STATIC = 0,
  STATE_DYNAMIC,
  STATE_KINEMATIC
};

struct iPhysicalBody : public virtual CS::Collisions::iCollisionObject
{
  SCF_INTERFACE (CS::Physics::iPhysicalBody, 1, 0, 0);

  virtual PhysicalBodyType GetBodyType () const = 0;

  virtual iRigidBody* QueryRigidBody () = 0;

  virtual iSoftBody* QuerySoftBody () = 0;

  virtual bool Disable () = 0;

  virtual bool Enable () = 0;

  virtual bool IsEnabled () = 0;

  virtual void SetMass (float mass) = 0;

  virtual float GetMass () = 0;

  virtual float GetDensity () const = 0;

  virtual void SetDensity (float density) = 0;

  virtual float GetVolume () = 0;
  
  virtual void AddForce (const csVector3& force) = 0;
  
  virtual csVector3 GetLinearVelocity (size_t index = 0) const = 0;

  virtual void SetFriction (float friction) = 0;

  virtual float GetFriction () = 0;
};

struct iRigidBody : public virtual iPhysicalBody
{
  SCF_INTERFACE (CS::Physics::iRigidBody, 1, 0, 0);

  virtual RigidBodyState GetState () = 0;
  
  virtual bool SetState (RigidBodyState state) = 0;

  virtual void SetElasticity (float elasticity) = 0;

  virtual float GetElasticity () = 0;

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

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

  virtual csVector3 GetAngularVelocity () const = 0;

  virtual void AddTorque (const csVector3& torque) = 0;

  virtual void AddRelForce (const csVector3& force) = 0;

  virtual void AddRelTorque (const csVector3& torque) = 0;

  virtual void AddForceAtPos (const csVector3& force,
      const csVector3& pos) = 0;

  virtual void AddForceAtRelPos (const csVector3& force,
      const csVector3& pos) = 0;

  virtual void AddRelForceAtPos (const csVector3& force,
      const csVector3& pos) = 0;

  virtual void AddRelForceAtRelPos (const csVector3& force,
      const csVector3& pos) = 0;

  virtual csVector3 GetForce () const = 0;

  virtual csVector3 GetTorque () const = 0;

  virtual void SetKinematicCallback (iKinematicCallback* cb) = 0;

  virtual iKinematicCallback* GetKinematicCallback () = 0;

  virtual void SetLinearDampener (float d) = 0;

  virtual float GetLinearDampener () = 0;

  virtual void SetRollingDampener (float d) = 0;

  virtual float GetRollingDampener () = 0;
};

struct iAnchorAnimationControl : public virtual iBase
{
  SCF_INTERFACE(CS::Physics::iAnchorAnimationControl, 1, 0, 0);

  virtual csVector3 GetAnchorPosition () const = 0;
};

struct iSoftBody : public virtual iPhysicalBody
{
  SCF_INTERFACE (CS::Physics::iSoftBody, 1, 0, 0);

  virtual void SetVertexMass (float mass, size_t index) = 0;

  virtual float GetVertexMass (size_t index) = 0;

  virtual size_t GetVertexCount () = 0;

  virtual csVector3 GetVertexPosition (size_t index) const = 0;

  virtual void AnchorVertex (size_t vertexIndex) = 0;

  virtual void AnchorVertex (size_t vertexIndex,
      iRigidBody* body) = 0;

  virtual void AnchorVertex (size_t vertexIndex,
      iAnchorAnimationControl* controller) = 0;

  virtual void UpdateAnchor (size_t vertexIndex,
      csVector3& position) = 0;

  virtual void RemoveAnchor (size_t vertexIndex) = 0;

  virtual void SetRigidity (float rigidity) = 0;

  virtual float GetRigidity () = 0;

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

  virtual void SetLinearVelocity (const csVector3& velocity,
      size_t vertexIndex) = 0;

  virtual void SetWindVelocity (const csVector3& velocity) = 0;

virtual const csVector3 GetWindVelocity () const = 0;

  virtual void AddForce (const csVector3& force, size_t vertexIndex) = 0;

  virtual size_t GetTriangleCount () = 0;

  virtual csTriangle GetTriangle (size_t index) const = 0;

  virtual csVector3 GetVertexNormal (size_t index) const = 0;
};

struct SoftBodyHelper
{
  static csPtr<iMeshFactoryWrapper> CreateClothGenMeshFactory
  (iObjectRegistry* object_reg, const char* factoryName, iSoftBody* cloth)
  {
    csRef<iEngine> engine = csQueryRegistry<iEngine> (object_reg);

    // Create the cloth mesh factory.
    csRef<iMeshFactoryWrapper> clothFact = engine->CreateMeshFactory
      ("crystalspace.mesh.object.genmesh", factoryName);
    if (!clothFact)
      return 0;

    csRef<iGeneralFactoryState> gmstate = scfQueryInterface<iGeneralFactoryState>
      (clothFact->GetMeshObjectFactory ());

    // Create the vertices of the genmesh
    size_t vertexCount = cloth->GetVertexCount ();
    gmstate->SetVertexCount (int (vertexCount * 2));
    csVector3* vertices = gmstate->GetVertices ();
    for (size_t i = 0; i < vertexCount; i++)
    {
      vertices[i] = cloth->GetVertexPosition (i);
      vertices[i + vertexCount] = cloth->GetVertexPosition (i);
    }

    // Create the triangles of the genmesh
    gmstate->SetTriangleCount (int (cloth->GetTriangleCount ()) * 2);
    csTriangle* triangles = gmstate->GetTriangles ();
    for (size_t i = 0; i < cloth->GetTriangleCount (); i++)
    {
      csTriangle triangle = cloth->GetTriangle (i);
      triangles[i * 2] = triangle;
      triangles[i * 2 + 1] = csTriangle (int (triangle[2] + vertexCount),
                                         int (triangle[1] + vertexCount),
                                         int (triangle[0] + vertexCount));
    }

    gmstate->CalculateNormals ();

    // Set up the texels of the genmesh
    csVector2* texels = gmstate->GetTexels ();
    csVector3* normals = gmstate->GetNormals ();
    CS::Geometry::TextureMapper* mapper = new CS::Geometry::DensityTextureMapper (1.0f);
    for (size_t i = 0; i < vertexCount * 2; i++)
      texels[i] = mapper->Map (vertices[i], normals[i], i);

    gmstate->Invalidate ();

    return csPtr<iMeshFactoryWrapper> (clothFact);
  }
};

struct iJoint : public virtual iBase
{
  SCF_INTERFACE (CS::Physics::iJoint, 1, 0, 0);

  virtual void Attach (iPhysicalBody* body1, iPhysicalBody* body2,
      bool forceUpdate = true) = 0;

  virtual iPhysicalBody* GetAttachedBody (int index) = 0;

  virtual void SetTransform (const csOrthoTransform& trans,
      bool forceUpdate = false) = 0;

  virtual csOrthoTransform GetTransform () const = 0;

  virtual void SetPosition (const csVector3& position,
    bool forceUpdate = false) = 0;

  virtual csVector3 GetPosition () const = 0;

  virtual void SetTransConstraints (bool X, 
      bool Y, bool Z, 
      bool forceUpdate = false) = 0;

  virtual bool IsXTransConstrained () = 0;

  virtual bool IsYTransConstrained () = 0;

  virtual bool IsZTransConstrained () = 0;

  virtual void SetMinimumDistance (const csVector3& dist,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetMinimumDistance () const = 0;

  virtual void SetMaximumDistance (const csVector3& dist,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetMaximumDistance () const = 0;

  virtual void SetRotConstraints (bool X, 
      bool Y, bool Z, 
      bool forceUpdate = false) = 0;

  virtual bool IsXRotConstrained () = 0;

  virtual bool IsYRotConstrained () = 0;

  virtual bool IsZRotConstrained () = 0;

  virtual void SetMinimumAngle (const csVector3& angle,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetMinimumAngle () const = 0;

  virtual void SetMaximumAngle (const csVector3& angle,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetMaximumAngle () const = 0;

  virtual void SetBounce (const csVector3& bounce,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetBounce () const = 0;

  virtual void SetDesiredVelocity (const csVector3& velo,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetDesiredVelocity () const = 0;

  virtual void SetMaxForce (const csVector3& force,
      bool forceUpdate = false) = 0;

  virtual csVector3 GetMaxForce () const = 0;

  virtual bool RebuildJoint () = 0;

  virtual void SetSpring(bool isSpring, bool forceUpdate = false) = 0;

  virtual void SetLinearStiffness (csVector3 stiff, bool forceUpdate = false) = 0;

  virtual csVector3 GetLinearStiffness () const = 0;

  virtual void SetAngularStiffness (csVector3 stiff, bool forceUpdate = false) = 0;

  virtual csVector3 GetAngularStiffness () const = 0;

  virtual void SetLinearDamping (csVector3 damp, bool forceUpdate = false) = 0;

  virtual csVector3 GetLinearDamping () const = 0;

  virtual void SetAngularDamping (csVector3 damp, bool forceUpdate = false) = 0;

  virtual csVector3 GetAngularDamping () const = 0;
  
  virtual void SetLinearEquilibriumPoint (csVector3 point, bool forceUpdate = false) = 0;

  virtual void SetAngularEquilibriumPoint (csVector3 point, bool forceUpdate = false) = 0;

  virtual void SetBreakingImpulseThreshold (float threshold, bool forceUpdate = false) = 0;

  virtual float GetBreakingImpulseThreshold () = 0;
};

struct iKinematicCallback : public virtual iBase
{
  SCF_INTERFACE (CS::Physics::iKinematicCallback, 1, 0, 0);

  virtual void GetBodyTransform (iRigidBody* body,
                                 csOrthoTransform& transform) const = 0;
};

struct iPhysicalSystem : public virtual iBase
{
  SCF_INTERFACE (CS::Physics::iPhysicalSystem, 1, 0, 0);

  virtual csRef<iRigidBody> CreateRigidBody () = 0;

  virtual csRef<iJoint> CreateJoint () = 0;

  /*
   * Create a P2P joint for rigid bodies by setting the position in 
   * world space.
   */
  virtual csRef<iJoint> CreateRigidP2PJoint (const csVector3 position) = 0;

  /* 
   * Create a slide joint for rigid bodies.
   * \param trans The transform of the joint in world space.
   * \param minDist The min distance the body can move along the axis.
   * \param maxDist The max distance the body can move along the axis.
   * \param minAngle The min angle the body can rotate around the axis.
   * \param maxAngle The max angle the body can rotate around the axis.
   * \param axis The slide axis, can only be 0, 1, 2.
   */
  virtual csRef<iJoint> CreateRigidSlideJoint (const csOrthoTransform trans,
    float minDist, float maxDist, float minAngle, float maxAngle, int axis) = 0;

  /* 
   * Create a hinge joint for rigid bodies.
   * \param position The position of the joint in world space.
   * \param minAngle The min angle the body can rotate around the axis.
   * \param maxAngle The max angle the body can rotate around the axis.
   * \param axis The axis of the hinge, can only be 0, 1, 2.
   */
  virtual csRef<iJoint> CreateRigidHingeJoint (const csVector3 position,
    float minAngle, float maxAngle, int axis) = 0;

  /* 
   * Create a cone twist joint for rigid bodies.
   * \param trans The transform of the joint in world space.
   * \param swingSpan1 The swing span the body can rotate around the local Z axis of joint.
   * \param swingSpan2 The swing span the body can rotate around the local Y axis of joint.
   * \param twistSpan The twist span the body can rotate around the local X axis of joint.
   */
  virtual csRef<iJoint> CreateRigidConeTwistJoint (const csOrthoTransform trans,
    float swingSpan1,float swingSpan2,float twistSpan) = 0;

  /* 
   * Create a linear joint for soft body by setting the position in 
   * world space.
   */
  virtual csRef<iJoint> CreateSoftLinearJoint (const csVector3 position) = 0;

  /* 
   * Create a angular joint for soft body by setting the rotation axis.
   * The axis can only be 0, 1, 2.
   */
  virtual csRef<iJoint> CreateSoftAngularJoint (int axis) = 0;

  /*
   * Create a pivot joint to attach to a rigid body to a position in world space
   * in order to manipulate it.
   */
  virtual csRef<iJoint> CreateRigidPivotJoint (iRigidBody* body, const csVector3 position) = 0;
  
  virtual csRef<iSoftBody> CreateRope (csVector3 start,
      csVector3 end, size_t segmentCount) = 0;

  virtual csRef<iSoftBody> CreateRope (csVector3* vertices, size_t vertexCount) = 0;

  virtual csRef<iSoftBody> CreateCloth (csVector3 corner1, csVector3 corner2,
      csVector3 corner3, csVector3 corner4,
      size_t segmentCount1, size_t segmentCount2,
      bool withDiagonals = false) = 0;

  virtual csRef<iSoftBody> CreateSoftBody (iGeneralFactoryState* genmeshFactory, 
    const csOrthoTransform& bodyTransform) = 0;

  virtual csRef<iSoftBody> CreateSoftBody (csVector3* vertices,
      size_t vertexCount, csTriangle* triangles,
      size_t triangleCount, const csOrthoTransform& bodyTransform) = 0;
};

struct iPhysicalSector : public virtual iBase
{
  SCF_INTERFACE (CS::Physics::iPhysicalSector, 1, 0, 0);

  virtual void SetSimulationSpeed (float speed) = 0;

  virtual void SetStepParameters (float timeStep, size_t maxSteps,
    size_t iterations) = 0;  

  virtual void Step (float duration) = 0;

  virtual void SetLinearDampener (float d) = 0;

  virtual float GetLinearDampener () const = 0;

  virtual void SetRollingDampener (float d) = 0;

  virtual float GetRollingDampener () const = 0;
  
  virtual void SetAutoDisableParams (float linear, float angular,
      float time) = 0;

  virtual void AddRigidBody (iRigidBody* body) = 0;

  virtual void RemoveRigidBody (iRigidBody* body) = 0;

  virtual size_t GetRigidBodyCount () = 0;

  virtual iRigidBody* GetRigidBody (size_t index) = 0;

  virtual iRigidBody* FindRigidBody (const char* name) = 0;

  virtual void AddSoftBody (iSoftBody* body) = 0;

  virtual void RemoveSoftBody (iSoftBody* body) = 0;

  virtual size_t GetSoftBodyCount () = 0;

  virtual iSoftBody* GetSoftBody (size_t index) = 0;

  virtual iSoftBody* FindSoftBody (const char* name) = 0;

  virtual void AddJoint (iJoint* joint) = 0;

  virtual void RemoveJoint (iJoint* joint) = 0;

  virtual void SetSoftBodyEnabled (bool enabled) = 0; 

  virtual bool GetSoftBodyEnabled () = 0;
};

struct iSoftBodyAnimationControlType : public iGenMeshAnimationControlType
{
  SCF_INTERFACE (CS::Physics::iSoftBodyAnimationControlType, 1, 0, 0);
};

struct iSoftBodyAnimationControlFactory : public iGenMeshAnimationControlFactory
{
  SCF_INTERFACE (CS::Physics::iSoftBodyAnimationControlFactory, 1, 0, 0);
};

struct iSoftBodyAnimationControl : public iGenMeshAnimationControl
{
  SCF_INTERFACE (CS::Physics::iSoftBodyAnimationControl, 1, 0, 0);

  virtual void SetSoftBody (iSoftBody* body, bool doubleSided = false) = 0;

  virtual iSoftBody* GetSoftBody () = 0;

  virtual void CreateAnimatedMeshAnchor (CS::Mesh::iAnimatedMesh* animesh,
    iRigidBody* body,
                size_t bodyVertexIndex,
                size_t animeshVertexIndex = (size_t) ~0) = 0;

  virtual size_t GetAnimatedMeshAnchorVertex (size_t bodyVertexIndex) = 0;

  virtual void RemoveAnimatedMeshAnchor (size_t bodyVertexIndex) = 0;
};
}
}
#endif

---