Dart Documentationbox2d_consoleSeparationFunction

SeparationFunction class

class SeparationFunction {
  DistanceProxy proxyA;
  DistanceProxy proxyB;
  int type;
  final Vector localPoint;
  final Vector axis;
  Sweep sweepA;
  Sweep sweepB;

  /** Pooling */
  final Vector localPointA;
  final Vector localPointB;
  final Vector pointA;
  final Vector pointB;
  final Vector localPointA1;
  final Vector localPointA2;
  final Vector normal;
  final Vector localPointB1;
  final Vector localPointB2;
  final Vector axisA;
  final Vector axisB;
  final Vector temp;
  final Transform xfa;
  final Transform xfb;

  SeparationFunction() :
    proxyA = new DistanceProxy(),
    proxyB = new DistanceProxy(),
    type = SeparationType.POINTS,
    localPoint = new Vector(),
    axis = new Vector(),
    sweepA = new Sweep(),
    sweepB = new Sweep(),
    localPointA = new Vector(),
    localPointB = new Vector(),
    pointA = new Vector(),
    pointB = new Vector(),
    localPointA1 = new Vector(),
    localPointA2 = new Vector(),
    normal = new Vector(),
    localPointB1 = new Vector(),
    localPointB2 = new Vector(),
    temp = new Vector(),
    xfa = new Transform(),
    xfb = new Transform(),
    axisA = new Vector(),
    axisB = new Vector() { }

  num initialize(SimplexCache cache, DistanceProxy argProxyA, Sweep
      argSweepA, DistanceProxy argProxyB, Sweep argSweepB, num t1) {
    proxyA = argProxyA;
    proxyB = argProxyB;
    int count = cache.count;
    assert (0 < count && count < 3);

    sweepA = argSweepA;
    sweepB = argSweepB;

    sweepA.getTransform(xfa, t1);
    sweepB.getTransform(xfb, t1);

    if (count == 1) {
      type = SeparationType.POINTS;
      localPointA.setFrom(proxyA.vertices[cache.indexA[0]]);
      localPointB.setFrom(proxyB.vertices[cache.indexB[0]]);
      Transform.mulToOut(xfa, localPointA, pointA);
      Transform.mulToOut(xfb, localPointB, pointB);
      axis.setFrom(pointB).subLocal(pointA);
      num s = axis.normalize();
      return s;
    } else if (cache.indexA[0] == cache.indexA[1]) {
      // Two points on B and one on A.
      type = SeparationType.FACE_B;

      localPointB1.setFrom(proxyB.vertices[cache.indexB[0]]);
      localPointB2.setFrom(proxyB.vertices[cache.indexB[1]]);

      temp.setFrom(localPointB2).subLocal(localPointB1);
      Vector.crossVectorAndNumToOut(temp, 1, axis);
      axis.normalize();

      Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);

      localPoint.setFrom(localPointB1);
      localPoint.addLocal(localPointB2);
      localPoint.mulLocal(.5);
      Transform.mulToOut(xfb, localPoint, pointB);

      localPointA.setFrom(proxyA.vertices[cache.indexA[0]]);
      Transform.mulToOut(xfa, localPointA, pointA);

      temp.setFrom(pointA);
      temp.subLocal(pointB);
      num s = Vector.dot(temp, normal);
      if (s < 0.0) {
        axis.negateLocal();
        s = -s;
      }

      return s;
    } else {
      // Two points on A and one or two points on B.
      type = SeparationType.FACE_A;

      localPointA1.setFrom(proxyA.vertices[cache.indexA[0]]);
      localPointA2.setFrom(proxyA.vertices[cache.indexA[1]]);

      temp.setFrom(localPointA2);
      temp.subLocal(localPointA1);
      Vector.crossVectorAndNumToOut(temp, 1.0, axis);
      axis.normalize();

      Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);

      localPoint.setFrom(localPointA1);
      localPoint.addLocal(localPointA2);
      localPoint.mulLocal(.5);
      Transform.mulToOut(xfa, localPoint, pointA);

      localPointB.setFrom(proxyB.vertices[cache.indexB[0]]);
      Transform.mulToOut(xfb, localPointB, pointB);

      temp.setFrom(pointB);
      temp.subLocal(pointA);
      num s = Vector.dot(temp, normal);
      if (s < 0.0) {
        axis.negateLocal();
        s = -s;
      }
      return s;
    }
  }

  num findMinSeparation(List<int> indexes, num t) {
    sweepA.getTransform(xfa, t);
    sweepB.getTransform(xfb, t);

    switch (type) {
      case SeparationType.POINTS:
        Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation, axis, axisA);
        Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, axis.negateLocal(),
            axisB);
        axis.negateLocal();

        indexes[0] = proxyA.getSupport(axisA);
        indexes[1] = proxyB.getSupport(axisB);

        localPointA.setFrom(proxyA.vertices[indexes[0]]);
        localPointB.setFrom(proxyB.vertices[indexes[1]]);

        Transform.mulToOut(xfa, localPointA, pointA);
        Transform.mulToOut(xfb, localPointB, pointB);

        num separation = Vector.dot(pointB.subLocal(pointA), axis);
        return separation;

      case SeparationType.FACE_A:
        Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);
        Transform.mulToOut(xfa, localPoint, pointA);

        normal.negateLocal();
        Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, normal, axisB);
        normal.negateLocal();

        indexes[0] = -1;
        indexes[1] = proxyB.getSupport(axisB);

        localPointB.setFrom(proxyB.vertices[indexes[1]]);
        Transform.mulToOut(xfb, localPointB, pointB);

        num separation = Vector.dot(pointB.subLocal(pointA), normal);
        return separation;

      case SeparationType.FACE_B:
        Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);
        Transform.mulToOut(xfb, localPoint, pointB);

        Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation,
            normal.negateLocal(), axisA);
        normal.negateLocal();

        indexes[1] = -1;
        indexes[0] = proxyA.getSupport(axisA);

        localPointA.setFrom(proxyA.vertices[indexes[0]]);
        Transform.mulToOut(xfa, localPointA, pointA);

        num separation = Vector.dot(pointA.subLocal(pointB), normal);
        return separation;

      default:
        assert (false);
        indexes[0] = -1;
        indexes[1] = -1;
        return 0;
    }
  }

  num evaluate(int indexA, int indexB, num t) {
    sweepA.getTransform(xfa, t);
    sweepB.getTransform(xfb, t);

    switch (type) {
      case SeparationType.POINTS:
        Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation, axis, axisA);
        Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, axis.negateLocal(),
            axisB);
        axis.negateLocal();

        localPointA.setFrom(proxyA.vertices[indexA]);
        localPointB.setFrom(proxyB.vertices[indexB]);

        Transform.mulToOut(xfa, localPointA, pointA);
        Transform.mulToOut(xfb, localPointB, pointB);

        num separation = Vector.dot(pointB.subLocal(pointA), axis);
        return separation;

      case SeparationType.FACE_A:
        Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);
        Transform.mulToOut(xfa, localPoint, pointA);

        normal.negateLocal();
        Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, normal, axisB);
        normal.negateLocal();

        localPointB.setFrom(proxyB.vertices[indexB]);
        Transform.mulToOut(xfb, localPointB, pointB);
        num separation = Vector.dot(pointB.subLocal(pointA), normal);
        return separation;

      case SeparationType.FACE_B:
        Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);
        Transform.mulToOut(xfb, localPoint, pointB);

        Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation,
            normal.negateLocal(), axisA);
        normal.negateLocal();

        localPointA.setFrom(proxyA.vertices[indexA]);
        Transform.mulToOut(xfa, localPointA, pointA);

        num separation = Vector.dot(pointA.subLocal(pointB), normal);
        return separation;

      default:
        assert (false);
        return 0;
    }
  }
}

Constructors

new SeparationFunction() #

SeparationFunction() :
  proxyA = new DistanceProxy(),
  proxyB = new DistanceProxy(),
  type = SeparationType.POINTS,
  localPoint = new Vector(),
  axis = new Vector(),
  sweepA = new Sweep(),
  sweepB = new Sweep(),
  localPointA = new Vector(),
  localPointB = new Vector(),
  pointA = new Vector(),
  pointB = new Vector(),
  localPointA1 = new Vector(),
  localPointA2 = new Vector(),
  normal = new Vector(),
  localPointB1 = new Vector(),
  localPointB2 = new Vector(),
  temp = new Vector(),
  xfa = new Transform(),
  xfb = new Transform(),
  axisA = new Vector(),
  axisB = new Vector() { }

Properties

final Vector axis #

final Vector axis;

final Vector axisA #

final Vector axisA;

final Vector axisB #

final Vector axisB;

final Vector localPoint #

final Vector localPoint;

final Vector localPointA #

Pooling

final Vector localPointA;

final Vector localPointA1 #

final Vector localPointA1;

final Vector localPointA2 #

final Vector localPointA2;

final Vector localPointB #

final Vector localPointB;

final Vector localPointB1 #

final Vector localPointB1;

final Vector localPointB2 #

final Vector localPointB2;

final Vector normal #

final Vector normal;

final Vector pointA #

final Vector pointA;

final Vector pointB #

final Vector pointB;

DistanceProxy proxyA #

DistanceProxy proxyA;

DistanceProxy proxyB #

DistanceProxy proxyB;

final Type runtimeType #

inherited from Object

A representation of the runtime type of the object.

external Type get runtimeType;

Sweep sweepA #

Sweep sweepA;

Sweep sweepB #

Sweep sweepB;

final Vector temp #

final Vector temp;

int type #

int type;

final Transform xfa #

final Transform xfa;

final Transform xfb #

final Transform xfb;

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

num evaluate(int indexA, int indexB, num t) #

num evaluate(int indexA, int indexB, num t) {
  sweepA.getTransform(xfa, t);
  sweepB.getTransform(xfb, t);

  switch (type) {
    case SeparationType.POINTS:
      Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation, axis, axisA);
      Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, axis.negateLocal(),
          axisB);
      axis.negateLocal();

      localPointA.setFrom(proxyA.vertices[indexA]);
      localPointB.setFrom(proxyB.vertices[indexB]);

      Transform.mulToOut(xfa, localPointA, pointA);
      Transform.mulToOut(xfb, localPointB, pointB);

      num separation = Vector.dot(pointB.subLocal(pointA), axis);
      return separation;

    case SeparationType.FACE_A:
      Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);
      Transform.mulToOut(xfa, localPoint, pointA);

      normal.negateLocal();
      Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, normal, axisB);
      normal.negateLocal();

      localPointB.setFrom(proxyB.vertices[indexB]);
      Transform.mulToOut(xfb, localPointB, pointB);
      num separation = Vector.dot(pointB.subLocal(pointA), normal);
      return separation;

    case SeparationType.FACE_B:
      Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);
      Transform.mulToOut(xfb, localPoint, pointB);

      Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation,
          normal.negateLocal(), axisA);
      normal.negateLocal();

      localPointA.setFrom(proxyA.vertices[indexA]);
      Transform.mulToOut(xfa, localPointA, pointA);

      num separation = Vector.dot(pointA.subLocal(pointB), normal);
      return separation;

    default:
      assert (false);
      return 0;
  }
}

num findMinSeparation(List<int> indexes, num t) #

num findMinSeparation(List<int> indexes, num t) {
  sweepA.getTransform(xfa, t);
  sweepB.getTransform(xfb, t);

  switch (type) {
    case SeparationType.POINTS:
      Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation, axis, axisA);
      Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, axis.negateLocal(),
          axisB);
      axis.negateLocal();

      indexes[0] = proxyA.getSupport(axisA);
      indexes[1] = proxyB.getSupport(axisB);

      localPointA.setFrom(proxyA.vertices[indexes[0]]);
      localPointB.setFrom(proxyB.vertices[indexes[1]]);

      Transform.mulToOut(xfa, localPointA, pointA);
      Transform.mulToOut(xfb, localPointB, pointB);

      num separation = Vector.dot(pointB.subLocal(pointA), axis);
      return separation;

    case SeparationType.FACE_A:
      Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);
      Transform.mulToOut(xfa, localPoint, pointA);

      normal.negateLocal();
      Matrix22.mulTransMatrixAndVectorToOut(xfb.rotation, normal, axisB);
      normal.negateLocal();

      indexes[0] = -1;
      indexes[1] = proxyB.getSupport(axisB);

      localPointB.setFrom(proxyB.vertices[indexes[1]]);
      Transform.mulToOut(xfb, localPointB, pointB);

      num separation = Vector.dot(pointB.subLocal(pointA), normal);
      return separation;

    case SeparationType.FACE_B:
      Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);
      Transform.mulToOut(xfb, localPoint, pointB);

      Matrix22.mulTransMatrixAndVectorToOut(xfa.rotation,
          normal.negateLocal(), axisA);
      normal.negateLocal();

      indexes[1] = -1;
      indexes[0] = proxyA.getSupport(axisA);

      localPointA.setFrom(proxyA.vertices[indexes[0]]);
      Transform.mulToOut(xfa, localPointA, pointA);

      num separation = Vector.dot(pointA.subLocal(pointB), normal);
      return separation;

    default:
      assert (false);
      indexes[0] = -1;
      indexes[1] = -1;
      return 0;
  }
}

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();

num initialize(SimplexCache cache, DistanceProxy argProxyA, Sweep argSweepA, DistanceProxy argProxyB, Sweep argSweepB, num t1) #

num initialize(SimplexCache cache, DistanceProxy argProxyA, Sweep
    argSweepA, DistanceProxy argProxyB, Sweep argSweepB, num t1) {
  proxyA = argProxyA;
  proxyB = argProxyB;
  int count = cache.count;
  assert (0 < count && count < 3);

  sweepA = argSweepA;
  sweepB = argSweepB;

  sweepA.getTransform(xfa, t1);
  sweepB.getTransform(xfb, t1);

  if (count == 1) {
    type = SeparationType.POINTS;
    localPointA.setFrom(proxyA.vertices[cache.indexA[0]]);
    localPointB.setFrom(proxyB.vertices[cache.indexB[0]]);
    Transform.mulToOut(xfa, localPointA, pointA);
    Transform.mulToOut(xfb, localPointB, pointB);
    axis.setFrom(pointB).subLocal(pointA);
    num s = axis.normalize();
    return s;
  } else if (cache.indexA[0] == cache.indexA[1]) {
    // Two points on B and one on A.
    type = SeparationType.FACE_B;

    localPointB1.setFrom(proxyB.vertices[cache.indexB[0]]);
    localPointB2.setFrom(proxyB.vertices[cache.indexB[1]]);

    temp.setFrom(localPointB2).subLocal(localPointB1);
    Vector.crossVectorAndNumToOut(temp, 1, axis);
    axis.normalize();

    Matrix22.mulMatrixAndVectorToOut(xfb.rotation, axis, normal);

    localPoint.setFrom(localPointB1);
    localPoint.addLocal(localPointB2);
    localPoint.mulLocal(.5);
    Transform.mulToOut(xfb, localPoint, pointB);

    localPointA.setFrom(proxyA.vertices[cache.indexA[0]]);
    Transform.mulToOut(xfa, localPointA, pointA);

    temp.setFrom(pointA);
    temp.subLocal(pointB);
    num s = Vector.dot(temp, normal);
    if (s < 0.0) {
      axis.negateLocal();
      s = -s;
    }

    return s;
  } else {
    // Two points on A and one or two points on B.
    type = SeparationType.FACE_A;

    localPointA1.setFrom(proxyA.vertices[cache.indexA[0]]);
    localPointA2.setFrom(proxyA.vertices[cache.indexA[1]]);

    temp.setFrom(localPointA2);
    temp.subLocal(localPointA1);
    Vector.crossVectorAndNumToOut(temp, 1.0, axis);
    axis.normalize();

    Matrix22.mulMatrixAndVectorToOut(xfa.rotation, axis, normal);

    localPoint.setFrom(localPointA1);
    localPoint.addLocal(localPointA2);
    localPoint.mulLocal(.5);
    Transform.mulToOut(xfa, localPoint, pointA);

    localPointB.setFrom(proxyB.vertices[cache.indexB[0]]);
    Transform.mulToOut(xfb, localPointB, pointB);

    temp.setFrom(pointB);
    temp.subLocal(pointA);
    num s = Vector.dot(temp, normal);
    if (s < 0.0) {
      axis.negateLocal();
      s = -s;
    }
    return s;
  }
}

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 SeparationFunction() #

SeparationFunction() :
  proxyA = new DistanceProxy(),
  proxyB = new DistanceProxy(),
  type = SeparationType.POINTS,
  localPoint = new Vector(),
  axis = new Vector(),
  sweepA = new Sweep(),
  sweepB = new Sweep(),
  localPointA = new Vector(),
  localPointB = new Vector(),
  pointA = new Vector(),
  pointB = new Vector(),
  localPointA1 = new Vector(),
  localPointA2 = new Vector(),
  normal = new Vector(),
  localPointB1 = new Vector(),
  localPointB2 = new Vector(),
  temp = new Vector(),
  xfa = new Transform(),
  xfb = new Transform(),
  axisA = new Vector(),
  axisB = new Vector() { }

String toString() #

inherited from Object

Returns a string representation of this object.

external String toString();