xiaoyan159/vtm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reorder method / field modifiers (#619)

Browse Source 
* Reorder method / field modifiers

* Reorder method / field modifiers v2
This commit is contained in:
Gustl22
2018-12-14 19:38:54 +01:00
committed by Emux
parent d806d6bcca
commit c984eae2d5
13 changed files with 149 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
vtm-app/src/org/osmdroid/location/GeocoderNominatim.java
View File

@@ -51,7 +51,7 @@ public class GeocoderNominatim {
init(context, Locale.getDefault()); init(context, Locale.getDefault());
} }
static public boolean isPresent() { public static boolean isPresent() {
return true; return true;
} }

10
vtm-theme-comparator/src/org/oscim/theme/comparator/editor/ThemeLoader.java
View File

@@ -35,13 +35,13 @@ import java.util.prefs.BackingStoreException;
public class ThemeLoader { public class ThemeLoader {
final private Logger vtmLog = LoggerFactory.getLogger("org.oscim.ThemeLoader"); private final Logger vtmLog = LoggerFactory.getLogger("org.oscim.ThemeLoader");
final private Logger mapsforgeLog = LoggerFactory.getLogger("org.mapsforge.ThemeLoader"); private final Logger mapsforgeLog = LoggerFactory.getLogger("org.mapsforge.ThemeLoader");
final private VtmPanel vtmPanel; private final VtmPanel vtmPanel;
final private MapsforgeMapPanel mapsforgeMapPanel; private final MapsforgeMapPanel mapsforgeMapPanel;
final private RSyntaxTextArea syntaxTextArea; private final RSyntaxTextArea syntaxTextArea;
private String themePath; private String themePath;
private String editorText; private String editorText;

8
vtm-theme-comparator/src/org/oscim/theme/comparator/location/LocationData.java
View File

@@ -81,22 +81,22 @@ public final class LocationData {
} }
public synchronized static double getLatitude() { public static synchronized double getLatitude() {
return latitude; return latitude;
} }
synchronized static void setLatitude(double latitude) { static synchronized void setLatitude(double latitude) {
if (LocationData.latitude != latitude) { if (LocationData.latitude != latitude) {
LocationData.latitude = latitude; LocationData.latitude = latitude;
notifyChange(); notifyChange();
} }
} }
public synchronized static double getLongitude() { public static synchronized double getLongitude() {
return longitude; return longitude;
} }
public synchronized static void setLongitude(double longitude) { public static synchronized void setLongitude(double longitude) {
if (LocationData.longitude != longitude) { if (LocationData.longitude != longitude) {
LocationData.longitude = longitude; LocationData.longitude = longitude;
notifyChange(); notifyChange();

2
vtm-web/src/org/oscim/gdx/emu/com/badlogic/gdx/backends/gwt/GwtApplication.java
View File

@@ -572,7 +572,7 @@ public abstract class GwtApplication implements EntryPoint, Application {
} }
} }
native static public void consoleLog(String message) /*-{ public static native void consoleLog(String message) /*-{
console.log( "GWT: " + message ); console.log( "GWT: " + message );
}-*/; }-*/;

2
vtm-web/src/org/oscim/tiling/source/geojson/JsArrayCollection.java
View File

@@ -81,7 +81,7 @@ public class JsArrayCollection<T> extends AbstractCollection<T> {
protected JsArr() { protected JsArr() {
} }
public native final JsArr<T> slice(int start, int end)/*-{ public final native JsArr<T> slice(int start, int end)/*-{
return this.slice(start, end); return this.slice(start, end);
}-*/; }-*/;

2
vtm/src/org/oscim/layers/tile/MapTile.java
View File

@@ -150,7 +150,7 @@ public class MapTile extends Tile {
*/ */
MapTile holder; MapTile holder;
public static abstract class TileData extends Inlist<TileData> { public abstract static class TileData extends Inlist<TileData> {
Object id; Object id;
protected abstract void dispose(); protected abstract void dispose();

2
vtm/src/org/oscim/layers/tile/TileLayer.java
View File

@@ -61,7 +61,7 @@ public abstract class TileLayer extends Layer implements UpdateListener {
mRenderer = renderer; mRenderer = renderer;
} }
abstract protected TileLoader createLoader(); protected abstract TileLoader createLoader();
public TileRenderer tileRenderer() { public TileRenderer tileRenderer() {
return (TileRenderer) mRenderer; return (TileRenderer) mRenderer;

2
vtm/src/org/oscim/layers/vector/AbstractVectorLayer.java
View File

@@ -78,7 +78,7 @@ public abstract class AbstractVectorLayer<T> extends Layer implements UpdateList
mWorker.submit(0); mWorker.submit(0);
} }
abstract protected void processFeatures(Task t, Box b); protected abstract void processFeatures(Task t, Box b);
protected static class Task { protected static class Task {
public final RenderBuckets buckets = new RenderBuckets(); public final RenderBuckets buckets = new RenderBuckets();

46
vtm/src/org/oscim/renderer/GLMatrix.java
View File

@@ -253,52 +253,52 @@ public class GLMatrix {
delete(pointer); delete(pointer);
} }
private native static long alloc(); private static native long alloc();
private native static void delete(long self); private static native void delete(long self);
private native static void set(long self, float[] m); private static native void set(long self, float[] m);
private native static void copy(long self, long other); private static native void copy(long self, long other);
private native static void identity(long self); private static native void identity(long self);
private native static void get(long self, float[] m); private static native void get(long self, float[] m);
private native static void mul(long self, long lhs_ptr); private static native void mul(long self, long lhs_ptr);
private native static void smul(long self, long rhs_ptr, long lhs_ptr); private static native void smul(long self, long rhs_ptr, long lhs_ptr);
private native static void smulrhs(long self, long rhs_ptr); private static native void smulrhs(long self, long rhs_ptr);
private native static void smullhs(long self, long lhs_ptr); private static native void smullhs(long self, long lhs_ptr);
private native static void strans(long self, long rhs_ptr); private static native void strans(long self, long rhs_ptr);
private native static void prj(long self, float[] vec3); private static native void prj(long self, float[] vec3);
private native static void prj3D(long self, float[] vec3, int start, int cnt); private static native void prj3D(long self, float[] vec3, int start, int cnt);
private native static void prj2D(long self, float[] vec2, int start, int cnt); private static native void prj2D(long self, float[] vec2, int start, int cnt);
private native static void prj2D2(long self, float[] vec2, int src_offset, private static native void prj2D2(long self, float[] vec2, int src_offset,
float[] dst_vec, int dst_offset, int length); float[] dst_vec, int dst_offset, int length);
private native static void setRotation(long self, float a, float x, float y, float z); private static native void setRotation(long self, float a, float x, float y, float z);
private native static void setScale(long self, float x, float y, float z); private static native void setScale(long self, float x, float y, float z);
private native static void setTranslation(long self, float x, float y, float z); private static native void setTranslation(long self, float x, float y, float z);
private native static void setTransScale(long self, float tx, float ty, float scale); private static native void setTransScale(long self, float tx, float ty, float scale);
//private native static void setAsUniform(long self, int handle); //private static native void setAsUniform(long self, int handle);
private native static void setValueAt(long self, int pos, float value); private static native void setValueAt(long self, int pos, float value);
private native static void addDepthOffset(long self, int delta); private static native void addDepthOffset(long self, int delta);
private native static ByteBuffer getBuffer(long self); private static native ByteBuffer getBuffer(long self);
/* Copyright (C) 2007 The Android Open Source Project /* Copyright (C) 2007 The Android Open Source Project
* *

2
vtm/src/org/oscim/theme/styles/RenderStyle.java
View File

@@ -27,7 +27,7 @@ import static org.oscim.backend.canvas.Color.parseColor;
*/ */
public abstract class RenderStyle<T extends RenderStyle<T>> { public abstract class RenderStyle<T extends RenderStyle<T>> {
public static abstract class StyleBuilder<T extends StyleBuilder<T>> { public abstract static class StyleBuilder<T extends StyleBuilder<T>> {
public String cat; public String cat;
public String style; public String style;

20
vtm/src/org/oscim/utils/animation/Easing.java
View File

@@ -32,7 +32,7 @@ public class Easing {
QUINT_INOUT QUINT_INOUT
} }
static public float ease(long start, long current, float duration, Type easingType) { public static float ease(long start, long current, float duration, Type easingType) {
long millisElapsed = current - start; long millisElapsed = current - start;
if (millisElapsed > duration) { if (millisElapsed > duration) {
return 1; return 1;
@@ -79,42 +79,42 @@ public class Easing {
// Following easing functions are copied from https://github.com/danro/jquery-easing/blob/master/jquery.easing.js // Following easing functions are copied from https://github.com/danro/jquery-easing/blob/master/jquery.easing.js
// Under BSD license // Under BSD license
static private float linear(float x, float t, float b, float c, float d) { private static float linear(float x, float t, float b, float c, float d) {
return c * x + b; return c * x + b;
} }
static private float sineInout(float x, float t, float b, float c, float d) { private static float sineInout(float x, float t, float b, float c, float d) {
return -c / 2 * (float) (Math.cos(Math.PI * t / d) - 1) + b; return -c / 2 * (float) (Math.cos(Math.PI * t / d) - 1) + b;
} }
static private float sineIn(float x, float t, float b, float c, float d) { private static float sineIn(float x, float t, float b, float c, float d) {
return -c * (float) Math.cos(t / d * (Math.PI / 2)) + c + b; return -c * (float) Math.cos(t / d * (Math.PI / 2)) + c + b;
} }
static private float sineOut(float x, float t, float b, float c, float d) { private static float sineOut(float x, float t, float b, float c, float d) {
return c * (float) Math.sin(t / d * (Math.PI / 2)) + b; return c * (float) Math.sin(t / d * (Math.PI / 2)) + b;
} }
static private float expoOut(float x, float t, float b, float c, float d) { private static float expoOut(float x, float t, float b, float c, float d) {
return (t == d) ? b + c : c * (float) (-Math.pow(2, -10 * x) + 1) + b; return (t == d) ? b + c : c * (float) (-Math.pow(2, -10 * x) + 1) + b;
} }
static private float quadInout(float x, float t, float b, float c, float d) { private static float quadInout(float x, float t, float b, float c, float d) {
if ((t /= d / 2) < 1) return c / 2 * t * t + b; if ((t /= d / 2) < 1) return c / 2 * t * t + b;
return -c / 2 * ((--t) * (t - 2) - 1) + b; return -c / 2 * ((--t) * (t - 2) - 1) + b;
} }
static private float cubicInout(float x, float t, float b, float c, float d) { private static float cubicInout(float x, float t, float b, float c, float d) {
if ((t /= d / 2) < 1) return c / 2 * t * t * t + b; if ((t /= d / 2) < 1) return c / 2 * t * t * t + b;
return c / 2 * ((t -= 2) * t * t + 2) + b; return c / 2 * ((t -= 2) * t * t + 2) + b;
} }
static private float quartInout(float x, float t, float b, float c, float d) { private static float quartInout(float x, float t, float b, float c, float d) {
if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b; if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
return -c / 2 * ((t -= 2) * t * t * t - 2) + b; return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
} }
static private float quintInout(float x, float t, float b, float c, float d) { private static float quintInout(float x, float t, float b, float c, float d) {
if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b; if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
return c / 2 * ((t -= 2) * t * t * t * t + 2) + b; return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
} }

102
vtm/src/org/oscim/utils/math/Interpolation.java
View File

@@ -26,7 +26,7 @@ public abstract class Interpolation {
/** /**
* @param a Alpha value between 0 and 1. * @param a Alpha value between 0 and 1.
*/ */
abstract public float apply(float a); public abstract float apply(float a);
/** /**
* @param a Alpha value between 0 and 1. * @param a Alpha value between 0 and 1.
@@ -35,66 +35,66 @@ public abstract class Interpolation {
return start + (end - start) * apply(a); return start + (end - start) * apply(a);
} }
static public final Interpolation linear = new Interpolation() { public static final Interpolation linear = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return a; return a;
} }
}; };
static public final Interpolation fade = new Interpolation() { public static final Interpolation fade = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return MathUtils.clamp(a * a * a * (a * (a * 6 - 15) + 10), 0, 1); return MathUtils.clamp(a * a * a * (a * (a * 6 - 15) + 10), 0, 1);
} }
}; };
static public final Pow pow2 = new Pow(2); public static final Pow pow2 = new Pow(2);
static public final PowIn pow2In = new PowIn(2); public static final PowIn pow2In = new PowIn(2);
static public final PowOut pow2Out = new PowOut(2); public static final PowOut pow2Out = new PowOut(2);
static public final Pow pow3 = new Pow(3); public static final Pow pow3 = new Pow(3);
static public final PowIn pow3In = new PowIn(3); public static final PowIn pow3In = new PowIn(3);
static public final PowOut pow3Out = new PowOut(3); public static final PowOut pow3Out = new PowOut(3);
static public final Pow pow4 = new Pow(4); public static final Pow pow4 = new Pow(4);
static public final PowIn pow4In = new PowIn(4); public static final PowIn pow4In = new PowIn(4);
static public final PowOut pow4Out = new PowOut(4); public static final PowOut pow4Out = new PowOut(4);
static public final Pow pow5 = new Pow(5); public static final Pow pow5 = new Pow(5);
static public final PowIn pow5In = new PowIn(5); public static final PowIn pow5In = new PowIn(5);
static public final PowOut pow5Out = new PowOut(5); public static final PowOut pow5Out = new PowOut(5);
static public final Interpolation sine = new Interpolation() { public static final Interpolation sine = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return (1 - MathUtils.cos(a * MathUtils.PI)) / 2; return (1 - MathUtils.cos(a * MathUtils.PI)) / 2;
} }
}; };
static public final Interpolation sineIn = new Interpolation() { public static final Interpolation sineIn = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return 1 - MathUtils.cos(a * MathUtils.PI / 2); return 1 - MathUtils.cos(a * MathUtils.PI / 2);
} }
}; };
static public final Interpolation sineOut = new Interpolation() { public static final Interpolation sineOut = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return MathUtils.sin(a * MathUtils.PI / 2); return MathUtils.sin(a * MathUtils.PI / 2);
} }
}; };
static public final Interpolation exp10 = new Exp(2, 10); public static final Interpolation exp10 = new Exp(2, 10);
static public final Interpolation exp10In = new ExpIn(2, 10); public static final Interpolation exp10In = new ExpIn(2, 10);
static public final Interpolation exp10Out = new ExpOut(2, 10); public static final Interpolation exp10Out = new ExpOut(2, 10);
static public final Interpolation exp5 = new Exp(2, 5); public static final Interpolation exp5 = new Exp(2, 5);
static public final Interpolation exp5In = new ExpIn(2, 5); public static final Interpolation exp5In = new ExpIn(2, 5);
static public final Interpolation exp5Out = new ExpOut(2, 5); public static final Interpolation exp5Out = new ExpOut(2, 5);
static public final Interpolation circle = new Interpolation() { public static final Interpolation circle = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
if (a <= 0.5f) { if (a <= 0.5f) {
@@ -107,14 +107,14 @@ public abstract class Interpolation {
} }
}; };
static public final Interpolation circleIn = new Interpolation() { public static final Interpolation circleIn = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
return 1 - (float) Math.sqrt(1 - a * a); return 1 - (float) Math.sqrt(1 - a * a);
} }
}; };
static public final Interpolation circleOut = new Interpolation() { public static final Interpolation circleOut = new Interpolation() {
@Override @Override
public float apply(float a) { public float apply(float a) {
a--; a--;
@@ -122,21 +122,21 @@ public abstract class Interpolation {
} }
}; };
static public final Elastic elastic = new Elastic(2, 10); public static final Elastic elastic = new Elastic(2, 10);
static public final Elastic elasticIn = new ElasticIn(2, 10); public static final Elastic elasticIn = new ElasticIn(2, 10);
static public final Elastic elasticOut = new ElasticOut(2, 10); public static final Elastic elasticOut = new ElasticOut(2, 10);
static public final Interpolation swing = new Swing(1.5f); public static final Interpolation swing = new Swing(1.5f);
static public final Interpolation swingIn = new SwingIn(2f); public static final Interpolation swingIn = new SwingIn(2f);
static public final Interpolation swingOut = new SwingOut(2f); public static final Interpolation swingOut = new SwingOut(2f);
static public final Interpolation bounce = new Bounce(4); public static final Interpolation bounce = new Bounce(4);
static public final Interpolation bounceIn = new BounceIn(4); public static final Interpolation bounceIn = new BounceIn(4);
static public final Interpolation bounceOut = new BounceOut(4); public static final Interpolation bounceOut = new BounceOut(4);
// //
static public class Pow extends Interpolation { public static class Pow extends Interpolation {
final int power; final int power;
public Pow(int power) { public Pow(int power) {
@@ -151,7 +151,7 @@ public abstract class Interpolation {
} }
} }
static public class PowIn extends Pow { public static class PowIn extends Pow {
public PowIn(int power) { public PowIn(int power) {
super(power); super(power);
} }
@@ -162,7 +162,7 @@ public abstract class Interpolation {
} }
} }
static public class PowOut extends Pow { public static class PowOut extends Pow {
public PowOut(int power) { public PowOut(int power) {
super(power); super(power);
} }
@@ -175,7 +175,7 @@ public abstract class Interpolation {
// //
static public class Exp extends Interpolation { public static class Exp extends Interpolation {
final float value, power, min, scale; final float value, power, min, scale;
public Exp(float value, float power) { public Exp(float value, float power) {
@@ -193,7 +193,7 @@ public abstract class Interpolation {
} }
} }
static public class ExpIn extends Exp { public static class ExpIn extends Exp {
public ExpIn(float value, float power) { public ExpIn(float value, float power) {
super(value, power); super(value, power);
} }
@@ -204,7 +204,7 @@ public abstract class Interpolation {
} }
} }
static public class ExpOut extends Exp { public static class ExpOut extends Exp {
public ExpOut(float value, float power) { public ExpOut(float value, float power) {
super(value, power); super(value, power);
} }
@@ -217,7 +217,7 @@ public abstract class Interpolation {
// //
static public class Elastic extends Interpolation { public static class Elastic extends Interpolation {
final float value, power; final float value, power;
public Elastic(float value, float power) { public Elastic(float value, float power) {
@@ -239,7 +239,7 @@ public abstract class Interpolation {
} }
} }
static public class ElasticIn extends Elastic { public static class ElasticIn extends Elastic {
public ElasticIn(float value, float power) { public ElasticIn(float value, float power) {
super(value, power); super(value, power);
} }
@@ -250,7 +250,7 @@ public abstract class Interpolation {
} }
} }
static public class ElasticOut extends Elastic { public static class ElasticOut extends Elastic {
public ElasticOut(float value, float power) { public ElasticOut(float value, float power) {
super(value, power); super(value, power);
} }
@@ -264,7 +264,7 @@ public abstract class Interpolation {
// //
static public class Bounce extends BounceOut { public static class Bounce extends BounceOut {
public Bounce(float[] widths, float[] heights) { public Bounce(float[] widths, float[] heights) {
super(widths, heights); super(widths, heights);
} }
@@ -288,7 +288,7 @@ public abstract class Interpolation {
} }
} }
static public class BounceOut extends Interpolation { public static class BounceOut extends Interpolation {
final float[] widths, heights; final float[] widths, heights;
public BounceOut(float[] widths, float[] heights) { public BounceOut(float[] widths, float[] heights) {
@@ -359,7 +359,7 @@ public abstract class Interpolation {
} }
} }
static public class BounceIn extends BounceOut { public static class BounceIn extends BounceOut {
public BounceIn(float[] widths, float[] heights) { public BounceIn(float[] widths, float[] heights) {
super(widths, heights); super(widths, heights);
} }
@@ -376,7 +376,7 @@ public abstract class Interpolation {
// //
static public class Swing extends Interpolation { public static class Swing extends Interpolation {
private final float scale; private final float scale;
public Swing(float scale) { public Swing(float scale) {
@@ -395,7 +395,7 @@ public abstract class Interpolation {
} }
} }
static public class SwingOut extends Interpolation { public static class SwingOut extends Interpolation {
private final float scale; private final float scale;
public SwingOut(float scale) { public SwingOut(float scale) {
@@ -409,7 +409,7 @@ public abstract class Interpolation {
} }
} }
static public class SwingIn extends Interpolation { public static class SwingIn extends Interpolation {
private final float scale; private final float scale;
public SwingIn(float scale) { public SwingIn(float scale) {

98
vtm/src/org/oscim/utils/math/MathUtils.java
View File

@@ -27,26 +27,26 @@ import java.util.Random;
* @author Nathan Sweet * @author Nathan Sweet
*/ */
public class MathUtils { public class MathUtils {
static public final float nanoToSec = 1 / 1000000000f; public static final float nanoToSec = 1 / 1000000000f;
static public final float PI = 3.1415927f; public static final float PI = 3.1415927f;
public static final float PI2 = PI * 2; public static final float PI2 = PI * 2;
static private final int SIN_BITS = 13; // Adjust for accuracy. private static final int SIN_BITS = 13; // Adjust for accuracy.
static private final int SIN_MASK = ~(-1 << SIN_BITS); private static final int SIN_MASK = ~(-1 << SIN_BITS);
static private final int SIN_COUNT = SIN_MASK + 1; private static final int SIN_COUNT = SIN_MASK + 1;
static private final float radFull = PI * 2; private static final float radFull = PI * 2;
static private final float degFull = 360; private static final float degFull = 360;
static private final float radToIndex = SIN_COUNT / radFull; private static final float radToIndex = SIN_COUNT / radFull;
static private final float degToIndex = SIN_COUNT / degFull; private static final float degToIndex = SIN_COUNT / degFull;
static public final float radiansToDegrees = 180f / PI; public static final float radiansToDegrees = 180f / PI;
static public final float radDeg = radiansToDegrees; public static final float radDeg = radiansToDegrees;
static public final float degreesToRadians = PI / 180; public static final float degreesToRadians = PI / 180;
static public final float degRad = degreesToRadians; public static final float degRad = degreesToRadians;
static private class Sin { private static class Sin {
static final float[] table = new float[SIN_COUNT]; static final float[] table = new float[SIN_COUNT];
static { static {
@@ -57,7 +57,7 @@ public class MathUtils {
} }
} }
static private class Cos { private static class Cos {
static final float[] table = new float[SIN_COUNT]; static final float[] table = new float[SIN_COUNT];
static { static {
@@ -71,41 +71,41 @@ public class MathUtils {
/** /**
* Returns the sine in radians. * Returns the sine in radians.
*/ */
static public final float sin(float radians) { public static final float sin(float radians) {
return Sin.table[(int) (radians * radToIndex) & SIN_MASK]; return Sin.table[(int) (radians * radToIndex) & SIN_MASK];
} }
/** /**
* Returns the cosine in radians. * Returns the cosine in radians.
*/ */
static public final float cos(float radians) { public static final float cos(float radians) {
return Cos.table[(int) (radians * radToIndex) & SIN_MASK]; return Cos.table[(int) (radians * radToIndex) & SIN_MASK];
} }
/** /**
* Returns the sine in radians. * Returns the sine in radians.
*/ */
static public final float sinDeg(float degrees) { public static final float sinDeg(float degrees) {
return Sin.table[(int) (degrees * degToIndex) & SIN_MASK]; return Sin.table[(int) (degrees * degToIndex) & SIN_MASK];
} }
/** /**
* Returns the cosine in radians. * Returns the cosine in radians.
*/ */
static public final float cosDeg(float degrees) { public static final float cosDeg(float degrees) {
return Cos.table[(int) (degrees * degToIndex) & SIN_MASK]; return Cos.table[(int) (degrees * degToIndex) & SIN_MASK];
} }
// --- // ---
static private final int ATAN2_BITS = 7; // Adjust for accuracy. private static final int ATAN2_BITS = 7; // Adjust for accuracy.
static private final int ATAN2_BITS2 = ATAN2_BITS << 1; private static final int ATAN2_BITS2 = ATAN2_BITS << 1;
static private final int ATAN2_MASK = ~(-1 << ATAN2_BITS2); private static final int ATAN2_MASK = ~(-1 << ATAN2_BITS2);
static private final int ATAN2_COUNT = ATAN2_MASK + 1; private static final int ATAN2_COUNT = ATAN2_MASK + 1;
static final int ATAN2_DIM = (int) Math.sqrt(ATAN2_COUNT); static final int ATAN2_DIM = (int) Math.sqrt(ATAN2_COUNT);
static private final float INV_ATAN2_DIM_MINUS_1 = 1.0f / (ATAN2_DIM - 1); private static final float INV_ATAN2_DIM_MINUS_1 = 1.0f / (ATAN2_DIM - 1);
static private class Atan2 { private static class Atan2 {
static final float[] table = new float[ATAN2_COUNT]; static final float[] table = new float[ATAN2_COUNT];
static { static {
@@ -122,7 +122,7 @@ public class MathUtils {
/** /**
* Returns atan2 in radians from a lookup table. * Returns atan2 in radians from a lookup table.
*/ */
static public final float atan2(float y, float x) { public static final float atan2(float y, float x) {
float add, mul; float add, mul;
if (x < 0) { if (x < 0) {
if (y < 0) { if (y < 0) {
@@ -148,34 +148,34 @@ public class MathUtils {
// --- // ---
static public Random random = new Random(); public static Random random = new Random();
/** /**
* Returns a random number between 0 (inclusive) and the specified value * Returns a random number between 0 (inclusive) and the specified value
* (inclusive). * (inclusive).
*/ */
static public final int random(int range) { public static final int random(int range) {
return random.nextInt(range + 1); return random.nextInt(range + 1);
} }
/** /**
* Returns a random number between start (inclusive) and end (inclusive). * Returns a random number between start (inclusive) and end (inclusive).
*/ */
static public final int random(int start, int end) { public static final int random(int start, int end) {
return start + random.nextInt(end - start + 1); return start + random.nextInt(end - start + 1);
} }
/** /**
* Returns a random boolean value. * Returns a random boolean value.
*/ */
static public final boolean randomBoolean() { public static final boolean randomBoolean() {
return random.nextBoolean(); return random.nextBoolean();
} }
/** /**
* Returns random number between 0.0 (inclusive) and 1.0 (exclusive). * Returns random number between 0.0 (inclusive) and 1.0 (exclusive).
*/ */
static public final float random() { public static final float random() {
return random.nextFloat(); return random.nextFloat();
} }
@@ -183,14 +183,14 @@ public class MathUtils {
* Returns a random number between 0 (inclusive) and the specified value * Returns a random number between 0 (inclusive) and the specified value
* (exclusive). * (exclusive).
*/ */
static public final float random(float range) { public static final float random(float range) {
return random.nextFloat() * range; return random.nextFloat() * range;
} }
/** /**
* Returns a random number between start (inclusive) and end (exclusive). * Returns a random number between start (inclusive) and end (exclusive).
*/ */
static public final float random(float start, float end) { public static final float random(float start, float end) {
return start + random.nextFloat() * (end - start); return start + random.nextFloat() * (end - start);
} }
@@ -200,7 +200,7 @@ public class MathUtils {
* Returns the next power of two. Returns the specified value if the value * Returns the next power of two. Returns the specified value if the value
* is already a power of two. * is already a power of two.
*/ */
static public int nextPowerOfTwo(int value) { public static int nextPowerOfTwo(int value) {
if (value == 0) if (value == 0)
return 1; return 1;
value--; value--;
@@ -212,13 +212,13 @@ public class MathUtils {
return value + 1; return value + 1;
} }
static public boolean isPowerOfTwo(int value) { public static boolean isPowerOfTwo(int value) {
return value != 0 && (value & value - 1) == 0; return value != 0 && (value & value - 1) == 0;
} }
// --- // ---
static public int clamp(int value, int min, int max) { public static int clamp(int value, int min, int max) {
if (value < min) if (value < min)
return min; return min;
if (value > max) if (value > max)
@@ -226,7 +226,7 @@ public class MathUtils {
return value; return value;
} }
static public short clamp(short value, short min, short max) { public static short clamp(short value, short min, short max) {
if (value < min) if (value < min)
return min; return min;
if (value > max) if (value > max)
@@ -234,7 +234,7 @@ public class MathUtils {
return value; return value;
} }
static public float clamp(float value, float min, float max) { public static float clamp(float value, float min, float max) {
if (value < min) if (value < min)
return min; return min;
if (value > max) if (value > max)
@@ -244,18 +244,18 @@ public class MathUtils {
// --- // ---
static private final int BIG_ENOUGH_INT = 16 * 1024; private static final int BIG_ENOUGH_INT = 16 * 1024;
static private final double BIG_ENOUGH_FLOOR = BIG_ENOUGH_INT; private static final double BIG_ENOUGH_FLOOR = BIG_ENOUGH_INT;
static private final double CEIL = 0.9999999; private static final double CEIL = 0.9999999;
static private final double BIG_ENOUGH_CEIL = Double.longBitsToDouble(Double.doubleToLongBits(BIG_ENOUGH_INT + 1) - 1); private static final double BIG_ENOUGH_CEIL = Double.longBitsToDouble(Double.doubleToLongBits(BIG_ENOUGH_INT + 1) - 1);
static private final double BIG_ENOUGH_ROUND = BIG_ENOUGH_INT + 0.5f; private static final double BIG_ENOUGH_ROUND = BIG_ENOUGH_INT + 0.5f;
/** /**
* Returns the largest integer less than or equal to the specified float. * Returns the largest integer less than or equal to the specified float.
* This method will only properly floor floats from * This method will only properly floor floats from
* -(2^14) to (Float.MAX_VALUE - 2^14). * -(2^14) to (Float.MAX_VALUE - 2^14).
*/ */
static public int floor(float x) { public static int floor(float x) {
return (int) (x + BIG_ENOUGH_FLOOR) - BIG_ENOUGH_INT; return (int) (x + BIG_ENOUGH_FLOOR) - BIG_ENOUGH_INT;
} }
@@ -264,7 +264,7 @@ public class MathUtils {
* This method will only properly floor floats that are * This method will only properly floor floats that are
* positive. Note this method simply casts the float to int. * positive. Note this method simply casts the float to int.
*/ */
static public int floorPositive(float x) { public static int floorPositive(float x) {
return (int) x; return (int) x;
} }
@@ -273,7 +273,7 @@ public class MathUtils {
* float. This method will only properly ceil floats from * float. This method will only properly ceil floats from
* -(2^14) to (Float.MAX_VALUE - 2^14). * -(2^14) to (Float.MAX_VALUE - 2^14).
*/ */
static public int ceil(float x) { public static int ceil(float x) {
return (int) (x + BIG_ENOUGH_CEIL) - BIG_ENOUGH_INT; return (int) (x + BIG_ENOUGH_CEIL) - BIG_ENOUGH_INT;
} }
@@ -282,7 +282,7 @@ public class MathUtils {
* float. This method will only properly ceil floats that * float. This method will only properly ceil floats that
* are positive. * are positive.
*/ */
static public int ceilPositive(float x) { public static int ceilPositive(float x) {
return (int) (x + CEIL); return (int) (x + CEIL);
} }
@@ -291,7 +291,7 @@ public class MathUtils {
* properly round floats from -(2^14) to * properly round floats from -(2^14) to
* (Float.MAX_VALUE - 2^14). * (Float.MAX_VALUE - 2^14).
*/ */
static public int round(float x) { public static int round(float x) {
return (int) (x + BIG_ENOUGH_ROUND) - BIG_ENOUGH_INT; return (int) (x + BIG_ENOUGH_ROUND) - BIG_ENOUGH_INT;
} }
@@ -299,7 +299,7 @@ public class MathUtils {
* Returns the closest integer to the specified float. This method will only * Returns the closest integer to the specified float. This method will only
* properly round floats that are positive. * properly round floats that are positive.
*/ */
static public int roundPositive(float x) { public static int roundPositive(float x) {
return (int) (x + 0.5f); return (int) (x + 0.5f);
} }
} }