pkg/box2d: 0.2.0 release

lib/src/dynamics/joints/wheel_joint.dart

 /*******************************************************************************
  * Copyright (c) 2015, Daniel Murphy, Google
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *  * Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
@@ skipping 216 matching lines @@
     double wB = data.velocities[_indexB].w;
 
     final Rot qA = pool.popRot();
     final Rot qB = pool.popRot();
     final Vector2 temp = pool.popVec2();
 
     qA.setAngle(aA);
     qB.setAngle(aB);
 
     // Compute the effective masses.
-    Rot.mulToOutUnsafe(
-        qA, temp.setFrom(_localAnchorA).sub(_localCenterA), rA);
-    Rot.mulToOutUnsafe(
-        qB, temp.setFrom(_localAnchorB).sub(_localCenterB), rB);
+    Rot.mulToOutUnsafe(qA, temp.setFrom(_localAnchorA).sub(_localCenterA), rA);
+    Rot.mulToOutUnsafe(qB, temp.setFrom(_localAnchorB).sub(_localCenterB), rB);
     d.setFrom(cB).add(rB).sub(cA).sub(rA);
 
     // Point to line constraint
     {
       Rot.mulToOut(qA, _localYAxisA, _ay);
       _sAy = temp.setFrom(d).add(rA).cross(_ay);
       _sBy = rB.cross(_ay);
 
       _mass = mA + mB + iA * _sAy * _sAy + iB * _sBy * _sBy;
 
@@ skipping 99 matching lines @@
     Vector2 vA = data.velocities[_indexA].v;
     double wA = data.velocities[_indexA].w;
     Vector2 vB = data.velocities[_indexB].v;
     double wB = data.velocities[_indexB].w;
 
     final Vector2 temp = pool.popVec2();
     final Vector2 P = pool.popVec2();
 
     // Solve spring constraint
     {
-      double Cdot =
-          _ax.dot(temp.setFrom(vB).sub(vA)) + _sBx * wB - _sAx * wA;
-      double impulse =
-          -_springMass * (Cdot + _bias + _gamma * _springImpulse);
+      double Cdot = _ax.dot(temp.setFrom(vB).sub(vA)) + _sBx * wB - _sAx * wA;
+      double impulse = -_springMass * (Cdot + _bias + _gamma * _springImpulse);
       _springImpulse += impulse;
 
       P.x = impulse * _ax.x;
       P.y = impulse * _ax.y;
       double LA = impulse * _sAx;
       double LB = impulse * _sBx;
 
       vA.x -= mA * P.x;
       vA.y -= mA * P.y;
       wA -= iA * LA;
@@ skipping 13 matching lines @@
       _motorImpulse = MathUtils.clampDouble(
           _motorImpulse + impulse, -maxImpulse, maxImpulse);
       impulse = _motorImpulse - oldImpulse;
 
       wA -= iA * impulse;
       wB += iB * impulse;
     }
 
     // Solve point to line constraint
     {
-      double Cdot =
-          _ay.dot(temp.setFrom(vB).sub(vA)) + _sBy * wB - _sAy * wA;
+      double Cdot = _ay.dot(temp.setFrom(vB).sub(vA)) + _sBy * wB - _sAy * wA;
       double impulse = -_mass * Cdot;
       _impulse += impulse;
 
       P.x = impulse * _ay.x;
       P.y = impulse * _ay.y;
       double LA = impulse * _sAy;
       double LB = impulse * _sBy;
 
       vA.x -= mA * P.x;
       vA.y -= mA * P.y;
@@ skipping 29 matching lines @@
     d.setFrom(cB).sub(cA).add(rB).sub(rA);
 
     Vector2 ay = pool.popVec2();
     Rot.mulToOut(qA, _localYAxisA, ay);
 
     double sAy = temp.setFrom(d).add(rA).cross(ay);
     double sBy = rB.cross(ay);
 
     double C = d.dot(ay);
 
-    double k = _invMassA +
-        _invMassB +
-        _invIA * _sAy * _sAy +
-        _invIB * _sBy * _sBy;
+    double k =
+        _invMassA + _invMassB + _invIA * _sAy * _sAy + _invIB * _sBy * _sBy;
 
     double impulse;
     if (k != 0.0) {
       impulse = -C / k;
     } else {
       impulse = 0.0;
     }
 
     final Vector2 P = pool.popVec2();
     P.x = impulse * ay.x;
@@ skipping 11 matching lines @@
     pool.pushVec2(3);
     pool.pushRot(2);
     // data.positions[_indexA].c = cA;
     data.positions[_indexA].a = aA;
     // data.positions[_indexB].c = cB;
     data.positions[_indexB].a = aB;
 
     return C.abs() <= Settings.linearSlop;
   }
 }