Dart Documentationbox2d_consoleRevoluteJointDef

RevoluteJointDef class

Revolute joint definition. This requires defining an anchor point where the bodies are joined. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. You also need to specify the initial relative angle for joint limits. This helps when saving and loading a game. The local anchor points are measured from the body's origin rather than the center of mass because... - You might not know where the center of mass will be. - If you add/remove shapes from a body and recompute the mass, the joints will be broken.

class RevoluteJointDef extends JointDef {
  /**
   *  The local anchor point relative to body1's origin.
   */
  Vector localAnchorA;

  /**
   *  The local anchor point relative to body2's origin.
   */
  Vector localAnchorB;

  /**
   *  The body2 angle minus body1 angle in the reference state (radians).
   */
  num referenceAngle;

  /**
   *  A flag to enable joint limits.
   */
  bool enableLimit;

  /**
   *  The lower angle for the joint limit (radians).
   */
  num lowerAngle;

  /**
   *  The upper angle for the joint limit (radians).
   */
  num upperAngle;

  /**
   *  A flag to enable the joint motor.
   */
  bool enableMotor;

  /**
   *  The desired motor speed. Usually in radians per second.
   */
  num motorSpeed;

  /**
   *  The maximum motor torque used to achieve the desired motor speed.
   *  Usually in N-m.
   */
  num maxMotorTorque;

  RevoluteJointDef() :
    super(),
    localAnchorA = new Vector(0.0, 0.0),
    localAnchorB = new Vector(0.0, 0.0),
    referenceAngle = 0.0,
    lowerAngle = 0.0,
    upperAngle = 0.0,
    maxMotorTorque = 0.0,
    motorSpeed = 0.0,
    enableLimit = false,
    enableMotor = false {
    type = JointType.REVOLUTE;
  }

  /**
   * Initialize the bodies, anchors, and reference angle using the world
   * anchor.
   */
  void initialize(Body b1, Body b2, Vector anchor) {
    bodyA = b1;
    bodyB = b2;
    bodyA.getLocalPointToOut(anchor, localAnchorA);
    bodyB.getLocalPointToOut(anchor, localAnchorB);
    referenceAngle = bodyA.angle - bodyB.angle;
  }
}

Extends

JointDef > RevoluteJointDef

Constructors

new RevoluteJointDef() #

RevoluteJointDef() :
  super(),
  localAnchorA = new Vector(0.0, 0.0),
  localAnchorB = new Vector(0.0, 0.0),
  referenceAngle = 0.0,
  lowerAngle = 0.0,
  upperAngle = 0.0,
  maxMotorTorque = 0.0,
  motorSpeed = 0.0,
  enableLimit = false,
  enableMotor = false {
  type = JointType.REVOLUTE;
}

Properties

Body bodyA #

inherited from JointDef

The first attached body.

Body bodyA;

Body bodyB #

inherited from JointDef

The second attached body.

Body bodyB;

bool collideConnected #

inherited from JointDef

Set this flag to true if the attached bodies should collide.

bool collideConnected;

bool enableLimit #

A flag to enable joint limits.

bool enableLimit;

bool enableMotor #

A flag to enable the joint motor.

bool enableMotor;

Vector localAnchorA #

The local anchor point relative to body1's origin.

Vector localAnchorA;

Vector localAnchorB #

The local anchor point relative to body2's origin.

Vector localAnchorB;

num lowerAngle #

The lower angle for the joint limit (radians).

num lowerAngle;

num maxMotorTorque #

The maximum motor torque used to achieve the desired motor speed. Usually in N-m.

num maxMotorTorque;

num motorSpeed #

The desired motor speed. Usually in radians per second.

num motorSpeed;

num referenceAngle #

The body2 angle minus body1 angle in the reference state (radians).

num referenceAngle;

final Type runtimeType #

inherited from Object

A representation of the runtime type of the object.

external Type get runtimeType;

int type #

inherited from JointDef

The joint type is set automatically for concrete joint types.

int type;

num upperAngle #

The upper angle for the joint limit (radians).

num upperAngle;

Object userData #

inherited from JointDef

Use this to attach application specific data to your joints.

Object userData;

Operators

bool operator ==(other) #

inherited from Object

The equality operator.

The default behavior for all Objects is to return true if and only if this and other are the same object.

If a subclass overrides the equality operator it should override the hashCode method as well to maintain consistency.

bool operator ==(other) => identical(this, other);

Methods

int hashCode() #

inherited from Object

Get a hash code for this object.

All objects have hash codes. Hash codes are guaranteed to be the same for objects that are equal when compared using the equality operator ==. Other than that there are no guarantees about the hash codes. They will not be consistent between runs and there are no distribution guarantees.

If a subclass overrides hashCode it should override the equality operator as well to maintain consistency.

external int hashCode();

void initialize(Body b1, Body b2, Vector anchor) #

Initialize the bodies, anchors, and reference angle using the world anchor.

void initialize(Body b1, Body b2, Vector anchor) {
  bodyA = b1;
  bodyB = b2;
  bodyA.getLocalPointToOut(anchor, localAnchorA);
  bodyB.getLocalPointToOut(anchor, localAnchorB);
  referenceAngle = bodyA.angle - bodyB.angle;
}

new JointDef() #

inherited from JointDef
JointDef() :
  type = JointType.UNKNOWN,
  userData = null,
  bodyA = null,
  bodyB = null,
  collideConnected = false { }

noSuchMethod(String name, List args) #

inherited from Object

noSuchMethod is invoked when users invoke a non-existant method on an object. The name of the method and the arguments of the invocation are passed to noSuchMethod. If noSuchMethod returns a value, that value becomes the result of the original invocation.

The default behavior of noSuchMethod is to throw a noSuchMethodError.

external Dynamic noSuchMethod(String name, List args);

const Object() #

inherited from Object

Creates a new Object instance.

Object instances have no meaningful state, and are only useful through their identity. An Object instance is equal to itself only.

const Object();

new RevoluteJointDef() #

RevoluteJointDef() :
  super(),
  localAnchorA = new Vector(0.0, 0.0),
  localAnchorB = new Vector(0.0, 0.0),
  referenceAngle = 0.0,
  lowerAngle = 0.0,
  upperAngle = 0.0,
  maxMotorTorque = 0.0,
  motorSpeed = 0.0,
  enableLimit = false,
  enableMotor = false {
  type = JointType.REVOLUTE;
}

String toString() #

inherited from Object

Returns a string representation of this object.

external String toString();