640 lines
26 KiB
Java
640 lines
26 KiB
Java
package androidx.core.graphics;
|
|
|
|
import android.graphics.Path;
|
|
import android.util.Log;
|
|
import androidx.annotation.Nullable;
|
|
import c.d.b.a.a;
|
|
import java.util.ArrayList;
|
|
public class PathParser {
|
|
private static final String LOGTAG = "PathParser";
|
|
|
|
public static class ExtractFloatResult {
|
|
public int mEndPosition;
|
|
public boolean mEndWithNegOrDot;
|
|
}
|
|
|
|
public static class PathDataNode {
|
|
public float[] mParams;
|
|
public char mType;
|
|
|
|
public PathDataNode(char c2, float[] fArr) {
|
|
this.mType = c2;
|
|
this.mParams = fArr;
|
|
}
|
|
|
|
public PathDataNode(PathDataNode pathDataNode) {
|
|
this.mType = pathDataNode.mType;
|
|
float[] fArr = pathDataNode.mParams;
|
|
this.mParams = PathParser.copyOfRange(fArr, 0, fArr.length);
|
|
}
|
|
|
|
/* JADX INFO: Can't fix incorrect switch cases order, some code will duplicate */
|
|
private static void addCommand(Path path, float[] fArr, char c2, char c3, float[] fArr2) {
|
|
int i;
|
|
int i2;
|
|
float f;
|
|
float f2;
|
|
float f3;
|
|
float f4;
|
|
float f5;
|
|
float f6;
|
|
float f7;
|
|
float f8;
|
|
char c4 = c3;
|
|
float f9 = fArr[0];
|
|
float f10 = fArr[1];
|
|
float f11 = fArr[2];
|
|
float f12 = fArr[3];
|
|
float f13 = fArr[4];
|
|
float f14 = fArr[5];
|
|
switch (c4) {
|
|
case 'A':
|
|
case 'a':
|
|
i = 7;
|
|
break;
|
|
case 'C':
|
|
case 'c':
|
|
i = 6;
|
|
break;
|
|
case 'H':
|
|
case 'V':
|
|
case 'h':
|
|
case 'v':
|
|
i = 1;
|
|
break;
|
|
case 'L':
|
|
case 'M':
|
|
case 'T':
|
|
case 'l':
|
|
case 'm':
|
|
case 't':
|
|
default:
|
|
i = 2;
|
|
break;
|
|
case 'Q':
|
|
case 'S':
|
|
case 'q':
|
|
case 's':
|
|
i = 4;
|
|
break;
|
|
case 'Z':
|
|
case 'z':
|
|
path.close();
|
|
path.moveTo(f13, f14);
|
|
f9 = f13;
|
|
f11 = f9;
|
|
f10 = f14;
|
|
f12 = f10;
|
|
i = 2;
|
|
break;
|
|
}
|
|
float f15 = f9;
|
|
float f16 = f10;
|
|
float f17 = f13;
|
|
float f18 = f14;
|
|
int i3 = 0;
|
|
char c5 = c2;
|
|
while (i3 < fArr2.length) {
|
|
if (c4 != 'A') {
|
|
if (c4 == 'C') {
|
|
i2 = i3;
|
|
int i4 = i2 + 2;
|
|
int i5 = i2 + 3;
|
|
int i6 = i2 + 4;
|
|
int i7 = i2 + 5;
|
|
path.cubicTo(fArr2[i2 + 0], fArr2[i2 + 1], fArr2[i4], fArr2[i5], fArr2[i6], fArr2[i7]);
|
|
f15 = fArr2[i6];
|
|
float f19 = fArr2[i7];
|
|
float f20 = fArr2[i4];
|
|
float f21 = fArr2[i5];
|
|
f16 = f19;
|
|
f12 = f21;
|
|
f11 = f20;
|
|
} else if (c4 == 'H') {
|
|
i2 = i3;
|
|
int i8 = i2 + 0;
|
|
path.lineTo(fArr2[i8], f16);
|
|
f15 = fArr2[i8];
|
|
} else if (c4 == 'Q') {
|
|
i2 = i3;
|
|
int i9 = i2 + 0;
|
|
int i10 = i2 + 1;
|
|
int i11 = i2 + 2;
|
|
int i12 = i2 + 3;
|
|
path.quadTo(fArr2[i9], fArr2[i10], fArr2[i11], fArr2[i12]);
|
|
float f22 = fArr2[i9];
|
|
float f23 = fArr2[i10];
|
|
f15 = fArr2[i11];
|
|
f16 = fArr2[i12];
|
|
f11 = f22;
|
|
f12 = f23;
|
|
} else if (c4 == 'V') {
|
|
i2 = i3;
|
|
int i13 = i2 + 0;
|
|
path.lineTo(f15, fArr2[i13]);
|
|
f16 = fArr2[i13];
|
|
} else if (c4 != 'a') {
|
|
if (c4 == 'c') {
|
|
int i14 = i3 + 2;
|
|
int i15 = i3 + 3;
|
|
int i16 = i3 + 4;
|
|
int i17 = i3 + 5;
|
|
path.rCubicTo(fArr2[i3 + 0], fArr2[i3 + 1], fArr2[i14], fArr2[i15], fArr2[i16], fArr2[i17]);
|
|
f2 = fArr2[i14] + f15;
|
|
f = fArr2[i15] + f16;
|
|
f15 += fArr2[i16];
|
|
f3 = fArr2[i17];
|
|
f16 += f3;
|
|
f11 = f2;
|
|
f12 = f;
|
|
} else if (c4 != 'h') {
|
|
if (c4 != 'q') {
|
|
if (c4 == 'v') {
|
|
int i18 = i3 + 0;
|
|
path.rLineTo(0.0f, fArr2[i18]);
|
|
f4 = fArr2[i18];
|
|
} else if (c4 != 'L') {
|
|
if (c4 == 'M') {
|
|
int i19 = i3 + 0;
|
|
f15 = fArr2[i19];
|
|
int i20 = i3 + 1;
|
|
f16 = fArr2[i20];
|
|
if (i3 > 0) {
|
|
path.lineTo(fArr2[i19], fArr2[i20]);
|
|
} else {
|
|
path.moveTo(fArr2[i19], fArr2[i20]);
|
|
}
|
|
} else if (c4 == 'S') {
|
|
if (c5 == 'c' || c5 == 's' || c5 == 'C' || c5 == 'S') {
|
|
f15 = (f15 * 2.0f) - f11;
|
|
f16 = (f16 * 2.0f) - f12;
|
|
}
|
|
int i21 = i3 + 0;
|
|
int i22 = i3 + 1;
|
|
int i23 = i3 + 2;
|
|
int i24 = i3 + 3;
|
|
path.cubicTo(f15, f16, fArr2[i21], fArr2[i22], fArr2[i23], fArr2[i24]);
|
|
f2 = fArr2[i21];
|
|
f = fArr2[i22];
|
|
f15 = fArr2[i23];
|
|
f16 = fArr2[i24];
|
|
f11 = f2;
|
|
f12 = f;
|
|
} else if (c4 == 'T') {
|
|
if (c5 == 'q' || c5 == 't' || c5 == 'Q' || c5 == 'T') {
|
|
f15 = (f15 * 2.0f) - f11;
|
|
f16 = (f16 * 2.0f) - f12;
|
|
}
|
|
int i25 = i3 + 0;
|
|
int i26 = i3 + 1;
|
|
path.quadTo(f15, f16, fArr2[i25], fArr2[i26]);
|
|
float f24 = fArr2[i25];
|
|
float f25 = fArr2[i26];
|
|
i2 = i3;
|
|
f12 = f16;
|
|
f11 = f15;
|
|
f15 = f24;
|
|
f16 = f25;
|
|
} else if (c4 == 'l') {
|
|
int i27 = i3 + 0;
|
|
int i28 = i3 + 1;
|
|
path.rLineTo(fArr2[i27], fArr2[i28]);
|
|
f15 += fArr2[i27];
|
|
f4 = fArr2[i28];
|
|
} else if (c4 == 'm') {
|
|
int i29 = i3 + 0;
|
|
f15 += fArr2[i29];
|
|
int i30 = i3 + 1;
|
|
f16 += fArr2[i30];
|
|
if (i3 > 0) {
|
|
path.rLineTo(fArr2[i29], fArr2[i30]);
|
|
} else {
|
|
path.rMoveTo(fArr2[i29], fArr2[i30]);
|
|
}
|
|
} else if (c4 == 's') {
|
|
if (c5 == 'c' || c5 == 's' || c5 == 'C' || c5 == 'S') {
|
|
float f26 = f15 - f11;
|
|
f5 = f16 - f12;
|
|
f6 = f26;
|
|
} else {
|
|
f6 = 0.0f;
|
|
f5 = 0.0f;
|
|
}
|
|
int i31 = i3 + 0;
|
|
int i32 = i3 + 1;
|
|
int i33 = i3 + 2;
|
|
int i34 = i3 + 3;
|
|
path.rCubicTo(f6, f5, fArr2[i31], fArr2[i32], fArr2[i33], fArr2[i34]);
|
|
f2 = fArr2[i31] + f15;
|
|
f = fArr2[i32] + f16;
|
|
f15 += fArr2[i33];
|
|
f3 = fArr2[i34];
|
|
} else if (c4 == 't') {
|
|
if (c5 == 'q' || c5 == 't' || c5 == 'Q' || c5 == 'T') {
|
|
f7 = f15 - f11;
|
|
f8 = f16 - f12;
|
|
} else {
|
|
f8 = 0.0f;
|
|
f7 = 0.0f;
|
|
}
|
|
int i35 = i3 + 0;
|
|
int i36 = i3 + 1;
|
|
path.rQuadTo(f7, f8, fArr2[i35], fArr2[i36]);
|
|
float f27 = f7 + f15;
|
|
float f28 = f8 + f16;
|
|
f15 += fArr2[i35];
|
|
f16 += fArr2[i36];
|
|
f12 = f28;
|
|
f11 = f27;
|
|
}
|
|
i2 = i3;
|
|
f18 = f16;
|
|
f17 = f15;
|
|
} else {
|
|
int i37 = i3 + 0;
|
|
int i38 = i3 + 1;
|
|
path.lineTo(fArr2[i37], fArr2[i38]);
|
|
f15 = fArr2[i37];
|
|
f16 = fArr2[i38];
|
|
}
|
|
f16 += f4;
|
|
} else {
|
|
int i39 = i3 + 0;
|
|
int i40 = i3 + 1;
|
|
int i41 = i3 + 2;
|
|
int i42 = i3 + 3;
|
|
path.rQuadTo(fArr2[i39], fArr2[i40], fArr2[i41], fArr2[i42]);
|
|
f2 = fArr2[i39] + f15;
|
|
f = fArr2[i40] + f16;
|
|
f15 += fArr2[i41];
|
|
f3 = fArr2[i42];
|
|
}
|
|
f16 += f3;
|
|
f11 = f2;
|
|
f12 = f;
|
|
} else {
|
|
int i43 = i3 + 0;
|
|
path.rLineTo(fArr2[i43], 0.0f);
|
|
f15 += fArr2[i43];
|
|
}
|
|
i2 = i3;
|
|
} else {
|
|
int i44 = i3 + 5;
|
|
int i45 = i3 + 6;
|
|
i2 = i3;
|
|
drawArc(path, f15, f16, fArr2[i44] + f15, fArr2[i45] + f16, fArr2[i3 + 0], fArr2[i3 + 1], fArr2[i3 + 2], fArr2[i3 + 3] != 0.0f, fArr2[i3 + 4] != 0.0f);
|
|
f15 += fArr2[i44];
|
|
f16 += fArr2[i45];
|
|
}
|
|
i3 = i2 + i;
|
|
c5 = c3;
|
|
c4 = c5;
|
|
} else {
|
|
i2 = i3;
|
|
int i46 = i2 + 5;
|
|
int i47 = i2 + 6;
|
|
drawArc(path, f15, f16, fArr2[i46], fArr2[i47], fArr2[i2 + 0], fArr2[i2 + 1], fArr2[i2 + 2], fArr2[i2 + 3] != 0.0f, fArr2[i2 + 4] != 0.0f);
|
|
f15 = fArr2[i46];
|
|
f16 = fArr2[i47];
|
|
}
|
|
f12 = f16;
|
|
f11 = f15;
|
|
i3 = i2 + i;
|
|
c5 = c3;
|
|
c4 = c5;
|
|
}
|
|
fArr[0] = f15;
|
|
fArr[1] = f16;
|
|
fArr[2] = f11;
|
|
fArr[3] = f12;
|
|
fArr[4] = f17;
|
|
fArr[5] = f18;
|
|
}
|
|
|
|
private static void arcToBezier(Path path, double d, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9) {
|
|
double d10 = d3;
|
|
int ceil = (int) Math.ceil(Math.abs((d9 * 4.0d) / 3.141592653589793d));
|
|
double cos = Math.cos(d7);
|
|
double sin = Math.sin(d7);
|
|
double cos2 = Math.cos(d8);
|
|
double sin2 = Math.sin(d8);
|
|
double d11 = -d10;
|
|
double d12 = d11 * cos;
|
|
double d13 = d4 * sin;
|
|
double d14 = (d12 * sin2) - (d13 * cos2);
|
|
double d15 = d11 * sin;
|
|
double d16 = d4 * cos;
|
|
double d17 = (cos2 * d16) + (sin2 * d15);
|
|
double d18 = d9 / ((double) ceil);
|
|
double d19 = d8;
|
|
double d20 = d17;
|
|
double d21 = d14;
|
|
int i = 0;
|
|
double d22 = d5;
|
|
double d23 = d6;
|
|
while (i < ceil) {
|
|
double d24 = d19 + d18;
|
|
double sin3 = Math.sin(d24);
|
|
double cos3 = Math.cos(d24);
|
|
double d25 = (((d10 * cos) * cos3) + d) - (d13 * sin3);
|
|
double d26 = (d16 * sin3) + (d10 * sin * cos3) + d2;
|
|
double d27 = (d12 * sin3) - (d13 * cos3);
|
|
double d28 = (cos3 * d16) + (sin3 * d15);
|
|
double d29 = d24 - d19;
|
|
double tan = Math.tan(d29 / 2.0d);
|
|
double sqrt = ((Math.sqrt(((tan * 3.0d) * tan) + 4.0d) - 1.0d) * Math.sin(d29)) / 3.0d;
|
|
path.rLineTo(0.0f, 0.0f);
|
|
path.cubicTo((float) ((d21 * sqrt) + d22), (float) ((d20 * sqrt) + d23), (float) (d25 - (sqrt * d27)), (float) (d26 - (sqrt * d28)), (float) d25, (float) d26);
|
|
i++;
|
|
d18 = d18;
|
|
sin = sin;
|
|
d22 = d25;
|
|
d15 = d15;
|
|
cos = cos;
|
|
d19 = d24;
|
|
d20 = d28;
|
|
d21 = d27;
|
|
ceil = ceil;
|
|
d23 = d26;
|
|
d10 = d3;
|
|
}
|
|
}
|
|
|
|
private static void drawArc(Path path, float f, float f2, float f3, float f4, float f5, float f6, float f7, boolean z2, boolean z3) {
|
|
double d;
|
|
double d2;
|
|
double radians = Math.toRadians((double) f7);
|
|
double cos = Math.cos(radians);
|
|
double sin = Math.sin(radians);
|
|
double d3 = (double) f;
|
|
double d4 = d3 * cos;
|
|
double d5 = (double) f2;
|
|
double d6 = (double) f5;
|
|
double d7 = ((d5 * sin) + d4) / d6;
|
|
double d8 = (double) f6;
|
|
double d9 = ((d5 * cos) + (((double) (-f)) * sin)) / d8;
|
|
double d10 = (double) f4;
|
|
double d11 = ((d10 * sin) + (((double) f3) * cos)) / d6;
|
|
double d12 = ((d10 * cos) + (((double) (-f3)) * sin)) / d8;
|
|
double d13 = d7 - d11;
|
|
double d14 = d9 - d12;
|
|
double d15 = (d7 + d11) / 2.0d;
|
|
double d16 = (d9 + d12) / 2.0d;
|
|
double d17 = (d14 * d14) + (d13 * d13);
|
|
if (d17 == 0.0d) {
|
|
Log.w("PathParser", " Points are coincident");
|
|
return;
|
|
}
|
|
double d18 = (1.0d / d17) - 0.25d;
|
|
if (d18 < 0.0d) {
|
|
Log.w("PathParser", "Points are too far apart " + d17);
|
|
float sqrt = (float) (Math.sqrt(d17) / 1.99999d);
|
|
drawArc(path, f, f2, f3, f4, f5 * sqrt, f6 * sqrt, f7, z2, z3);
|
|
return;
|
|
}
|
|
double sqrt2 = Math.sqrt(d18);
|
|
double d19 = d13 * sqrt2;
|
|
double d20 = sqrt2 * d14;
|
|
if (z2 == z3) {
|
|
d2 = d15 - d20;
|
|
d = d16 + d19;
|
|
} else {
|
|
d2 = d15 + d20;
|
|
d = d16 - d19;
|
|
}
|
|
double atan2 = Math.atan2(d9 - d, d7 - d2);
|
|
double atan22 = Math.atan2(d12 - d, d11 - d2) - atan2;
|
|
int i = (atan22 > 0.0d ? 1 : (atan22 == 0.0d ? 0 : -1));
|
|
if (z3 != (i >= 0)) {
|
|
atan22 = i > 0 ? atan22 - 6.283185307179586d : atan22 + 6.283185307179586d;
|
|
}
|
|
double d21 = d2 * d6;
|
|
double d22 = d * d8;
|
|
arcToBezier(path, (d21 * cos) - (d22 * sin), (d22 * cos) + (d21 * sin), d6, d8, d3, d5, radians, atan2, atan22);
|
|
}
|
|
|
|
public static void nodesToPath(PathDataNode[] pathDataNodeArr, Path path) {
|
|
float[] fArr = new float[6];
|
|
char c2 = 'm';
|
|
for (int i = 0; i < pathDataNodeArr.length; i++) {
|
|
addCommand(path, fArr, c2, pathDataNodeArr[i].mType, pathDataNodeArr[i].mParams);
|
|
c2 = pathDataNodeArr[i].mType;
|
|
}
|
|
}
|
|
|
|
public void interpolatePathDataNode(PathDataNode pathDataNode, PathDataNode pathDataNode2, float f) {
|
|
this.mType = pathDataNode.mType;
|
|
int i = 0;
|
|
while (true) {
|
|
float[] fArr = pathDataNode.mParams;
|
|
if (i < fArr.length) {
|
|
this.mParams[i] = (pathDataNode2.mParams[i] * f) + ((1.0f - f) * fArr[i]);
|
|
i++;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private PathParser() {
|
|
}
|
|
|
|
private static void addNode(ArrayList<PathDataNode> arrayList, char c2, float[] fArr) {
|
|
arrayList.add(new PathDataNode(c2, fArr));
|
|
}
|
|
|
|
public static boolean canMorph(@Nullable PathDataNode[] pathDataNodeArr, @Nullable PathDataNode[] pathDataNodeArr2) {
|
|
if (pathDataNodeArr == null || pathDataNodeArr2 == null || pathDataNodeArr.length != pathDataNodeArr2.length) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < pathDataNodeArr.length; i++) {
|
|
if (!(pathDataNodeArr[i].mType == pathDataNodeArr2[i].mType && pathDataNodeArr[i].mParams.length == pathDataNodeArr2[i].mParams.length)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static float[] copyOfRange(float[] fArr, int i, int i2) {
|
|
if (i <= i2) {
|
|
int length = fArr.length;
|
|
if (i < 0 || i > length) {
|
|
throw new ArrayIndexOutOfBoundsException();
|
|
}
|
|
int i3 = i2 - i;
|
|
int min = Math.min(i3, length - i);
|
|
float[] fArr2 = new float[i3];
|
|
System.arraycopy(fArr, i, fArr2, 0, min);
|
|
return fArr2;
|
|
}
|
|
throw new IllegalArgumentException();
|
|
}
|
|
|
|
public static PathDataNode[] createNodesFromPathData(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
int i = 1;
|
|
int i2 = 0;
|
|
while (i < str.length()) {
|
|
int nextStart = nextStart(str, i);
|
|
String trim = str.substring(i2, nextStart).trim();
|
|
if (trim.length() > 0) {
|
|
addNode(arrayList, trim.charAt(0), getFloats(trim));
|
|
}
|
|
i2 = nextStart;
|
|
i = nextStart + 1;
|
|
}
|
|
if (i - i2 == 1 && i2 < str.length()) {
|
|
addNode(arrayList, str.charAt(i2), new float[0]);
|
|
}
|
|
return (PathDataNode[]) arrayList.toArray(new PathDataNode[arrayList.size()]);
|
|
}
|
|
|
|
public static Path createPathFromPathData(String str) {
|
|
Path path = new Path();
|
|
PathDataNode[] createNodesFromPathData = createNodesFromPathData(str);
|
|
if (createNodesFromPathData == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
PathDataNode.nodesToPath(createNodesFromPathData, path);
|
|
return path;
|
|
} catch (RuntimeException e) {
|
|
throw new RuntimeException(a.t("Error in parsing ", str), e);
|
|
}
|
|
}
|
|
|
|
public static PathDataNode[] deepCopyNodes(PathDataNode[] pathDataNodeArr) {
|
|
if (pathDataNodeArr == null) {
|
|
return null;
|
|
}
|
|
PathDataNode[] pathDataNodeArr2 = new PathDataNode[pathDataNodeArr.length];
|
|
for (int i = 0; i < pathDataNodeArr.length; i++) {
|
|
pathDataNodeArr2[i] = new PathDataNode(pathDataNodeArr[i]);
|
|
}
|
|
return pathDataNodeArr2;
|
|
}
|
|
|
|
/* JADX INFO: Can't fix incorrect switch cases order, some code will duplicate */
|
|
/* JADX WARNING: Removed duplicated region for block: B:20:0x003a A[LOOP:0: B:1:0x0007->B:20:0x003a, LOOP_END] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:24:0x003d A[SYNTHETIC] */
|
|
private static void extract(String str, int i, ExtractFloatResult extractFloatResult) {
|
|
extractFloatResult.mEndWithNegOrDot = false;
|
|
boolean z2 = false;
|
|
boolean z3 = false;
|
|
boolean z4 = false;
|
|
for (int i2 = i; i2 < str.length(); i2++) {
|
|
char charAt = str.charAt(i2);
|
|
if (charAt != ' ') {
|
|
if (charAt == 'E' || charAt == 'e') {
|
|
z2 = true;
|
|
if (z4) {
|
|
extractFloatResult.mEndPosition = i2;
|
|
}
|
|
} else {
|
|
switch (charAt) {
|
|
case ',':
|
|
break;
|
|
case '-':
|
|
if (i2 != i && !z2) {
|
|
extractFloatResult.mEndWithNegOrDot = true;
|
|
break;
|
|
}
|
|
z2 = false;
|
|
break;
|
|
case '.':
|
|
if (!z3) {
|
|
z2 = false;
|
|
z3 = true;
|
|
break;
|
|
} else {
|
|
extractFloatResult.mEndWithNegOrDot = true;
|
|
break;
|
|
}
|
|
default:
|
|
z2 = false;
|
|
break;
|
|
}
|
|
if (z4) {
|
|
}
|
|
}
|
|
}
|
|
z2 = false;
|
|
z4 = true;
|
|
if (z4) {
|
|
}
|
|
}
|
|
extractFloatResult.mEndPosition = i2;
|
|
}
|
|
|
|
private static float[] getFloats(String str) {
|
|
if (str.charAt(0) == 'z' || str.charAt(0) == 'Z') {
|
|
return new float[0];
|
|
}
|
|
try {
|
|
float[] fArr = new float[str.length()];
|
|
ExtractFloatResult extractFloatResult = new ExtractFloatResult();
|
|
int length = str.length();
|
|
int i = 1;
|
|
int i2 = 0;
|
|
while (i < length) {
|
|
extract(str, i, extractFloatResult);
|
|
int i3 = extractFloatResult.mEndPosition;
|
|
if (i < i3) {
|
|
fArr[i2] = Float.parseFloat(str.substring(i, i3));
|
|
i2++;
|
|
}
|
|
i = extractFloatResult.mEndWithNegOrDot ? i3 : i3 + 1;
|
|
}
|
|
return copyOfRange(fArr, 0, i2);
|
|
} catch (NumberFormatException e) {
|
|
throw new RuntimeException(a.u("error in parsing \"", str, "\""), e);
|
|
}
|
|
}
|
|
|
|
public static boolean interpolatePathDataNodes(PathDataNode[] pathDataNodeArr, PathDataNode[] pathDataNodeArr2, PathDataNode[] pathDataNodeArr3, float f) {
|
|
if (pathDataNodeArr == null || pathDataNodeArr2 == null || pathDataNodeArr3 == null) {
|
|
throw new IllegalArgumentException("The nodes to be interpolated and resulting nodes cannot be null");
|
|
} else if (pathDataNodeArr.length == pathDataNodeArr2.length && pathDataNodeArr2.length == pathDataNodeArr3.length) {
|
|
if (!canMorph(pathDataNodeArr2, pathDataNodeArr3)) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < pathDataNodeArr.length; i++) {
|
|
pathDataNodeArr[i].interpolatePathDataNode(pathDataNodeArr2[i], pathDataNodeArr3[i], f);
|
|
}
|
|
return true;
|
|
} else {
|
|
throw new IllegalArgumentException("The nodes to be interpolated and resulting nodes must have the same length");
|
|
}
|
|
}
|
|
|
|
private static int nextStart(String str, int i) {
|
|
while (i < str.length()) {
|
|
char charAt = str.charAt(i);
|
|
if ((charAt - 'Z') * (charAt - 'A') > 0) {
|
|
if ((charAt - 'z') * (charAt - 'a') > 0) {
|
|
continue;
|
|
i++;
|
|
}
|
|
}
|
|
if (!(charAt == 'e' || charAt == 'E')) {
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public static void updateNodes(PathDataNode[] pathDataNodeArr, PathDataNode[] pathDataNodeArr2) {
|
|
for (int i = 0; i < pathDataNodeArr2.length; i++) {
|
|
pathDataNodeArr[i].mType = pathDataNodeArr2[i].mType;
|
|
for (int i2 = 0; i2 < pathDataNodeArr2[i].mParams.length; i2++) {
|
|
pathDataNodeArr[i].mParams[i2] = pathDataNodeArr2[i].mParams[i2];
|
|
}
|
|
}
|
|
}
|
|
}
|