drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Matrix JNI update

Browse Source 
Switches to @FastNative & @CriticalNative
Switches to NativeAllocationRegistry
Updated formatting
Changes native_* to n* naming for native methods

Test: refactor CL, no behavior change; device still boots

Change-Id: Ic3b115b7aef26811bf8fef3777c131778608da30
This commit is contained in:
John Reck
2016-09-28 16:12:42 -07:00
parent 463d85cd92
commit 94931bd87e
2 changed files with 628 additions and 571 deletions
Download Patch File Download Diff File Expand all files Collapse all files

631
graphics/java/android/graphics/Matrix.java
View File

@ -16,8 +16,12 @@
package android.graphics;
import java.io.PrintWriter;
import dalvik.annotation.optimization.CriticalNative;
import dalvik.annotation.optimization.FastNative;
import libcore.util.NativeAllocationRegistry;
import java.io.PrintWriter;
/**
* The Matrix class holds a 3x3 matrix for transforming coordinates.
@ -216,352 +220,345 @@ public class Matrix {
}
};
// sizeof(SkMatrix) is 9 * sizeof(float) + uint32_t
private static final long NATIVE_ALLOCATION_SIZE = 40;
private static class NoImagePreloadHolder {
public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry(
Matrix.class.getClassLoader(), nGetNativeFinalizer(), NATIVE_ALLOCATION_SIZE);
}
/**
* @hide
*/
public long native_instance;
public final long native_instance;
/**
* Create an identity matrix
*/
public Matrix() {
native_instance = native_create(0);
native_instance = nCreate(0);
NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, native_instance);
}
/**
* Create a matrix that is a (deep) copy of src
*
* @param src The matrix to copy into this matrix
*/
public Matrix(Matrix src) {
native_instance = native_create(src != null ? src.native_instance : 0);
native_instance = nCreate(src != null ? src.native_instance : 0);
NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, native_instance);
}
/**
* Returns true if the matrix is identity.
* This maybe faster than testing if (getType() == 0)
* Returns true if the matrix is identity. This maybe faster than testing if (getType() == 0)
*/
public boolean isIdentity() {
return native_isIdentity(native_instance);
return nIsIdentity(native_instance);
}
/**
* Gets whether this matrix is affine. An affine matrix preserves
* straight lines and has no perspective.
* Gets whether this matrix is affine. An affine matrix preserves straight lines and has no
* perspective.
*
* @return Whether the matrix is affine.
*/
public boolean isAffine() {
return native_isAffine(native_instance);
return nIsAffine(native_instance);
}
/**
* Returns true if will map a rectangle to another rectangle. This can be
* true if the matrix is identity, scale-only, or rotates a multiple of 90
* degrees.
* Returns true if will map a rectangle to another rectangle. This can be true if the matrix is
* identity, scale-only, or rotates a multiple of 90 degrees.
*/
public boolean rectStaysRect() {
return native_rectStaysRect(native_instance);
return nRectStaysRect(native_instance);
}
/**
* (deep) copy the src matrix into this matrix. If src is null, reset this
* matrix to the identity matrix.
* (deep) copy the src matrix into this matrix. If src is null, reset this matrix to the
* identity matrix.
*/
public void set(Matrix src) {
if (src == null) {
reset();
} else {
native_set(native_instance, src.native_instance);
nSet(native_instance, src.native_instance);
}
}
/** Returns true iff obj is a Matrix and its values equal our values.
*/
/**
* Returns true iff obj is a Matrix and its values equal our values.
*/
@Override
public boolean equals(Object obj) {
//if (obj == this) return true; -- NaN value would mean matrix != itself
if (!(obj instanceof Matrix)) return false;
return native_equals(native_instance, ((Matrix)obj).native_instance);
// if (obj == this) return true; -- NaN value would mean matrix != itself
if (!(obj instanceof Matrix)) {
return false;
}
return nEquals(native_instance, ((Matrix) obj).native_instance);
}
@Override
public int hashCode() {
// This should generate the hash code by performing some arithmetic operation on all
// the matrix elements -- our equals() does an element-by-element comparison, and we
// need to ensure that the hash code for two equal objects is the same. We're not
// need to ensure that the hash code for two equal objects is the same. We're not
// really using this at the moment, so we take the easy way out.
return 44;
}
/** Set the matrix to identity */
public void reset() {
native_reset(native_instance);
nReset(native_instance);
}
/** Set the matrix to translate by (dx, dy). */
public void setTranslate(float dx, float dy) {
native_setTranslate(native_instance, dx, dy);
nSetTranslate(native_instance, dx, dy);
}
/**
* Set the matrix to scale by sx and sy, with a pivot point at (px, py).
* The pivot point is the coordinate that should remain unchanged by the
* specified transformation.
* Set the matrix to scale by sx and sy, with a pivot point at (px, py). The pivot point is the
* coordinate that should remain unchanged by the specified transformation.
*/
public void setScale(float sx, float sy, float px, float py) {
native_setScale(native_instance, sx, sy, px, py);
nSetScale(native_instance, sx, sy, px, py);
}
/** Set the matrix to scale by sx and sy. */
public void setScale(float sx, float sy) {
native_setScale(native_instance, sx, sy);
nSetScale(native_instance, sx, sy);
}
/**
* Set the matrix to rotate by the specified number of degrees, with a pivot
* point at (px, py). The pivot point is the coordinate that should remain
* unchanged by the specified transformation.
* Set the matrix to rotate by the specified number of degrees, with a pivot point at (px, py).
* The pivot point is the coordinate that should remain unchanged by the specified
* transformation.
*/
public void setRotate(float degrees, float px, float py) {
native_setRotate(native_instance, degrees, px, py);
nSetRotate(native_instance, degrees, px, py);
}
/**
* Set the matrix to rotate about (0,0) by the specified number of degrees.
*/
public void setRotate(float degrees) {
native_setRotate(native_instance, degrees);
nSetRotate(native_instance, degrees);
}
/**
* Set the matrix to rotate by the specified sine and cosine values, with a
* pivot point at (px, py). The pivot point is the coordinate that should
* remain unchanged by the specified transformation.
* Set the matrix to rotate by the specified sine and cosine values, with a pivot point at (px,
* py). The pivot point is the coordinate that should remain unchanged by the specified
* transformation.
*/
public void setSinCos(float sinValue, float cosValue, float px, float py) {
native_setSinCos(native_instance, sinValue, cosValue, px, py);
nSetSinCos(native_instance, sinValue, cosValue, px, py);
}
/** Set the matrix to rotate by the specified sine and cosine values. */
public void setSinCos(float sinValue, float cosValue) {
native_setSinCos(native_instance, sinValue, cosValue);
nSetSinCos(native_instance, sinValue, cosValue);
}
/**
* Set the matrix to skew by sx and sy, with a pivot point at (px, py).
* The pivot point is the coordinate that should remain unchanged by the
* specified transformation.
* Set the matrix to skew by sx and sy, with a pivot point at (px, py). The pivot point is the
* coordinate that should remain unchanged by the specified transformation.
*/
public void setSkew(float kx, float ky, float px, float py) {
native_setSkew(native_instance, kx, ky, px, py);
nSetSkew(native_instance, kx, ky, px, py);
}
/** Set the matrix to skew by sx and sy. */
public void setSkew(float kx, float ky) {
native_setSkew(native_instance, kx, ky);
nSetSkew(native_instance, kx, ky);
}
/**
* Set the matrix to the concatenation of the two specified matrices and
* return true.
*
* <p>Either of the two matrices may also be the target matrix, that is
* <code>matrixA.setConcat(matrixA, matrixB);</code> is valid.</p>
*
* <p class="note">In {@link android.os.Build.VERSION_CODES#GINGERBREAD_MR1} and below, this
* function returns true only if the result can be represented. In
* {@link android.os.Build.VERSION_CODES#HONEYCOMB} and above, it always returns true.</p>
* Set the matrix to the concatenation of the two specified matrices and return true.
* <p>
* Either of the two matrices may also be the target matrix, that is
* <code>matrixA.setConcat(matrixA, matrixB);</code> is valid.
* </p>
* <p class="note">
* In {@link android.os.Build.VERSION_CODES#GINGERBREAD_MR1} and below, this function returns
* true only if the result can be represented. In
* {@link android.os.Build.VERSION_CODES#HONEYCOMB} and above, it always returns true.
* </p>
*/
public boolean setConcat(Matrix a, Matrix b) {
native_setConcat(native_instance, a.native_instance, b.native_instance);
nSetConcat(native_instance, a.native_instance, b.native_instance);
return true;
}
/**
* Preconcats the matrix with the specified translation.
* M' = M * T(dx, dy)
* Preconcats the matrix with the specified translation. M' = M * T(dx, dy)
*/
public boolean preTranslate(float dx, float dy) {
native_preTranslate(native_instance, dx, dy);
nPreTranslate(native_instance, dx, dy);
return true;
}
/**
* Preconcats the matrix with the specified scale.
* M' = M * S(sx, sy, px, py)
* Preconcats the matrix with the specified scale. M' = M * S(sx, sy, px, py)
*/
public boolean preScale(float sx, float sy, float px, float py) {
native_preScale(native_instance, sx, sy, px, py);
nPreScale(native_instance, sx, sy, px, py);
return true;
}
/**
* Preconcats the matrix with the specified scale.
* M' = M * S(sx, sy)
* Preconcats the matrix with the specified scale. M' = M * S(sx, sy)
*/
public boolean preScale(float sx, float sy) {
native_preScale(native_instance, sx, sy);
nPreScale(native_instance, sx, sy);
return true;
}
/**
* Preconcats the matrix with the specified rotation.
* M' = M * R(degrees, px, py)
* Preconcats the matrix with the specified rotation. M' = M * R(degrees, px, py)
*/
public boolean preRotate(float degrees, float px, float py) {
native_preRotate(native_instance, degrees, px, py);
nPreRotate(native_instance, degrees, px, py);
return true;
}
/**
* Preconcats the matrix with the specified rotation.
* M' = M * R(degrees)
* Preconcats the matrix with the specified rotation. M' = M * R(degrees)
*/
public boolean preRotate(float degrees) {
native_preRotate(native_instance, degrees);
nPreRotate(native_instance, degrees);
return true;
}
/**
* Preconcats the matrix with the specified skew.
* M' = M * K(kx, ky, px, py)
* Preconcats the matrix with the specified skew. M' = M * K(kx, ky, px, py)
*/
public boolean preSkew(float kx, float ky, float px, float py) {
native_preSkew(native_instance, kx, ky, px, py);
nPreSkew(native_instance, kx, ky, px, py);
return true;
}
/**
* Preconcats the matrix with the specified skew.
* M' = M * K(kx, ky)
* Preconcats the matrix with the specified skew. M' = M * K(kx, ky)
*/
public boolean preSkew(float kx, float ky) {
native_preSkew(native_instance, kx, ky);
nPreSkew(native_instance, kx, ky);
return true;
}
/**
* Preconcats the matrix with the specified matrix.
* M' = M * other
* Preconcats the matrix with the specified matrix. M' = M * other
*/
public boolean preConcat(Matrix other) {
native_preConcat(native_instance, other.native_instance);
nPreConcat(native_instance, other.native_instance);
return true;
}
/**
* Postconcats the matrix with the specified translation.
* M' = T(dx, dy) * M
* Postconcats the matrix with the specified translation. M' = T(dx, dy) * M
*/
public boolean postTranslate(float dx, float dy) {
native_postTranslate(native_instance, dx, dy);
nPostTranslate(native_instance, dx, dy);
return true;
}
/**
* Postconcats the matrix with the specified scale.
* M' = S(sx, sy, px, py) * M
* Postconcats the matrix with the specified scale. M' = S(sx, sy, px, py) * M
*/
public boolean postScale(float sx, float sy, float px, float py) {
native_postScale(native_instance, sx, sy, px, py);
nPostScale(native_instance, sx, sy, px, py);
return true;
}
/**
* Postconcats the matrix with the specified scale.
* M' = S(sx, sy) * M
* Postconcats the matrix with the specified scale. M' = S(sx, sy) * M
*/
public boolean postScale(float sx, float sy) {
native_postScale(native_instance, sx, sy);
nPostScale(native_instance, sx, sy);
return true;
}
/**
* Postconcats the matrix with the specified rotation.
* M' = R(degrees, px, py) * M
* Postconcats the matrix with the specified rotation. M' = R(degrees, px, py) * M
*/
public boolean postRotate(float degrees, float px, float py) {
native_postRotate(native_instance, degrees, px, py);
nPostRotate(native_instance, degrees, px, py);
return true;
}
/**
* Postconcats the matrix with the specified rotation.
* M' = R(degrees) * M
* Postconcats the matrix with the specified rotation. M' = R(degrees) * M
*/
public boolean postRotate(float degrees) {
native_postRotate(native_instance, degrees);
nPostRotate(native_instance, degrees);
return true;
}
/**
* Postconcats the matrix with the specified skew.
* M' = K(kx, ky, px, py) * M
* Postconcats the matrix with the specified skew. M' = K(kx, ky, px, py) * M
*/
public boolean postSkew(float kx, float ky, float px, float py) {
native_postSkew(native_instance, kx, ky, px, py);
nPostSkew(native_instance, kx, ky, px, py);
return true;
}
/**
* Postconcats the matrix with the specified skew.
* M' = K(kx, ky) * M
* Postconcats the matrix with the specified skew. M' = K(kx, ky) * M
*/
public boolean postSkew(float kx, float ky) {
native_postSkew(native_instance, kx, ky);
nPostSkew(native_instance, kx, ky);
return true;
}
/**
* Postconcats the matrix with the specified matrix.
* M' = other * M
* Postconcats the matrix with the specified matrix. M' = other * M
*/
public boolean postConcat(Matrix other) {
native_postConcat(native_instance, other.native_instance);
nPostConcat(native_instance, other.native_instance);
return true;
}
/** Controlls how the src rect should align into the dst rect for
setRectToRect().
*/
/**
* Controlls how the src rect should align into the dst rect for setRectToRect().
*/
public enum ScaleToFit {
/**
* Scale in X and Y independently, so that src matches dst exactly.
* This may change the aspect ratio of the src.
* Scale in X and Y independently, so that src matches dst exactly. This may change the
* aspect ratio of the src.
*/
FILL (0),
FILL(0),
/**
* Compute a scale that will maintain the original src aspect ratio,
* but will also ensure that src fits entirely inside dst. At least one
* axis (X or Y) will fit exactly. START aligns the result to the
* left and top edges of dst.
* Compute a scale that will maintain the original src aspect ratio, but will also ensure
* that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. START
* aligns the result to the left and top edges of dst.
*/
START (1),
START(1),
/**
* Compute a scale that will maintain the original src aspect ratio,
* but will also ensure that src fits entirely inside dst. At least one
* axis (X or Y) will fit exactly. The result is centered inside dst.
* Compute a scale that will maintain the original src aspect ratio, but will also ensure
* that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. The
* result is centered inside dst.
*/
CENTER (2),
CENTER(2),
/**
* Compute a scale that will maintain the original src aspect ratio,
* but will also ensure that src fits entirely inside dst. At least one
* axis (X or Y) will fit exactly. END aligns the result to the
* right and bottom edges of dst.
* Compute a scale that will maintain the original src aspect ratio, but will also ensure
* that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. END
* aligns the result to the right and bottom edges of dst.
*/
END (3);
END(3);
// the native values must match those in SkMatrix.h
ScaleToFit(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* Set the matrix to the scale and translate values that map the source
* rectangle to the destination rectangle, returning true if the the result
* can be represented.
* Set the matrix to the scale and translate values that map the source rectangle to the
* destination rectangle, returning true if the the result can be represented.
*
* @param src the source rectangle to map from.
* @param dst the destination rectangle to map to.
@ -572,13 +569,13 @@ public class Matrix {
if (dst == null || src == null) {
throw new NullPointerException();
}
return native_setRectToRect(native_instance, src, dst, stf.nativeInt);
return nSetRectToRect(native_instance, src, dst, stf.nativeInt);
}
// private helper to perform range checks on arrays of "points"
private static void checkPointArrays(float[] src, int srcIndex,
float[] dst, int dstIndex,
int pointCount) {
float[] dst, int dstIndex,
int pointCount) {
// check for too-small and too-big indices
int srcStop = srcIndex + (pointCount << 1);
int dstStop = dstIndex + (pointCount << 1);
@ -589,84 +586,81 @@ public class Matrix {
}
/**
* Set the matrix such that the specified src points would map to the
* specified dst points. The "points" are represented as an array of floats,
* order [x0, y0, x1, y1, ...], where each "point" is 2 float values.
* Set the matrix such that the specified src points would map to the specified dst points. The
* "points" are represented as an array of floats, order [x0, y0, x1, y1, ...], where each
* "point" is 2 float values.
*
* @param src The array of src [x,y] pairs (points)
* @param src The array of src [x,y] pairs (points)
* @param srcIndex Index of the first pair of src values
* @param dst The array of dst [x,y] pairs (points)
* @param dst The array of dst [x,y] pairs (points)
* @param dstIndex Index of the first pair of dst values
* @param pointCount The number of pairs/points to be used. Must be [0..4]
* @return true if the matrix was set to the specified transformation
*/
public boolean setPolyToPoly(float[] src, int srcIndex,
float[] dst, int dstIndex,
int pointCount) {
float[] dst, int dstIndex,
int pointCount) {
if (pointCount > 4) {
throw new IllegalArgumentException();
}
checkPointArrays(src, srcIndex, dst, dstIndex, pointCount);
return native_setPolyToPoly(native_instance, src, srcIndex,
dst, dstIndex, pointCount);
return nSetPolyToPoly(native_instance, src, srcIndex,
dst, dstIndex, pointCount);
}
/**
* If this matrix can be inverted, return true and if inverse is not null,
* set inverse to be the inverse of this matrix. If this matrix cannot be
* inverted, ignore inverse and return false.
* If this matrix can be inverted, return true and if inverse is not null, set inverse to be the
* inverse of this matrix. If this matrix cannot be inverted, ignore inverse and return false.
*/
public boolean invert(Matrix inverse) {
return native_invert(native_instance, inverse.native_instance);
return nInvert(native_instance, inverse.native_instance);
}
/**
* Apply this matrix to the array of 2D points specified by src, and write
* the transformed points into the array of points specified by dst. The
* two arrays represent their "points" as pairs of floats [x, y].
* Apply this matrix to the array of 2D points specified by src, and write the transformed
* points into the array of points specified by dst. The two arrays represent their "points" as
* pairs of floats [x, y].
*
* @param dst The array of dst points (x,y pairs)
* @param dst The array of dst points (x,y pairs)
* @param dstIndex The index of the first [x,y] pair of dst floats
* @param src The array of src points (x,y pairs)
* @param src The array of src points (x,y pairs)
* @param srcIndex The index of the first [x,y] pair of src floats
* @param pointCount The number of points (x,y pairs) to transform
*/
public void mapPoints(float[] dst, int dstIndex, float[] src, int srcIndex,
int pointCount) {
int pointCount) {
checkPointArrays(src, srcIndex, dst, dstIndex, pointCount);
native_mapPoints(native_instance, dst, dstIndex, src, srcIndex,
pointCount, true);
nMapPoints(native_instance, dst, dstIndex, src, srcIndex,
pointCount, true);
}
/**
* Apply this matrix to the array of 2D vectors specified by src, and write
* the transformed vectors into the array of vectors specified by dst. The
* two arrays represent their "vectors" as pairs of floats [x, y].
* Apply this matrix to the array of 2D vectors specified by src, and write the transformed
* vectors into the array of vectors specified by dst. The two arrays represent their "vectors"
* as pairs of floats [x, y]. Note: this method does not apply the translation associated with
* the matrix. Use {@link Matrix#mapPoints(float[], int, float[], int, int)} if you want the
* translation to be applied.
*
* Note: this method does not apply the translation associated with the matrix. Use
* {@link Matrix#mapPoints(float[], int, float[], int, int)} if you want the translation
* to be applied.
*
* @param dst The array of dst vectors (x,y pairs)
* @param dst The array of dst vectors (x,y pairs)
* @param dstIndex The index of the first [x,y] pair of dst floats
* @param src The array of src vectors (x,y pairs)
* @param src The array of src vectors (x,y pairs)
* @param srcIndex The index of the first [x,y] pair of src floats
* @param vectorCount The number of vectors (x,y pairs) to transform
*/
public void mapVectors(float[] dst, int dstIndex, float[] src, int srcIndex,
int vectorCount) {
int vectorCount) {
checkPointArrays(src, srcIndex, dst, dstIndex, vectorCount);
native_mapPoints(native_instance, dst, dstIndex, src, srcIndex,
vectorCount, false);
nMapPoints(native_instance, dst, dstIndex, src, srcIndex,
vectorCount, false);
}
/**
* Apply this matrix to the array of 2D points specified by src, and write
* the transformed points into the array of points specified by dst. The
* two arrays represent their "points" as pairs of floats [x, y].
* Apply this matrix to the array of 2D points specified by src, and write the transformed
* points into the array of points specified by dst. The two arrays represent their "points" as
* pairs of floats [x, y].
*
* @param dst The array of dst points (x,y pairs)
* @param src The array of src points (x,y pairs)
* @param dst The array of dst points (x,y pairs)
* @param src The array of src points (x,y pairs)
*/
public void mapPoints(float[] dst, float[] src) {
if (dst.length != src.length) {
@ -676,15 +670,14 @@ public class Matrix {
}
/**
* Apply this matrix to the array of 2D vectors specified by src, and write
* the transformed vectors into the array of vectors specified by dst. The
* two arrays represent their "vectors" as pairs of floats [x, y].
* Apply this matrix to the array of 2D vectors specified by src, and write the transformed
* vectors into the array of vectors specified by dst. The two arrays represent their "vectors"
* as pairs of floats [x, y]. Note: this method does not apply the translation associated with
* the matrix. Use {@link Matrix#mapPoints(float[], float[])} if you want the translation to be
* applied.
*
* Note: this method does not apply the translation associated with the matrix. Use
* {@link Matrix#mapPoints(float[], float[])} if you want the translation to be applied.
*
* @param dst The array of dst vectors (x,y pairs)
* @param src The array of src vectors (x,y pairs)
* @param dst The array of dst vectors (x,y pairs)
* @param src The array of src vectors (x,y pairs)
*/
public void mapVectors(float[] dst, float[] src) {
if (dst.length != src.length) {
@ -694,8 +687,8 @@ public class Matrix {
}
/**
* Apply this matrix to the array of 2D points, and write the transformed
* points back into the array
* Apply this matrix to the array of 2D points, and write the transformed points back into the
* array
*
* @param pts The array [x0, y0, x1, y1, ...] of points to transform.
*/
@ -704,10 +697,8 @@ public class Matrix {
}
/**
* Apply this matrix to the array of 2D vectors, and write the transformed
* vectors back into the array.
*
* Note: this method does not apply the translation associated with the matrix. Use
* Apply this matrix to the array of 2D vectors, and write the transformed vectors back into the
* array. Note: this method does not apply the translation associated with the matrix. Use
* {@link Matrix#mapPoints(float[])} if you want the translation to be applied.
*
* @param vecs The array [x0, y0, x1, y1, ...] of vectors to transform.
@ -717,9 +708,9 @@ public class Matrix {
}
/**
* Apply this matrix to the src rectangle, and write the transformed
* rectangle into dst. This is accomplished by transforming the 4 corners of
* src, and then setting dst to the bounds of those points.
* Apply this matrix to the src rectangle, and write the transformed rectangle into dst. This is
* accomplished by transforming the 4 corners of src, and then setting dst to the bounds of
* those points.
*
* @param dst Where the transformed rectangle is written.
* @param src The original rectangle to be transformed.
@ -729,13 +720,13 @@ public class Matrix {
if (dst == null || src == null) {
throw new NullPointerException();
}
return native_mapRect(native_instance, dst, src);
return nMapRect(native_instance, dst, src);
}
/**
* Apply this matrix to the rectangle, and write the transformed rectangle
* back into it. This is accomplished by transforming the 4 corners of rect,
* and then setting it to the bounds of those points
* Apply this matrix to the rectangle, and write the transformed rectangle back into it. This is
* accomplished by transforming the 4 corners of rect, and then setting it to the bounds of
* those points
*
* @param rect The rectangle to transform.
* @return the result of calling rectStaysRect()
@ -745,34 +736,33 @@ public class Matrix {
}
/**
* Return the mean radius of a circle after it has been mapped by
* this matrix. NOTE: in perspective this value assumes the circle
* has its center at the origin.
* Return the mean radius of a circle after it has been mapped by this matrix. NOTE: in
* perspective this value assumes the circle has its center at the origin.
*/
public float mapRadius(float radius) {
return native_mapRadius(native_instance, radius);
return nMapRadius(native_instance, radius);
}
/** Copy 9 values from the matrix into the array.
*/
/**
* Copy 9 values from the matrix into the array.
*/
public void getValues(float[] values) {
if (values.length < 9) {
throw new ArrayIndexOutOfBoundsException();
}
native_getValues(native_instance, values);
nGetValues(native_instance, values);
}
/** Copy 9 values from the array into the matrix.
Depending on the implementation of Matrix, these may be
transformed into 16.16 integers in the Matrix, such that
a subsequent call to getValues() will not yield exactly
the same values.
*/
/**
* Copy 9 values from the array into the matrix. Depending on the implementation of Matrix,
* these may be transformed into 16.16 integers in the Matrix, such that a subsequent call to
* getValues() will not yield exactly the same values.
*/
public void setValues(float[] values) {
if (values.length < 9) {
throw new ArrayIndexOutOfBoundsException();
}
native_setValues(native_instance, values);
nSetValues(native_instance, values);
}
@Override
@ -798,122 +788,155 @@ public class Matrix {
float[] values = new float[9];
getValues(values);
sb.append('[');
sb.append(values[0]); sb.append(", "); sb.append(values[1]); sb.append(", ");
sb.append(values[2]); sb.append("][");
sb.append(values[3]); sb.append(", "); sb.append(values[4]); sb.append(", ");
sb.append(values[5]); sb.append("][");
sb.append(values[6]); sb.append(", "); sb.append(values[7]); sb.append(", ");
sb.append(values[8]); sb.append(']');
sb.append(values[0]);
sb.append(", ");
sb.append(values[1]);
sb.append(", ");
sb.append(values[2]);
sb.append("][");
sb.append(values[3]);
sb.append(", ");
sb.append(values[4]);
sb.append(", ");
sb.append(values[5]);
sb.append("][");
sb.append(values[6]);
sb.append(", ");
sb.append(values[7]);
sb.append(", ");
sb.append(values[8]);
sb.append(']');
}
/**
* Print short string, to optimize dumping.
*
* @hide
*/
public void printShortString(PrintWriter pw) {
float[] values = new float[9];
getValues(values);
pw.print('[');
pw.print(values[0]); pw.print(", "); pw.print(values[1]); pw.print(", ");
pw.print(values[2]); pw.print("][");
pw.print(values[3]); pw.print(", "); pw.print(values[4]); pw.print(", ");
pw.print(values[5]); pw.print("][");
pw.print(values[6]); pw.print(", "); pw.print(values[7]); pw.print(", ");
pw.print(values[8]); pw.print(']');
pw.print(values[0]);
pw.print(", ");
pw.print(values[1]);
pw.print(", ");
pw.print(values[2]);
pw.print("][");
pw.print(values[3]);
pw.print(", ");
pw.print(values[4]);
pw.print(", ");
pw.print(values[5]);
pw.print("][");
pw.print(values[6]);
pw.print(", ");
pw.print(values[7]);
pw.print(", ");
pw.print(values[8]);
pw.print(']');
}
@Override
protected void finalize() throws Throwable {
try {
finalizer(native_instance);
native_instance = 0; // Other finalizers can still call us.
} finally {
super.finalize();
}
}
/*package*/ final long ni() {
/* package */ final long ni() {
return native_instance;
}
private static native long native_create(long native_src_or_zero);
private static native boolean native_isIdentity(long native_object);
private static native boolean native_isAffine(long native_object);
private static native boolean native_rectStaysRect(long native_object);
private static native void native_reset(long native_object);
private static native void native_set(long native_object,
long native_other);
private static native void native_setTranslate(long native_object,
float dx, float dy);
private static native void native_setScale(long native_object,
float sx, float sy, float px, float py);
private static native void native_setScale(long native_object,
float sx, float sy);
private static native void native_setRotate(long native_object,
float degrees, float px, float py);
private static native void native_setRotate(long native_object,
float degrees);
private static native void native_setSinCos(long native_object,
float sinValue, float cosValue, float px, float py);
private static native void native_setSinCos(long native_object,
float sinValue, float cosValue);
private static native void native_setSkew(long native_object,
float kx, float ky, float px, float py);
private static native void native_setSkew(long native_object,
float kx, float ky);
private static native void native_setConcat(long native_object,
long native_a,
long native_b);
private static native void native_preTranslate(long native_object,
float dx, float dy);
private static native void native_preScale(long native_object,
float sx, float sy, float px, float py);
private static native void native_preScale(long native_object,
float sx, float sy);
private static native void native_preRotate(long native_object,
float degrees, float px, float py);
private static native void native_preRotate(long native_object,
float degrees);
private static native void native_preSkew(long native_object,
float kx, float ky, float px, float py);
private static native void native_preSkew(long native_object,
float kx, float ky);
private static native void native_preConcat(long native_object,
long native_other_matrix);
private static native void native_postTranslate(long native_object,
float dx, float dy);
private static native void native_postScale(long native_object,
float sx, float sy, float px, float py);
private static native void native_postScale(long native_object,
float sx, float sy);
private static native void native_postRotate(long native_object,
float degrees, float px, float py);
private static native void native_postRotate(long native_object,
float degrees);
private static native void native_postSkew(long native_object,
float kx, float ky, float px, float py);
private static native void native_postSkew(long native_object,
float kx, float ky);
private static native void native_postConcat(long native_object,
long native_other_matrix);
private static native boolean native_setRectToRect(long native_object,
RectF src, RectF dst, int stf);
private static native boolean native_setPolyToPoly(long native_object,
float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount);
private static native boolean native_invert(long native_object,
long native_inverse);
private static native void native_mapPoints(long native_object,
float[] dst, int dstIndex, float[] src, int srcIndex,
int ptCount, boolean isPts);
private static native boolean native_mapRect(long native_object,
RectF dst, RectF src);
private static native float native_mapRadius(long native_object,
float radius);
private static native void native_getValues(long native_object,
float[] values);
private static native void native_setValues(long native_object,
float[] values);
private static native boolean native_equals(long native_a, long native_b);
private static native void finalizer(long native_instance);
// ------------------ Regular JNI ------------------------
private static native long nCreate(long nSrc_or_zero);
private static native long nGetNativeFinalizer();
// ------------------ Fast JNI ------------------------
@FastNative
private static native boolean nSetRectToRect(long nObject,
RectF src, RectF dst, int stf);
@FastNative
private static native boolean nSetPolyToPoly(long nObject,
float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount);
@FastNative
private static native void nMapPoints(long nObject,
float[] dst, int dstIndex, float[] src, int srcIndex,
int ptCount, boolean isPts);
@FastNative
private static native boolean nMapRect(long nObject, RectF dst, RectF src);
@FastNative
private static native void nGetValues(long nObject, float[] values);
@FastNative
private static native void nSetValues(long nObject, float[] values);
// ------------------ Critical JNI ------------------------
@CriticalNative
private static native boolean nIsIdentity(long nObject);
@CriticalNative
private static native boolean nIsAffine(long nObject);
@CriticalNative
private static native boolean nRectStaysRect(long nObject);
@CriticalNative
private static native void nReset(long nObject);
@CriticalNative
private static native void nSet(long nObject, long nOther);
@CriticalNative
private static native void nSetTranslate(long nObject, float dx, float dy);
@CriticalNative
private static native void nSetScale(long nObject, float sx, float sy, float px, float py);
@CriticalNative
private static native void nSetScale(long nObject, float sx, float sy);
@CriticalNative
private static native void nSetRotate(long nObject, float degrees, float px, float py);
@CriticalNative
private static native void nSetRotate(long nObject, float degrees);
@CriticalNative
private static native void nSetSinCos(long nObject, float sinValue, float cosValue,
float px, float py);
@CriticalNative
private static native void nSetSinCos(long nObject, float sinValue, float cosValue);
@CriticalNative
private static native void nSetSkew(long nObject, float kx, float ky, float px, float py);
@CriticalNative
private static native void nSetSkew(long nObject, float kx, float ky);
@CriticalNative
private static native void nSetConcat(long nObject, long nA, long nB);
@CriticalNative
private static native void nPreTranslate(long nObject, float dx, float dy);
@CriticalNative
private static native void nPreScale(long nObject, float sx, float sy, float px, float py);
@CriticalNative
private static native void nPreScale(long nObject, float sx, float sy);
@CriticalNative
private static native void nPreRotate(long nObject, float degrees, float px, float py);
@CriticalNative
private static native void nPreRotate(long nObject, float degrees);
@CriticalNative
private static native void nPreSkew(long nObject, float kx, float ky, float px, float py);
@CriticalNative
private static native void nPreSkew(long nObject, float kx, float ky);
@CriticalNative
private static native void nPreConcat(long nObject, long nOther_matrix);
@CriticalNative
private static native void nPostTranslate(long nObject, float dx, float dy);
@CriticalNative
private static native void nPostScale(long nObject, float sx, float sy, float px, float py);
@CriticalNative
private static native void nPostScale(long nObject, float sx, float sy);
@CriticalNative
private static native void nPostRotate(long nObject, float degrees, float px, float py);
@CriticalNative
private static native void nPostRotate(long nObject, float degrees);
@CriticalNative
private static native void nPostSkew(long nObject, float kx, float ky, float px, float py);
@CriticalNative
private static native void nPostSkew(long nObject, float kx, float ky);
@CriticalNative
private static native void nPostConcat(long nObject, long nOther_matrix);
@CriticalNative
private static native boolean nInvert(long nObject, long nInverse);
@CriticalNative
private static native float nMapRadius(long nObject, float radius);
@CriticalNative
private static native boolean nEquals(long nA, long nB);
}