예제 #1
0
  /**
   * Calculates the inverse of this transform.
   *
   * @return the inverted transform
   */
  public CCTransform invert() {
    CCTransform result = new CCTransform();

    if (_myIsIdentity) {
      result.setIdentity();
      return result;
    }

    result._myMatrix.set(_myMatrix);
    if (_myIsRotationMatrix) {
      if (_myIsUniformScale) {
        final double sx = _myScale.x;
        result._myMatrix.transposeLocal();
        if (sx != 1.0) {
          result._myMatrix.multiplyLocal(1.0f / sx);
        }
      } else {
        result._myMatrix.set(result._myMatrix.multiplyDiagonalPost(_myScale).invertLocal());
      }
    } else {
      result._myMatrix.invertLocal();
    }

    result._myTranslation.set(result._myMatrix.applyPost(_myTranslation).negateLocal());
    result.updateFlags(_myIsRotationMatrix);

    return result;
  }
예제 #2
0
 /**
  * @param o the object to compare for equality
  * @return true if this transform and the provided transform have the exact same double values.
  */
 public boolean strictEquals(final Object o) {
   if (this == o) {
     return true;
   }
   if (!(o instanceof CCTransform)) {
     return false;
   }
   final CCTransform comp = (CCTransform) o;
   return _myMatrix.strictEquals(comp.getMatrix())
       && _myScale.equals(comp.scale())
       && _myTranslation.equals(comp.translation());
 }
예제 #3
0
  /**
   * Check a transform... if it is null or one of its members are invalid, return false. Else return
   * true.
   *
   * @param transform the transform to check
   * @return true or false as stated above.
   */
  public static boolean isValid(final CCTransform transform) {
    if (transform == null) {
      return false;
    }
    if (!CCVector3.isValid(transform.scale())
        || !CCVector3.isValid(transform.translation())
        || !CCMatrix3x3.isValid(transform.getMatrix())) {
      return false;
    }

    return true;
  }
예제 #4
0
  /**
   * Constructs a new Transform object from the information stored in the given source Transform.
   *
   * @param theSource
   * @throws NullPointerException if source is null.
   */
  public CCTransform(final CCTransform theSource) {
    _myMatrix.set(theSource.getMatrix());
    _myScale.set(theSource.scale());
    _myTranslation.set(theSource.translation());

    _myIsIdentity = theSource.isIdentity();
    _myIsRotationMatrix = theSource.isRotationMatrix();
    _myIsUniformScale = theSource.isUniformScale();
  }
예제 #5
0
  /**
   * Copies the given transform values into this transform object.
   *
   * @param source
   * @return this transform for chaining.
   * @throws NullPointerException if source is null.
   */
  public CCTransform set(final CCTransform source) {
    if (source.isIdentity()) {
      setIdentity();
    } else {
      _myMatrix.set(source.getMatrix());
      _myScale.set(source.scale());
      _myTranslation.set(source.translation());

      _myIsIdentity = false;
      _myIsRotationMatrix = source.isRotationMatrix();
      _myIsUniformScale = source.isUniformScale();
    }
    return this;
  }
예제 #6
0
 /**
  * @param o the object to compare for equality
  * @return true if this transform and the provided transform have the same values.
  */
 @Override
 public boolean equals(final Object o) {
   if (this == o) {
     return true;
   }
   if (!(o instanceof CCTransform)) {
     return false;
   }
   final CCTransform comp = (CCTransform) o;
   return _myMatrix.equals(comp.getMatrix())
       && Math.abs(_myTranslation.x - comp.translation().x) < CCTransform.ALLOWED_DEVIANCE
       && Math.abs(_myTranslation.y - comp.translation().y) < CCTransform.ALLOWED_DEVIANCE
       && Math.abs(_myTranslation.z - comp.translation().z) < CCTransform.ALLOWED_DEVIANCE
       && Math.abs(_myScale.x - comp.scale().x) < CCTransform.ALLOWED_DEVIANCE
       && Math.abs(_myScale.y - comp.scale().y) < CCTransform.ALLOWED_DEVIANCE
       && Math.abs(_myScale.z - comp.scale().z) < CCTransform.ALLOWED_DEVIANCE;
 }
예제 #7
0
  /**
   * Calculates the product of this transform with the given "transformBy" transform (P = this * T)
   * and stores this in store.
   *
   * @param transformBy
   * @return the product
   * @throws NullPointerException if transformBy is null.
   */
  public CCTransform multiply(final CCTransform transformBy, CCTransform theStore) {
    if (theStore == null) theStore = new CCTransform();

    if (_myIsIdentity) {
      return theStore.set(transformBy);
    }

    if (transformBy.isIdentity()) {
      return theStore.set(this);
    }

    if (_myIsRotationMatrix && transformBy.isRotationMatrix() && _myIsUniformScale) {
      theStore._myIsRotationMatrix = true;
      theStore._myMatrix.set(_myMatrix).multiplyLocal(transformBy.getMatrix());

      theStore._myTranslation.set(transformBy.translation());
      theStore._myTranslation.set(_myMatrix.applyPost(theStore._myTranslation));
      // uniform scale, so just use X.
      theStore._myTranslation.multiplyLocal(_myScale.x);
      theStore._myTranslation.addLocal(_myTranslation);

      if (transformBy.isUniformScale()) {
        theStore.scale(_myScale.x * transformBy.scale().x);
      } else {
        final CCVector3 scale = theStore._myScale.set(transformBy.scale());
        scale.multiplyLocal(_myScale.x);
      }

      // update our flags in one place.
      theStore.updateFlags(true);

      return theStore;
    }

    // In all remaining cases, the matrix cannot be written as R*S*X+T.
    final CCMatrix3x3 matrixA =
        isRotationMatrix() ? _myMatrix.multiplyDiagonalPost(_myScale) : _myMatrix;

    final CCMatrix3x3 matrixB =
        transformBy.isRotationMatrix()
            ? transformBy.getMatrix().multiplyDiagonalPost(transformBy.scale())
            : transformBy.getMatrix();

    final CCMatrix3x3 newMatrix = theStore._myMatrix;
    newMatrix.set(matrixA).multiplyLocal(matrixB);

    theStore._myTranslation.set(
        matrixA.applyPost(transformBy.translation()).addLocal(translation()));

    // prevent scale bleeding since we don't set it.
    theStore._myScale.set(1.0f, 1.0f, 1.0f);

    // update our flags in one place.
    theStore.updateFlags(false);

    return theStore;
  }