taoDNode.h

/* Copyright (c) 2005 Arachi, Inc. and Stanford University. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject
 * to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef _taoDNode_h
#define _taoDNode_h

#include "taoTypes.h"

class taoArticulatedBodyLink;
class taoJoint;
class deVector3;
class deVector6;
class deFrame;
class deMatrix3;

class taoDNode
{
public:
  taoDNode() : _abNode(NULL), _propagate(1),
  _id(-1), _isFixed(0), _cor(0), _cofg(0), _cofv(0), _cofs(0), _cofd(0) {}

  virtual ~taoDNode() {}

  virtual void sync(deFrame* local) = 0;

  virtual deInt isRoot() { return (getDParent() == NULL); }

  virtual deInt isParentRoot() { return (isRoot() || getDParent()->isRoot()); }

  virtual taoJoint* getJointList() = 0;
  virtual taoJoint const * getJointList() const = 0;

  virtual taoArticulatedBodyLink* getABNode() { return _abNode; }
  virtual void setABNode(taoArticulatedBodyLink* node) { _abNode = node; }


  virtual deInt getPropagate() { return _propagate; }
  virtual void setPropagate(deInt p) { _propagate = p; } // YYY

  virtual deVector6* velocity() = 0;
  virtual deVector6* acceleration() = 0;

  virtual deFrame* frameHome() = 0;
  virtual deFrame* frameLocal() = 0;
  //virtual deFrame* frameGlobal() = 0;
  virtual deFloat* mass() = 0;
  virtual deVector3* center() = 0;
  virtual deVector3 const * center() const = 0;
  virtual deMatrix3* inertia() = 0;
  virtual deVector6* force() = 0;
  virtual void zeroForce() = 0;
  virtual void addForce(const deVector6* f) = 0;

  virtual void updateFrame() = 0;
  virtual void integrate(deFloat dt) = 0;

  virtual taoDNode* getDParent() = 0;
  virtual taoDNode const * getDParent() const = 0;
  virtual void setDChild(taoDNode* n) = 0;
  virtual taoDNode* getDChild() = 0;
  virtual taoDNode const* getDChild() const = 0;
  virtual taoDNode* getDSibling() = 0;
  virtual taoDNode const* getDSibling() const = 0;

private:
  taoArticulatedBodyLink* _abNode;
  deInt _propagate;

  /* *********************************************
   *           Moved here from taoDNode
   * ********************************************* */
public:

  virtual deFrame* frameGlobal() = 0;
  virtual deFrame const * frameGlobal() const = 0;

  virtual void getFrameGraphics(deFrame* Fg) = 0;

  virtual void setID(const deInt id) { _id = id; }
  virtual deInt getID() const { return _id; }

  virtual void setIsFixed(const deInt f) { _isFixed = f; }
  virtual deInt getIsFixed() { return _isFixed; }

  virtual deFloat getCOR() { return _cor; }
  virtual deFloat getCOF_grip() { return _cofg; }
  virtual deFloat getCOF_viscous() { return _cofv; }
  virtual deFloat getCOF_static() { return _cofs; }
  virtual deFloat getCOF_dynamic() { return _cofd; }

  virtual void setCOR(deFloat c) { _cor = c; }
  virtual void setCOF_grip(deFloat c) { _cofg = c; }
  virtual void setCOF_viscous(deFloat c) { _cofv = c; }
  virtual void setCOF_static(deFloat c) { _cofs = c; }
  virtual void setCOF_dynamic(deFloat c) { _cofd = c; }

  virtual deFloat effectiveMass(const deVector3* Pie, const deVector3* Ui) { return 0; }
  virtual void linearVelocity(deVector3* Vie, const deVector3* Pie) {}
  virtual void linearAcceleration(deVector3* Aie, const deVector3* Pie) {}

  virtual void impulse(const deVector3* Pie, const deVector3* Yie) {}

  virtual void impulseDist(const deVector3* Pie, const deVector3* Yie) {}

  virtual void force(const deVector3* Pie, const deVector3* Fie) {}

  virtual deInt impact1(const deVector3* Pie, const deVector3* Ui, const deFloat cor2, const deFloat cofg2);

  virtual deInt impact2(taoDNode* ni, const deVector3* Pie, const deVector3* Ui,
      taoDNode* nj, const deVector3* Pje, const deVector3* Uj);

  virtual deInt penetration1(const deVector3* Pie, const deVector3* Ui, const deVector3* pdist, const deFloat dt);

  std::string name_;

private:
  deInt _id;
  deInt _isFixed;

  deFloat _cor;
  deFloat _cofg;
  deFloat _cofv;
  deFloat _cofs;
  deFloat _cofd;

  deInt _Impact1(const deVector3* Pie, const deVector3* Ui, const deVector3* V, const deFloat m, const deFloat vp, const deFloat vm, const deFloat cofg2);
  void _Friction(const deVector3* Pie, const deVector3* Ui, const deVector3* Ut, const deFloat vtmag, const deFloat m);
};

#endif // _taoDNode_h