diff options
author | neothemachine <[email protected]> | 2012-12-05 17:03:16 +0100 |
---|---|---|
committer | neothemachine <[email protected]> | 2012-12-05 17:03:16 +0100 |
commit | 9dd02f103042cb8a196f8a3ed2278da443e345bf (patch) | |
tree | 422449f0c62ff9518316ce5d4219bb2b12f0ed15 /ardor3d-math/src/main/java/com/ardor3d | |
parent | 2b26b12fd794de0f03a064a10024a3d9f5583756 (diff) |
move all files from trunk to root folder
Diffstat (limited to 'ardor3d-math/src/main/java/com/ardor3d')
59 files changed, 17946 insertions, 0 deletions
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/ColorRGBA.java b/ardor3d-math/src/main/java/com/ardor3d/math/ColorRGBA.java new file mode 100644 index 0000000..ea11e50 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/ColorRGBA.java @@ -0,0 +1,1040 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyColorRGBA; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * ColorRGBA is a 4 component color value (red, green, blue, alpha). The standard range for each individual component is + * [0f, 1f]. Non-standard use of color (for example HDR rendering) may need to use values outside of this range however, + * so the value is not clipped or enforced. + */ +public class ColorRGBA implements Cloneable, Savable, Externalizable, ReadOnlyColorRGBA, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<ColorRGBA> COLOR_POOL = ObjectPool.create(ColorRGBA.class, + MathConstants.maxMathPoolSize); + + /** + * the color black (0, 0, 0, 1). + */ + public static final ReadOnlyColorRGBA BLACK = new ColorRGBA(0f, 0f, 0f, 1f); + /** + * the color black with a zero alpha value (0, 0, 0, 0). + */ + public static final ReadOnlyColorRGBA BLACK_NO_ALPHA = new ColorRGBA(0f, 0f, 0f, 0f); + /** + * the color white (1, 1, 1, 1). + */ + public static final ReadOnlyColorRGBA WHITE = new ColorRGBA(1f, 1f, 1f, 1f); + /** + * the color gray (.2f, .2f, .2f, 1). + */ + public static final ReadOnlyColorRGBA DARK_GRAY = new ColorRGBA(0.2f, 0.2f, 0.2f, 1.0f); + /** + * the color gray (.5f, .5f, .5f, 1). + */ + public static final ReadOnlyColorRGBA GRAY = new ColorRGBA(0.5f, 0.5f, 0.5f, 1.0f); + /** + * the color gray (.8f, .8f, .8f, 1). + */ + public static final ReadOnlyColorRGBA LIGHT_GRAY = new ColorRGBA(0.8f, 0.8f, 0.8f, 1.0f); + /** + * the color red (1, 0, 0, 1). + */ + public static final ReadOnlyColorRGBA RED = new ColorRGBA(1f, 0f, 0f, 1f); + /** + * the color green (0, 1, 0, 1). + */ + public static final ReadOnlyColorRGBA GREEN = new ColorRGBA(0f, 1f, 0f, 1f); + /** + * the color blue (0, 0, 1, 1). + */ + public static final ReadOnlyColorRGBA BLUE = new ColorRGBA(0f, 0f, 1f, 1f); + /** + * the color yellow (1, 1, 0, 1). + */ + public static final ReadOnlyColorRGBA YELLOW = new ColorRGBA(1f, 1f, 0f, 1f); + /** + * the color magenta (1, 0, 1, 1). + */ + public static final ReadOnlyColorRGBA MAGENTA = new ColorRGBA(1f, 0f, 1f, 1f); + /** + * the color cyan (0, 1, 1, 1). + */ + public static final ReadOnlyColorRGBA CYAN = new ColorRGBA(0f, 1f, 1f, 1f); + /** + * the color orange (251/255f, 130/255f, 0, 1). + */ + public static final ReadOnlyColorRGBA ORANGE = new ColorRGBA(251f / 255f, 130f / 255f, 0f, 1f); + /** + * the color brown (65/255f, 40/255f, 25/255f, 1). + */ + public static final ReadOnlyColorRGBA BROWN = new ColorRGBA(65f / 255f, 40f / 255f, 25f / 255f, 1f); + /** + * the color pink (1, 0.68f, 0.68f, 1). + */ + public static final ReadOnlyColorRGBA PINK = new ColorRGBA(1f, 0.68f, 0.68f, 1f); + + protected float _r = 0; + protected float _g = 0; + protected float _b = 0; + protected float _a = 0; + + /** + * Constructs a new, mutable color set to (1, 1, 1, 1). + */ + public ColorRGBA() { + this(1, 1, 1, 1); + } + + /** + * Constructs a new, mutable color set to the (r, g, b, a) values of the provided source color. + * + * @param src + */ + public ColorRGBA(final ReadOnlyColorRGBA src) { + this(src.getRed(), src.getGreen(), src.getBlue(), src.getAlpha()); + } + + /** + * Constructs a new color set to (r, g, b, a). + * + * @param r + * @param g + * @param b + * @param a + */ + public ColorRGBA(final float r, final float g, final float b, final float a) { + _r = r; + _g = g; + _b = b; + _a = a; + } + + @Override + public float getRed() { + return _r; + } + + @Override + public float getGreen() { + return _g; + } + + @Override + public float getBlue() { + return _b; + } + + @Override + public float getAlpha() { + return _a; + } + + /** + * @param index + * @return r value if index == 0, g value if index == 1, b value if index == 2 or a value if index == 3 + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2, 3. + */ + @Override + public float getValue(final int index) { + switch (index) { + case 0: + return getRed(); + case 1: + return getGreen(); + case 2: + return getBlue(); + case 3: + return getAlpha(); + } + throw new IllegalArgumentException("index must be either 0, 1, 2 or 3"); + } + + /** + * @param index + * which field index in this color to set. + * @param value + * to set to one of r, g, b or a. + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2, 3. + */ + public void setValue(final int index, final float value) { + switch (index) { + case 0: + setRed(value); + return; + case 1: + setGreen(value); + return; + case 2: + setBlue(value); + return; + case 3: + setAlpha(value); + return; + } + throw new IllegalArgumentException("index must be either 0, 1, 2 or 3"); + } + + /** + * Stores the float values of this color in the given float array. + * + * @param store + * if null, a new float[4] array is created. + * @return the float array + * @throws NullPointerException + * if store is null. + * @throws ArrayIndexOutOfBoundsException + * if store is not at least length 4. + */ + @Override + public float[] toArray(float[] store) { + if (store == null) { + store = new float[4]; + } + // do last first to ensure size is correct before any edits occur. + store[3] = getAlpha(); + store[2] = getBlue(); + store[1] = getGreen(); + store[0] = getRed(); + return store; + } + + /** + * Sets the red component of this color to the given float value. + * + * @param r + * new red value, generally should be in the range [0.0f, 1.0f] + */ + public void setRed(final float r) { + _r = r; + } + + /** + * Sets the green component of this color to the given float value. + * + * @param g + * new green value, generally should be in the range [0.0f, 1.0f] + */ + public void setGreen(final float g) { + _g = g; + } + + /** + * Sets the blue component of this color to the given float value. + * + * @param b + * new blue value, generally should be in the range [0.0f, 1.0f] + */ + public void setBlue(final float b) { + _b = b; + } + + /** + * Sets the alpha component of this color to the given float value. Consider that an alpha of 1.0f means opaque (can + * not see through) and 0.0f means transparent. + * + * @param a + * new alpha value, generally should be in the range [0.0f, 1.0f] + */ + public void setAlpha(final float a) { + _a = a; + } + + /** + * Sets the value of this color to (r, g, b, a) + * + * @param r + * new red value, generally should be in the range [0.0f, 1.0f] + * @param g + * new green value, generally should be in the range [0.0f, 1.0f] + * @param b + * new blue value, generally should be in the range [0.0f, 1.0f] + * @param a + * new alpha value, generally should be in the range [0.0f, 1.0f] + * @return this color for chaining + */ + public ColorRGBA set(final float r, final float g, final float b, final float a) { + setRed(r); + setGreen(g); + setBlue(b); + setAlpha(a); + return this; + } + + /** + * Sets the value of this color to the (r, g, b, a) values of the provided source color. + * + * @param source + * @return this color for chaining + * @throws NullPointerException + * if source is null. + */ + public ColorRGBA set(final ReadOnlyColorRGBA source) { + _r = source.getRed(); + _g = source.getGreen(); + _b = source.getBlue(); + _a = source.getAlpha(); + return this; + } + + /** + * Sets the value of this color to (0, 0, 0, 0) + * + * @return this color for chaining + */ + public ColorRGBA zero() { + return set(0, 0, 0, 0); + } + + /** + * Brings all values (r,g,b,a) into the range [0.0f, 1.0f]. If a value is above or below this range it is replaced + * with the appropriate end of the range. + * + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + */ + @Override + public ColorRGBA clamp(final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(this); + } else if (result != this) { + result.set(this); + } + + if (result._r < 0.0f) { + result._r = 0.0f; + } else if (result._r > 1.0f) { + result._r = 1.0f; + } + + if (result._g < 0.0f) { + result._g = 0.0f; + } else if (result._g > 1.0f) { + result._g = 1.0f; + } + + if (result._b < 0.0f) { + result._b = 0.0f; + } else if (result._b > 1.0f) { + result._b = 1.0f; + } + + if (result._a < 0.0f) { + result._a = 0.0f; + } else if (result._a > 1.0f) { + result._a = 1.0f; + } + + return result; + } + + /** + * Brings all values (r,g,b,a) into the range [0.0f, 1.0f]. If a value is above or below this range it is replaced + * with the appropriate end of the range. + * + * @return this color for chaining + */ + public ColorRGBA clampLocal() { + return clamp(this); + } + + /** + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a random, mutable opaque color. + */ + public static ColorRGBA randomColor(final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + result._r = MathUtils.nextRandomFloat(); + result._g = MathUtils.nextRandomFloat(); + result._b = MathUtils.nextRandomFloat(); + result._a = 1.0f; + return result; + } + + /** + * @return this color, stored as an integer by converting the values to the range [0, 255] and combining them as + * single byte values into a 4 byte int in the order ARGB. Note that this method expects color values in the + * [0.0f, 1.0f] range. + */ + @Override + public int asIntARGB() { + final int argb = ((int) (_a * 255) & 0xFF) << 24 | ((int) (_r * 255) & 0xFF) << 16 + | ((int) (_g * 255) & 0xFF) << 8 | (int) (_b * 255) & 0xFF; + return argb; + } + + /** + * @return this color, stored as an integer by converting the values to the range [0, 255] and combining them as + * single byte values into a 4 byte int in the order RGBA. Note that this method expects color values in the + * [0.0f, 1.0f] range. + */ + @Override + public int asIntRGBA() { + final int rgba = ((int) (_r * 255) & 0xFF) << 24 | ((int) (_g * 255) & 0xFF) << 16 + | ((int) (_b * 255) & 0xFF) << 8 | (int) (_a * 255) & 0xFF; + return rgba; + } + + /** + * Reads a color, packed into a 4 byte int as 1 byte values in the order ARGB. These byte values are normalized to + * the range [0.0f, 1.0f] + * + * @param color + * @return this color for chaining + */ + public ColorRGBA fromIntARGB(final int color) { + _a = ((byte) (color >> 24) & 0xFF) / 255f; + _r = ((byte) (color >> 16) & 0xFF) / 255f; + _g = ((byte) (color >> 8) & 0xFF) / 255f; + _b = ((byte) color & 0xFF) / 255f; + return this; + } + + /** + * Reads a color, packed into a 4 byte int as 1 byte values in the order RGBA. These byte values are normalized to + * the range [0.0f, 1.0f] + * + * @param color + * @return this color for chaining + */ + public ColorRGBA fromIntRGBA(final int color) { + _r = ((byte) (color >> 24) & 0xFF) / 255f; + _g = ((byte) (color >> 16) & 0xFF) / 255f; + _b = ((byte) (color >> 8) & 0xFF) / 255f; + _a = ((byte) color & 0xFF) / 255f; + return this; + } + + /** + * @return this string as a hex value (#RRGGBBAA). e.g. opaque blue is #0000ffff + */ + @Override + public String asHexRRGGBBAA() { + final StringBuilder sb = new StringBuilder("#"); + final String red = Integer.toHexString(Math.round(MathUtils.clamp(getRed(), 0f, 1f) * 255)); + final String green = Integer.toHexString(Math.round(MathUtils.clamp(getGreen(), 0f, 1f) * 255)); + final String blue = Integer.toHexString(Math.round(MathUtils.clamp(getBlue(), 0f, 1f) * 255)); + final String alpha = Integer.toHexString(Math.round(MathUtils.clamp(getAlpha(), 0f, 1f) * 255)); + if (red.length() < 2) { + sb.append("0"); + } + sb.append(red); + if (green.length() < 2) { + sb.append("0"); + } + sb.append(green); + if (blue.length() < 2) { + sb.append("0"); + } + sb.append(blue); + if (alpha.length() < 2) { + sb.append("0"); + } + sb.append(alpha); + return sb.toString(); + } + + /** + * Adds the given values to those of this color and returns them in store. + * + * @param r + * @param g + * @param b + * @param a + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return (this.r + r, this.g + g, this.b + b, this.a + a) + */ + @Override + public ColorRGBA add(final float r, final float g, final float b, final float a, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() + r, getGreen() + g, getBlue() + b, getAlpha() + a); + } + + /** + * Increments the values of this color with the given r, g, b and a values. + * + * @param r + * @param g + * @param b + * @param a + * @return this color for chaining + */ + public ColorRGBA addLocal(final float r, final float g, final float b, final float a) { + return set(getRed() + r, getGreen() + g, getBlue() + b, getAlpha() + a); + } + + /** + * Adds the values of the given source color to those of this color and returns them in store. + * + * @param source + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return (this.r + source.r, this.g + source.g, this.b + source.b, this.a + source.a) + * @throws NullPointerException + * if source is null. + */ + @Override + public ColorRGBA add(final ReadOnlyColorRGBA source, final ColorRGBA store) { + return add(source.getRed(), source.getGreen(), source.getBlue(), source.getAlpha(), store); + } + + /** + * Increments the values of this color with the r, g, b and a values of the given color. + * + * @param source + * @return this color for chaining + * @throws NullPointerException + * if source is null. + */ + public ColorRGBA addLocal(final ReadOnlyColorRGBA source) { + return addLocal(source.getRed(), source.getGreen(), source.getBlue(), source.getAlpha()); + } + + /** + * Subtracts the given values from those of this color and returns them in store. + * + * @param r + * @param g + * @param b + * @param a + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return (this.r - r, this.g - g, this.b - b, this.a - a) + */ + @Override + public ColorRGBA subtract(final float r, final float g, final float b, final float a, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() - r, getGreen() - g, getBlue() - b, getAlpha() - a); + } + + /** + * Decrements the values of this color by the given r, g, b and a values. + * + * @param r + * @param g + * @param b + * @param a + * @return this color for chaining + */ + public ColorRGBA subtractLocal(final float r, final float g, final float b, final float a) { + return set(getRed() - r, getGreen() - g, getBlue() - b, getAlpha() - a); + } + + /** + * Subtracts the values of the given source color from those of this color and returns them in store. + * + * @param source + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return (this.r - source.r, this.g - source.g, this.b - source.b, this.a - source.a) + * @throws NullPointerException + * if source is null. + */ + @Override + public ColorRGBA subtract(final ReadOnlyColorRGBA source, final ColorRGBA store) { + return subtract(source.getRed(), source.getGreen(), source.getBlue(), source.getAlpha(), store); + } + + /** + * Decrements the values of this color by the r, g, b and a values from the given source color. + * + * @param source + * @return this color for chaining + * @throws NullPointerException + * if source is null. + */ + public ColorRGBA subtractLocal(final ReadOnlyColorRGBA source) { + return subtractLocal(source.getRed(), source.getGreen(), source.getBlue(), source.getAlpha()); + } + + /** + * Multiplies the values of this color by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new color (this.r * scalar, this.g * scalar, this.b * scalar, this.a * scalar) + */ + @Override + public ColorRGBA multiply(final float scalar, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() * scalar, getGreen() * scalar, getBlue() * scalar, getAlpha() * scalar); + } + + /** + * Internally modifies the values of this color by multiplying them each by the given scalar value. + * + * @param scalar + * @return this color for chaining + * + * . + */ + public ColorRGBA multiplyLocal(final float scalar) { + return set(getRed() * scalar, getGreen() * scalar, getBlue() * scalar, getAlpha() * scalar); + } + + /** + * Multiplies the values of this color by the given scalar value and returns the result in store. + * + * @param scale + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new color (this.r * scale.r, this.g * scale.g, this.b * scale.b, this.a * scale.a) + */ + @Override + public ColorRGBA multiply(final ReadOnlyColorRGBA scale, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() * scale.getRed(), getGreen() * scale.getGreen(), getBlue() * scale.getBlue(), + getAlpha() * scale.getAlpha()); + } + + /** + * Internally modifies the values of this color by multiplying them each by the given scale values. + * + * @param scale + * @return this color for chaining + */ + public ColorRGBA multiplyLocal(final ReadOnlyColorRGBA scale) { + return set(getRed() * scale.getRed(), getGreen() * scale.getGreen(), getBlue() * scale.getBlue(), getAlpha() + * scale.getAlpha()); + } + + /** + * Divides the values of this color by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new color (this.r / scalar, this.g / scalar, this.b / scalar, this.a / scalar) + */ + @Override + public ColorRGBA divide(final float scalar, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() / scalar, getGreen() / scalar, getBlue() / scalar, getAlpha() / scalar); + } + + /** + * Internally modifies the values of this color by dividing them each by the given scalar value. + * + * @param scalar + * @return this color for chaining + * @throws ArithmeticException + * if scalar is 0 + */ + public ColorRGBA divideLocal(final float scalar) { + final float invScalar = 1.0f / scalar; + + return set(getRed() * invScalar, getGreen() * invScalar, getBlue() * invScalar, getAlpha() * invScalar); + } + + /** + * Divides the values of this color by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new color (this.r / scale.r, this.g / scale.g, this.b / scale.b, this.a / scale.a) + */ + @Override + public ColorRGBA divide(final ReadOnlyColorRGBA scale, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + return result.set(getRed() / scale.getRed(), getGreen() / scale.getGreen(), getBlue() / scale.getBlue(), + getAlpha() / scale.getAlpha()); + } + + /** + * Internally modifies the values of this color by dividing them each by the given scale values. + * + * @param scale + * @return this color for chaining + */ + public ColorRGBA divideLocal(final ReadOnlyColorRGBA scale) { + return set(getRed() / scale.getRed(), getGreen() / scale.getGreen(), getBlue() / scale.getBlue(), getAlpha() + / scale.getAlpha()); + } + + /** + * Performs a linear interpolation between this color and the given end color, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the current value of this color and if it is + * closer to 1, the result will be closer to the end value. + * + * @param endColor + * @param scalar + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new mutable color as described above. + * @throws NullPointerException + * if endVec is null. + */ + @Override + public ColorRGBA lerp(final ReadOnlyColorRGBA endColor, final float scalar, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + final float r = (1.0f - scalar) * getRed() + scalar * endColor.getRed(); + final float g = (1.0f - scalar) * getGreen() + scalar * endColor.getGreen(); + final float b = (1.0f - scalar) * getBlue() + scalar * endColor.getBlue(); + final float a = (1.0f - scalar) * getAlpha() + scalar * endColor.getAlpha(); + return result.set(r, g, b, a); + } + + /** + * Performs a linear interpolation between this color and the given end color, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the current value of this color and if it is + * closer to 1, the result will be closer to the end value. The result is stored back in this color. + * + * @param endColor + * @param scalar + * @return this color for chaining + * @throws NullPointerException + * if endVec is null. + */ + public ColorRGBA lerpLocal(final ReadOnlyColorRGBA endColor, final float scalar) { + setRed((1.0f - scalar) * getRed() + scalar * endColor.getRed()); + setGreen((1.0f - scalar) * getGreen() + scalar * endColor.getGreen()); + setBlue((1.0f - scalar) * getBlue() + scalar * endColor.getBlue()); + setAlpha((1.0f - scalar) * getAlpha() + scalar * endColor.getAlpha()); + return this; + } + + /** + * Performs a linear interpolation between the given begin and end colors, using the given scalar as a percent. iow, + * if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the result + * will be closer to the end value. + * + * @param beginColor + * @param endColor + * @param scalar + * the scalar as a percent. + * @param store + * the color to store the result in for return. If null, a new color object is created and returned. + * @return a new mutable color as described above. + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public static ColorRGBA lerp(final ReadOnlyColorRGBA beginColor, final ReadOnlyColorRGBA endColor, + final float scalar, final ColorRGBA store) { + ColorRGBA result = store; + if (result == null) { + result = new ColorRGBA(); + } + + final float r = (1.0f - scalar) * beginColor.getRed() + scalar * endColor.getRed(); + final float g = (1.0f - scalar) * beginColor.getGreen() + scalar * endColor.getGreen(); + final float b = (1.0f - scalar) * beginColor.getBlue() + scalar * endColor.getBlue(); + final float a = (1.0f - scalar) * beginColor.getAlpha() + scalar * endColor.getAlpha(); + return result.set(r, g, b, a); + } + + /** + * Performs a linear interpolation between the given begin and end colors, using the given scalar as a percent. iow, + * if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the result + * will be closer to the end value. The result is stored back in this color. + * + * @param beginColor + * @param endColor + * @param changeAmnt + * the scalar as a percent. + * @return this color for chaining + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public ColorRGBA lerpLocal(final ReadOnlyColorRGBA beginColor, final ReadOnlyColorRGBA endColor, final float scalar) { + setRed((1.0f - scalar) * beginColor.getRed() + scalar * endColor.getRed()); + setGreen((1.0f - scalar) * beginColor.getGreen() + scalar * endColor.getGreen()); + setBlue((1.0f - scalar) * beginColor.getBlue() + scalar * endColor.getBlue()); + setAlpha((1.0f - scalar) * beginColor.getAlpha() + scalar * endColor.getAlpha()); + return this; + } + + /** + * Check a color... if it is null or its values are NaN or infinite, return false. Else return true. + * + * @param color + * the color to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyColorRGBA color) { + if (color == null) { + return false; + } + if (Float.isNaN(color.getRed()) || Float.isNaN(color.getGreen()) || Float.isNaN(color.getBlue()) + || Float.isNaN(color.getAlpha())) { + return false; + } + if (Float.isInfinite(color.getRed()) || Float.isInfinite(color.getGreen()) || Float.isInfinite(color.getBlue()) + || Float.isInfinite(color.getAlpha())) { + return false; + } + return true; + } + + /** + * @return the string representation of this color. + */ + @Override + public String toString() { + return "com.ardor3d.math.ColorRGBA [R=" + getRed() + ", G=" + getGreen() + ", B=" + getBlue() + ", A=" + + getAlpha() + "]"; + } + + /** + * @return returns a unique code for this color object based on its values. If two colors are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + final int r = Float.floatToIntBits(getRed()); + result += 31 * result + r; + + final int g = Float.floatToIntBits(getGreen()); + result += 31 * result + g; + + final int b = Float.floatToIntBits(getBlue()); + result += 31 * result + b; + + final int a = Float.floatToIntBits(getAlpha()); + result += 31 * result + a; + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this color and the provided color have the same r, g, b and a values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyColorRGBA)) { + return false; + } + final ReadOnlyColorRGBA comp = (ReadOnlyColorRGBA) o; + return getRed() == comp.getRed() && getGreen() == comp.getGreen() && getBlue() == comp.getBlue() + && getAlpha() == comp.getAlpha(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public ColorRGBA clone() { + return new ColorRGBA(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends ColorRGBA> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(getRed(), "r", 1); + capsule.write(getGreen(), "g", 1); + capsule.write(getBlue(), "b", 1); + capsule.write(getAlpha(), "a", 1); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + setRed(capsule.readFloat("r", 1)); + setGreen(capsule.readFloat("g", 1)); + setBlue(capsule.readFloat("b", 1)); + setAlpha(capsule.readFloat("a", 1)); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setRed(in.readFloat()); + setGreen(in.readFloat()); + setBlue(in.readFloat()); + setAlpha(in.readFloat()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeFloat(getRed()); + out.writeFloat(getGreen()); + out.writeFloat(getBlue()); + out.writeFloat(getAlpha()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of ColorRGBA that is intended for temporary use in calculations and so forth. Multiple calls + * to the method should return instances of this class that are not currently in use. + */ + public final static ColorRGBA fetchTempInstance() { + if (MathConstants.useMathPools) { + return ColorRGBA.COLOR_POOL.fetch(); + } else { + return new ColorRGBA(); + } + } + + /** + * Releases a ColorRGBA back to be used by a future call to fetchTempInstance. TAKE CARE: this ColorRGBA object + * should no longer have other classes referencing it or "Bad Things" will happen. + * + * @param color + * the ColorRGBA to release. + */ + public final static void releaseTempInstance(final ColorRGBA color) { + if (MathConstants.useMathPools) { + ColorRGBA.COLOR_POOL.release(color); + } + } + + /** + * Parses the given string for a color value. Currently we support hex notation - # followed by 1, 2, 3, 4, 6, or 8 + * chars 0-9A-F. + * <ul> + * <li>chars: pattern - notes</li> + * <li>1: V - RGB is parsed as val/15, A=1</li> + * <li>2: VA - RGB is parsed as V/15, A as A/15</li> + * <li>3: RGB - RGB is parsed as R/15, G/15, B/15, A=1</li> + * <li>4: RGB - RGBA are parsed as R/15, G/15, B/15, A/15</li> + * <li>6: RRGGBB - RGB is parsed as RR/255, GG/255, BB/255, A=1</li> + * <li>8: RRGGBBAA - RGBA is parsed as RR/255, GG/255, BB/255, AA/255</li> + * </ul> + * + * @param colorString + * @param store + * @return + */ + public static ColorRGBA parseColor(final String colorString, final ColorRGBA store) { + ColorRGBA rVal = store; + if (rVal == null) { + rVal = new ColorRGBA(); + } + + // XXX: should we parse words too? eg 'red'... + if (!colorString.startsWith("#")) { + throw new IllegalArgumentException("must start with #."); + } + + float r = 1, g = 1, b = 1, a = 1; + final int length = colorString.length(); + if (length == 2) { + r = Integer.parseInt(colorString.substring(1, 2), 16) / 15f; + g = b = r; + a = 1; + } else if (length == 3) { + r = Integer.parseInt(colorString.substring(1, 2), 16) / 15f; + g = b = r; + a = Integer.parseInt(colorString.substring(2, 3), 16) / 15f; + } else if (length == 4) { + r = Integer.parseInt(colorString.substring(1, 2), 16) / 15f; + g = Integer.parseInt(colorString.substring(2, 3), 16) / 15f; + b = Integer.parseInt(colorString.substring(3, 4), 16) / 15f; + a = 1; + } else if (length == 5) { + r = Integer.parseInt(colorString.substring(1, 2), 16) / 15f; + g = Integer.parseInt(colorString.substring(2, 3), 16) / 15f; + b = Integer.parseInt(colorString.substring(3, 4), 16) / 15f; + a = Integer.parseInt(colorString.substring(4, 5), 16) / 15f; + } else if (length == 7) { + r = Integer.parseInt(colorString.substring(1, 3), 16) / 255f; + g = Integer.parseInt(colorString.substring(3, 5), 16) / 255f; + b = Integer.parseInt(colorString.substring(5, 7), 16) / 255f; + a = 1; + } else if (length == 9) { + r = Integer.parseInt(colorString.substring(1, 3), 16) / 255f; + g = Integer.parseInt(colorString.substring(3, 5), 16) / 255f; + b = Integer.parseInt(colorString.substring(5, 7), 16) / 255f; + a = Integer.parseInt(colorString.substring(7, 9), 16) / 255f; + } else { + throw new IllegalArgumentException("unsupported value, must be 1, 2, 3, 4, 5, 7 or 9 hexvalues: " + + colorString); + } + rVal.set(r, g, b, a); + + return rVal; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/FastMath.java b/ardor3d-math/src/main/java/com/ardor3d/math/FastMath.java new file mode 100644 index 0000000..6ef29eb --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/FastMath.java @@ -0,0 +1,93 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +/** + * A "close approximation" class for Math operations. + * + * References: + * <ul> + * <li>http://www.devmaster.net/forums/showthread.php?t=5784</li> + * <li>http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf</li> + * <li>http://stackoverflow.com/questions/523531/fast-transcendent-trigonometric-functions-for-java</li> + * <li>http://www.lightsoft.co.uk/PD/stu/stuchat37.html</li> + * <li>http://wiki.java.net/bin/view/Games/JeffGems</li> + * </ul> + * + * NB: With current improvements in hardware, I don't recommend using these and they will likely be deprecated/removed + * in the future. + */ +public enum FastMath { + ; + + public final static double EPSILON_SIN = 0.0011d; + public final static double EPSILON_COS = 0.0011d; + public final static double EPSILON_SIN2COS2 = 0.002d; + public final static double EPSILON_ASIN = 0.0014d; + public final static double EPSILON_ACOS = 0.0014d; + public final static double EPSILON_ATAN = 0.005d; // needs to be improved + public final static double EPSILON_SQRT = 0.025d; // guess + + private final static double _sin_a = -4 / MathUtils.SQUARED_PI; + private final static double _sin_b = 4 / MathUtils.PI; + private final static double _sin_p = 9d / 40; + + private final static double _asin_a = -0.0481295276831013447d; + private final static double _asin_b = -0.343835993947915197d; + private final static double _asin_c = 0.962761848425913169d; + private final static double _asin_d = 1.00138940860107040d; + + private final static double _atan_a = 0.280872d; + + /** sin: [-œÄ,œÄ] -> [-1,1] */ + public final static double sin(double x) { + x = FastMath._sin_a * x * Math.abs(x) + FastMath._sin_b * x; + return FastMath._sin_p * (x * Math.abs(x) - x) + x; + } + + /** cos: [-œÄ,œÄ] -> [-1,1] */ + public final static double cos(final double x) { + return sin(x + (x > MathUtils.HALF_PI ? -MathUtils.THREE_PI_HALVES : MathUtils.HALF_PI)); + } + + /** tan: [-œÄ,œÄ] \ {-œÄ/2,œÄ/2} -> R */ + public final static double tan(final double x) { + return sin(x) / cos(x); + } + + /** asin: [-1,1] -> [-œÄ/2,œÄ/2] */ + public final static double asin(final double x) { + return x * (Math.abs(x) * (Math.abs(x) * FastMath._asin_a + FastMath._asin_b) + FastMath._asin_c) + + Math.signum(x) * (FastMath._asin_d - Math.sqrt(1 - x * x)); + } + + /** acos: [-1,1] -> [0,œÄ] */ + public final static double acos(final double x) { + return MathUtils.HALF_PI - asin(x); + } + + /** atan: (-‚à û,‚à û) -> (-œÄ/2,œÄ/2) */ + public final static double atan(final double x) { + return Math.abs(x) < 1 ? x / (1 + FastMath._atan_a * x * x) : Math.signum(x) * MathUtils.HALF_PI - x + / (x * x + FastMath._atan_a); + } + + /** inverseSqrt: (0,‚à û) -> (0,‚à û) **/ + public final static double inverseSqrt(double x) { + final double xhalves = 0.5d * x; + x = Double.longBitsToDouble(0x5FE6EB50C7B537AAl - (Double.doubleToRawLongBits(x) >> 1)); + return x * (1.5d - xhalves * x * x); // more iterations possible + } + + public final static double sqrt(final double x) { + return x * inverseSqrt(x); + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/InvalidTransformException.java b/ardor3d-math/src/main/java/com/ardor3d/math/InvalidTransformException.java new file mode 100644 index 0000000..3d38c89 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/InvalidTransformException.java @@ -0,0 +1,23 @@ + +package com.ardor3d.math; + +public class InvalidTransformException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public InvalidTransformException() { + super(); + } + + public InvalidTransformException(final String desc) { + super(desc); + } + + public InvalidTransformException(final Throwable cause) { + super(cause); + } + + public InvalidTransformException(final String desc, final Throwable cause) { + super(desc, cause); + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Line3.java b/ardor3d-math/src/main/java/com/ardor3d/math/Line3.java new file mode 100644 index 0000000..453f48a --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Line3.java @@ -0,0 +1,171 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import com.ardor3d.math.type.ReadOnlyLine3; +import com.ardor3d.math.type.ReadOnlyVector3; + +public class Line3 extends Line3Base implements ReadOnlyLine3, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Line3> LINE3_POOL = ObjectPool.create(Line3.class, MathConstants.maxMathPoolSize); + + /** + * Constructs a new line with an origin at (0,0,0) and a direction of (0,0,1). + */ + public Line3() { + super(Vector3.ZERO, Vector3.UNIT_Z); + } + + /** + * Constructs a new line using the supplied origin point and unit length direction vector + * + * @param origin + * the origin of the line. + * @param direction + * the direction of the line. Should be of unit length. + */ + public Line3(final ReadOnlyVector3 origin, final ReadOnlyVector3 direction) { + super(origin, direction); + } + + /** + * Constructs a new line using the supplied source line + * + * @param source + */ + public Line3(final ReadOnlyLine3 source) { + super(source.getOrigin(), source.getDirection()); + } + + /** + * Copies the values of the given source line into this line. + * + * @param source + * @return this line for chaining + * @throws NullPointerException + * if source is null. + */ + public Line3 set(final ReadOnlyLine3 source) { + _origin.set(source.getOrigin()); + _direction.set(source.getDirection()); + return this; + } + + /** + * @param point + * @param store + * if not null, the closest point is stored in this param + * @return the squared distance from this line to the given point. + * @throws NullPointerException + * if the point is null. + */ + public double distanceSquared(final ReadOnlyVector3 point, final Vector3 store) { + final Vector3 vectorA = Vector3.fetchTempInstance(); + vectorA.set(point).subtractLocal(_origin); + + // Note: assumes direction is normalized + final double t0 = _direction.dot(vectorA); + // d = |P - (O + t*D)| + vectorA.set(_direction).multiplyLocal(t0); + vectorA.addLocal(_origin); + + // Save away the closest point if requested. + if (store != null) { + store.set(vectorA); + } + + point.subtract(vectorA, vectorA); + final double lSQ = vectorA.lengthSquared(); + Vector3.releaseTempInstance(vectorA); + return lSQ; + } + + /** + * Check a line... if it is null or the values of its origin or direction are NaN or infinite, return false. Else + * return true. + * + * @param line + * the line to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyLine3 line) { + if (line == null) { + return false; + } + + return Vector3.isValid(line.getDirection()) && Vector3.isValid(line.getOrigin()); + } + + /** + * @return the string representation of this line. + */ + @Override + public String toString() { + return "com.ardor3d.math.Line3 [Origin: " + _origin + " - Direction: " + _direction + "]"; + } + + /** + * @param o + * the object to compare for equality + * @return true if this line and the provided line have the same constant and normal values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyLine3)) { + return false; + } + final ReadOnlyLine3 comp = (ReadOnlyLine3) o; + return _origin.equals(comp.getOrigin()) && _direction.equals(comp.getDirection()); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Line3 clone() { + return new Line3(this); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Line3 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Line3 fetchTempInstance() { + if (MathConstants.useMathPools) { + return LINE3_POOL.fetch(); + } else { + return new Line3(); + } + } + + /** + * Releases a Line3 back to be used by a future call to fetchTempInstance. TAKE CARE: this Line3 object should no + * longer have other classes referencing it or "Bad Things" will happen. + * + * @param line + * the Line3 to release. + */ + public final static void releaseTempInstance(final Line3 line) { + if (MathConstants.useMathPools) { + LINE3_POOL.release(line); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Line3Base.java b/ardor3d-math/src/main/java/com/ardor3d/math/Line3Base.java new file mode 100644 index 0000000..25f34fa --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Line3Base.java @@ -0,0 +1,130 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+
+import com.ardor3d.math.type.ReadOnlyVector3;
+import com.ardor3d.util.export.InputCapsule;
+import com.ardor3d.util.export.OutputCapsule;
+import com.ardor3d.util.export.Savable;
+
+public abstract class Line3Base implements Savable, Externalizable {
+
+ protected final Vector3 _origin = new Vector3();
+ protected final Vector3 _direction = new Vector3();
+
+ public Line3Base(final ReadOnlyVector3 origin, final ReadOnlyVector3 direction) {
+ _origin.set(origin);
+ _direction.set(direction);
+ }
+
+ /**
+ * @return this line's origin point as a readable vector
+ */
+ public ReadOnlyVector3 getOrigin() {
+ return _origin;
+ }
+
+ /**
+ * @return this line's direction as a readable vector
+ */
+ public ReadOnlyVector3 getDirection() {
+ return _direction;
+ }
+
+ /**
+ * Sets the line's origin point to the values of the given vector.
+ *
+ * @param origin
+ * @throws NullPointerException
+ * if normal is null.
+ */
+ public void setOrigin(final ReadOnlyVector3 origin) {
+ _origin.set(origin);
+ }
+
+ /**
+ * Sets the line's direction to the values of the given vector.
+ *
+ * @param direction
+ * @throws NullPointerException
+ * if direction is null.
+ */
+ public void setDirection(final ReadOnlyVector3 direction) {
+ _direction.set(direction);
+ }
+
+ /**
+ * @return returns a unique code for this line3base object based on its values. If two line3base objects are
+ * numerically equal, they will return the same hash code value.
+ */
+ @Override
+ public int hashCode() {
+ int result = 17;
+
+ result += 31 * result + _origin.hashCode();
+ result += 31 * result + _direction.hashCode();
+
+ return result;
+ }
+
+ // /////////////////
+ // Methods for Savable
+ // /////////////////
+
+ public Class<? extends Line3Base> getClassTag() {
+ return this.getClass();
+ }
+
+ public void write(final OutputCapsule capsule) throws IOException {
+ capsule.write(_origin, "origin", new Vector3(Vector3.ZERO));
+ capsule.write(_direction, "direction", new Vector3(Vector3.UNIT_Z));
+ }
+
+ public void read(final InputCapsule capsule) throws IOException {
+ _origin.set((Vector3) capsule.readSavable("origin", new Vector3(Vector3.ZERO)));
+ _direction.set((Vector3) capsule.readSavable("direction", new Vector3(Vector3.UNIT_Z)));
+ }
+
+ // /////////////////
+ // Methods for Externalizable
+ // /////////////////
+
+ /**
+ * Used with serialization. Not to be called manually.
+ *
+ * @param in
+ * ObjectInput
+ * @throws IOException
+ * @throws ClassNotFoundException
+ */
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ setOrigin((Vector3) in.readObject());
+ setDirection((Vector3) in.readObject());
+ }
+
+ /**
+ * Used with serialization. Not to be called manually.
+ *
+ * @param out
+ * ObjectOutput
+ * @throws IOException
+ */
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ out.writeObject(_origin);
+ out.writeObject(_direction);
+ }
+
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/LineSegment3.java b/ardor3d-math/src/main/java/com/ardor3d/math/LineSegment3.java new file mode 100644 index 0000000..aa62875 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/LineSegment3.java @@ -0,0 +1,334 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyLineSegment3; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; + +/** + * LineSegment describes a line with a discrete length with an "origin" in the center, extending in the given + * "direction" and it's opposite by an "extent" amount. + */ +public class LineSegment3 extends Line3Base implements ReadOnlyLineSegment3, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<LineSegment3> LINESEG3_POOL = ObjectPool.create(LineSegment3.class, + MathConstants.maxMathPoolSize); + + protected double _extent; + + /** + * Constructs a new segment segment with an origin at (0,0,0) a direction of (0,0,1) and an extent of 0.5. + */ + public LineSegment3() { + super(Vector3.ZERO, Vector3.UNIT_Z); + _extent = 0.5; + } + + /** + * Copy constructor. + * + * @param source + * the line segment to copy from. + */ + public LineSegment3(final ReadOnlyLineSegment3 source) { + this(source.getOrigin(), source.getDirection(), source.getExtent()); + } + + /** + * Constructs a new segment segment using the supplied origin point, unit length direction vector and extent + * + * @param origin + * @param direction + * - unit length + * @param extent + */ + public LineSegment3(final ReadOnlyVector3 origin, final ReadOnlyVector3 direction, final double extent) { + super(origin, direction); + _extent = extent; + } + + /** + * Constructs a new segment segment using the supplied start and end points + * + * @param start + * @param end + */ + public LineSegment3(final ReadOnlyVector3 start, final ReadOnlyVector3 end) { + this(); + _origin.set(start).addLocal(end).multiplyLocal(0.5); + _direction.set(end).subtractLocal(start); + _extent = 0.5 * _direction.length(); + _direction.normalizeLocal(); + } + + /** + * Copies the values of the given source segment into this segment. + * + * @param source + * @return this segment for chaining + * @throws NullPointerException + * if source is null. + */ + public LineSegment3 set(final ReadOnlyLineSegment3 source) { + _origin.set(source.getOrigin()); + _direction.set(source.getDirection()); + return this; + } + + /** + * @return this segment's extent value + */ + @Override + public double getExtent() { + return _extent; + } + + /** + * Sets the segment's extent to the provided value. + * + * @param extent + */ + public void setExtent(final double extent) { + _extent = extent; + } + + public Vector3 getPositiveEnd(final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(getDirection()).multiplyLocal(_extent); + result.addLocal(getOrigin()); + return result; + } + + public Vector3 getNegativeEnd(final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(getDirection()).multiplyLocal(-_extent); + result.addLocal(getOrigin()); + return result; + } + + /** + * @param point + * @param store + * if not null, the closest point is stored in this param + * @return the squared distance from this segment to the given point. + * @throws NullPointerException + * if the point is null. + */ + @Override + public double distanceSquared(final ReadOnlyVector3 point, final Vector3 store) { + final Vector3 vectorA = Vector3.fetchTempInstance(); + vectorA.set(point).subtractLocal(_origin); + + // Note: assumes direction is normalized + final double t0 = _direction.dot(vectorA); + + if (-_extent < t0) { + if (t0 < _extent) { + // d = |P - (O + t*D)| + vectorA.set(getDirection()).multiplyLocal(t0); + vectorA.addLocal(getOrigin()); + } else { + // ray is closest to positive (end) end point + getPositiveEnd(vectorA); + } + } else { + // ray is closest to negative (start) end point + getNegativeEnd(vectorA); + } + + // Save away the closest point if requested. + if (store != null) { + store.set(vectorA); + } + + point.subtract(vectorA, vectorA); + final double lSQ = vectorA.lengthSquared(); + Vector3.releaseTempInstance(vectorA); + return lSQ; + } + + /** + * + * @param position + * a random position lying somewhere on this line segment. + */ + public Vector3 random(final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + final double rand = MathUtils.nextRandomDouble(); + + result.setX(2 * _extent * getOrigin().getX() * (1 - rand) + getDirection().getX() * _extent * (2 * rand - 1)); + result.setY(2 * _extent * getOrigin().getY() * (1 - rand) + getDirection().getY() * _extent * (2 * rand - 1)); + result.setZ(2 * _extent * getOrigin().getZ() * (1 - rand) + getDirection().getZ() * _extent * (2 * rand - 1)); + + return result; + } + + /** + * Check a segment... if it is null or the values of its origin or direction or extent are NaN or infinite, return + * false. Else return true. + * + * @param segment + * the segment to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyLineSegment3 segment) { + if (segment == null) { + return false; + } + + return Vector3.isValid(segment.getDirection()) && Vector3.isValid(segment.getOrigin()) + && !Double.isInfinite(segment.getExtent()) && !Double.isNaN(segment.getExtent()); + } + + /** + * @return the string representation of this segment. + */ + @Override + public String toString() { + return "com.ardor3d.math.LineSegment3 [Origin: " + _origin + " - Direction: " + _direction + " - Extent: " + + _extent + "]"; + } + + /** + * @param o + * the object to compare for equality + * @return true if this segment and the provided segment have the same constant and normal values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyLineSegment3)) { + return false; + } + final ReadOnlyLineSegment3 comp = (ReadOnlyLineSegment3) o; + return _origin.equals(comp.getOrigin()) && _direction.equals(comp.getDirection()) + && _extent == comp.getExtent(); + } + + /** + * @return returns a unique code for this segment object based on its values. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _origin.hashCode(); + result += 31 * result + _direction.hashCode(); + final long ex = Double.doubleToLongBits(_extent); + result += 31 * result + (int) (ex ^ ex >>> 32); + + return result; + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public LineSegment3 clone() { + return new LineSegment3(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public void write(final OutputCapsule capsule) throws IOException { + super.write(capsule); + capsule.write(_extent, "extent", 0.0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + super.read(capsule); + _extent = capsule.readDouble("extent", 0.0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + super.readExternal(in); + _extent = in.readDouble(); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + super.writeExternal(out); + out.writeDouble(_extent); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of LineSegment3 that is intended for temporary use in calculations and so forth. Multiple + * calls to the method should return instances of this class that are not currently in use. + */ + public final static LineSegment3 fetchTempInstance() { + if (MathConstants.useMathPools) { + return LineSegment3.LINESEG3_POOL.fetch(); + } else { + return new LineSegment3(); + } + } + + /** + * Releases a LineSegment3 back to be used by a future call to fetchTempInstance. TAKE CARE: this LineSegment3 + * object should no longer have other classes referencing it or "Bad Things" will happen. + * + * @param segment + * the LineSegment3 to release. + */ + public final static void releaseTempInstance(final LineSegment3 segment) { + if (MathConstants.useMathPools) { + LineSegment3.LINESEG3_POOL.release(segment); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/MathConstants.java b/ardor3d-math/src/main/java/com/ardor3d/math/MathConstants.java new file mode 100644 index 0000000..ef518b3 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/MathConstants.java @@ -0,0 +1,45 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math;
+
+/**
+ * Just a simple flag holder for runtime stripping of various ardor3d logging and debugging features.
+ */
+public class MathConstants {
+
+ public static final boolean useMathPools;
+
+ public static final boolean useFastMath;
+
+ public static final int maxMathPoolSize;
+
+ static {
+ boolean hasPropertyAccess = true;
+ try {
+ if (System.getSecurityManager() != null) {
+ System.getSecurityManager().checkPropertiesAccess();
+ }
+ } catch (final SecurityException e) {
+ hasPropertyAccess = false;
+ }
+
+ if (hasPropertyAccess) {
+ useMathPools = (System.getProperty("ardor3d.noMathPools") == null);
+ useFastMath = (System.getProperty("ardor3d.useFastMath") != null);
+ maxMathPoolSize = (System.getProperty("ardor3d.maxMathPoolSize") != null ? Integer.parseInt(System
+ .getProperty("ardor3d.maxMathPoolSize")) : 11);
+ } else {
+ useMathPools = true;
+ useFastMath = false;
+ maxMathPoolSize = 11;
+ }
+ }
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/MathUtils.java b/ardor3d-math/src/main/java/com/ardor3d/math/MathUtils.java new file mode 100644 index 0000000..02a745f --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/MathUtils.java @@ -0,0 +1,570 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.util.Random; + +import com.ardor3d.math.type.ReadOnlyVector3; + +public class MathUtils { + + /** A "close to zero" double epsilon value for use */ + public static final double EPSILON = 2.220446049250313E-16d; + + /** A "close to zero" double epsilon value for use */ + public static final double ZERO_TOLERANCE = 0.0001; + + public static final double ONE_THIRD = 1.0 / 3.0; + + /** The value PI as a double. (180 degrees) */ + public static final double PI = Math.PI; + + /** The value PI^2 as a double. */ + public final static double SQUARED_PI = MathUtils.PI * MathUtils.PI; + + /** The value 2PI as a double. (360 degrees) */ + public static final double TWO_PI = 2.0 * MathUtils.PI; + + /** The value PI/2 as a double. (90 degrees) */ + public static final double HALF_PI = 0.5 * MathUtils.PI; + + /** The value PI/4 as a double. (45 degrees) */ + public static final double QUARTER_PI = 0.25 * MathUtils.PI; + + /** The value 3/4 PI as a double. (135 degrees) */ + public final static double THREE_PI_HALVES = MathUtils.TWO_PI - MathUtils.HALF_PI; + + /** The value 1/PI as a double. */ + public static final double INV_PI = 1.0 / MathUtils.PI; + + /** The value 1/(2PI) as a double. */ + public static final double INV_TWO_PI = 1.0 / MathUtils.TWO_PI; + + /** A value to multiply a degree value by, to convert it to radians. */ + public static final double DEG_TO_RAD = MathUtils.PI / 180.0; + + /** A value to multiply a radian value by, to convert it to degrees. */ + public static final double RAD_TO_DEG = 180.0 / MathUtils.PI; + + /** A precreated random object for random numbers. */ + public static final Random rand = new Random(System.currentTimeMillis()); + + /** + * Fast Trig functions for x86. This forces the trig functiosn to stay within the safe area on the x86 processor + * (-45 degrees to +45 degrees) The results may be very slightly off from what the Math and StrictMath trig + * functions give due to rounding in the angle reduction but it will be very very close. + * + * note: code from wiki posting on java.net by jeffpk + */ + private static double reduceSinAngle(double radians) { + radians %= MathUtils.TWO_PI; // put us in -2PI to +2PI space + if (Math.abs(radians) > MathUtils.PI) { // put us in -PI to +PI space + radians = radians - MathUtils.TWO_PI; + } + if (Math.abs(radians) > MathUtils.HALF_PI) {// put us in -PI/2 to +PI/2 space + radians = MathUtils.PI - radians; + } + + return radians; + } + + /** + * Returns sine of a value. + * + * note: code from wiki posting on java.net by jeffpk + * + * @param dValue + * The value to sine, in radians. + * @return The sine of dValue. + * @see java.lang.Math#sin(double) + */ + public static double sin(double dValue) { + dValue = reduceSinAngle(dValue); // limits angle to between -PI/2 and +PI/2 + if (Math.abs(dValue) <= MathUtils.QUARTER_PI) { + return MathConstants.useFastMath ? FastMath.sin(dValue) : Math.sin(dValue); + } + + return MathConstants.useFastMath ? FastMath.cos(MathUtils.HALF_PI - dValue) : Math.cos(MathUtils.HALF_PI + - dValue); + } + + /** + * Returns cos of a value. + * + * @param dValue + * The value to cosine, in radians. + * @return The cosine of dValue. + * @see java.lang.Math#cos(double) + */ + public static double cos(final double dValue) { + return sin(dValue + MathUtils.HALF_PI); + } + + public static double sqrt(final double dValue) { + return MathConstants.useFastMath ? FastMath.sqrt(dValue) : Math.sqrt(dValue); + } + + public static double inverseSqrt(final double dValue) { + return MathConstants.useFastMath ? FastMath.inverseSqrt(dValue) : 1 / Math.sqrt(dValue); + } + + public static double atan(final double dValue) { + return MathConstants.useFastMath ? FastMath.atan(dValue) : Math.atan(dValue); + } + + public static double asin(final double dValue) { + return MathConstants.useFastMath ? FastMath.asin(dValue) : Math.asin(dValue); + } + + public static double tan(final double dValue) { + return MathConstants.useFastMath ? FastMath.tan(dValue) : Math.tan(dValue); + } + + public static double acos(final double dValue) { + return MathConstants.useFastMath ? FastMath.acos(dValue) : Math.acos(dValue); + } + + /** + * Converts a point from Spherical coordinates to Cartesian (using positive Y as up) and stores the results in the + * store var. + * + * @param sphereCoords + * (Radius, Azimuth, Polar) + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + */ + public static Vector3 sphericalToCartesian(final ReadOnlyVector3 sphereCoords, final Vector3 store) { + final double a = sphereCoords.getX() * cos(sphereCoords.getZ()); + final double x = a * cos(sphereCoords.getY()); + final double y = sphereCoords.getX() * sin(sphereCoords.getZ()); + final double z = a * sin(sphereCoords.getY()); + + Vector3 rVal = store; + if (rVal == null) { + rVal = new Vector3(); + } + return rVal.set(x, y, z); + } + + /** + * Converts a point from Cartesian coordinates (using positive Y as up) to Spherical and stores the results in the + * store var. (Radius, Azimuth, Polar) + * + * @param cartCoords + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + */ + public static Vector3 cartesianToSpherical(final ReadOnlyVector3 cartCoords, final Vector3 store) { + final double cartX = Math.abs(cartCoords.getX()) <= MathUtils.EPSILON ? MathUtils.EPSILON : cartCoords.getX(); + final double cartY = cartCoords.getY(); + final double cartZ = cartCoords.getZ(); + + final double x = sqrt(cartX * cartX + cartY * cartY + cartZ * cartZ); + final double y = atan(cartZ / cartX) + (cartX < 0.0 ? MathUtils.PI : 0); + final double z = asin(cartY / x); + + Vector3 rVal = store; + if (rVal == null) { + rVal = new Vector3(); + } + return rVal.set(x, y, z); + } + + /** + * Converts a point from Spherical coordinates to Cartesian (using positive Z as up) and stores the results in the + * store var. + * + * @param sphereCoords + * (Radius, Azimuth, Polar) + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + */ + public static Vector3 sphericalToCartesianZ(final ReadOnlyVector3 sphereCoords, final Vector3 store) { + final double a = sphereCoords.getX() * cos(sphereCoords.getZ()); + final double x = a * cos(sphereCoords.getY()); + final double y = a * sin(sphereCoords.getY()); + final double z = sphereCoords.getX() * sin(sphereCoords.getZ()); + + Vector3 rVal = store; + if (rVal == null) { + rVal = new Vector3(); + } + return rVal.set(x, y, z); + } + + /** + * Converts a point from Cartesian coordinates (using positive Z as up) to Spherical and stores the results in the + * store var. (Radius, Azimuth, Polar) + * + * @param cartCoords + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + */ + public static Vector3 cartesianZToSpherical(final ReadOnlyVector3 cartCoords, final Vector3 store) { + final double cartX = Math.abs(cartCoords.getX()) <= MathUtils.EPSILON ? MathUtils.EPSILON : cartCoords.getX(); + final double cartY = cartCoords.getY(); + final double cartZ = cartCoords.getZ(); + + final double x = sqrt(cartX * cartX + cartY * cartY + cartZ * cartZ); + final double y = asin(cartY / x); + final double z = atan(cartZ / cartX) + (cartX < 0.0 ? MathUtils.PI : 0); + + Vector3 rVal = store; + if (rVal == null) { + rVal = new Vector3(); + } + return rVal.set(x, y, z); + } + + /** + * Returns true if the number is a power of 2 (2,4,8,16...) + * + * A good implementation found on the Java boards. note: a number is a power of two if and only if it is the + * smallest number with that number of significant bits. Therefore, if you subtract 1, you know that the new number + * will have fewer bits, so ANDing the original number with anything less than it will give 0. + * + * @param number + * The number to test. + * @return True if it is a power of two. + */ + public static boolean isPowerOfTwo(final int number) { + return number > 0 && (number & number - 1) == 0; + } + + /** + * @param number + * @return the closest power of two to the given number. + */ + public static int nearestPowerOfTwo(final int number) { + return (int) Math.pow(2, Math.ceil(Math.log(number) / Math.log(2))); + } + + /** + * @param value + * @param base + * @return the logarithm of value with given base, calculated as log(value)/log(base) such that pow(base, + * return)==value + */ + public static double log(final double value, final double base) { + return Math.log(value) / Math.log(base); + } + + /** + * Sets the seed to use for "random" operations. The default is the current system milliseconds. + * + * @param seed + */ + public static void setRandomSeed(final long seed) { + MathUtils.rand.setSeed(seed); + } + + /** + * Returns a random double between 0 and 1. + * + * @return A random double between <tt>0.0</tt> (inclusive) to <tt>1.0</tt> (exclusive). + */ + public static double nextRandomDouble() { + return MathUtils.rand.nextDouble(); + } + + /** + * Returns a random float between 0 and 1. + * + * @return A random float between <tt>0.0f</tt> (inclusive) to <tt>1.0f</tt> (exclusive). + */ + public static float nextRandomFloat() { + return MathUtils.rand.nextFloat(); + } + + /** + * @return A random int between Integer.MIN_VALUE and Integer.MAX_VALUE. + */ + public static int nextRandomInt() { + return MathUtils.rand.nextInt(); + } + + /** + * Returns a random int between min and max. + * + * @return A random int between <tt>min</tt> (inclusive) to <tt>max</tt> (inclusive). + */ + public static int nextRandomInt(final int min, final int max) { + return (int) (nextRandomFloat() * (max - min + 1)) + min; + } + + /** + * + * @param percent + * @param startValue + * @param endValue + * @return + */ + public static float lerp(final float percent, final float startValue, final float endValue) { + if (startValue == endValue) { + return startValue; + } + return (1 - percent) * startValue + percent * endValue; + } + + /** + * + * @param percent + * @param startValue + * @param endValue + * @return + */ + public static double lerp(final double percent, final double startValue, final double endValue) { + if (startValue == endValue) { + return startValue; + } + return (1 - percent) * startValue + percent * endValue; + } + + /** + * plot a given value on the cubic S-curve: 3t^2 - 2t^3 + * + * @param t + * our input value + * @return the plotted value + */ + public static float scurve3(final float t) { + final float t2 = t * t; + final float t3 = t * t2; + return 3f * t2 - 2f * t3; + } + + /** + * plot a given value on the cubic S-curve: 3t^2 - 2t^3 + * + * @param t + * our input value + * @return the plotted value + */ + public static double scurve3(final double t) { + final double t2 = t * t; + final double t3 = t * t2; + return 3. * t2 - 2. * t3; + } + + /** + * plot a given value on the quintic S-curve: 6t^5 - 15t^4 + 10t^3 + * + * @param t + * our input value + * @return the plotted value + */ + public static float scurve5(final float t) { + final float t3 = t * t * t; + final float t4 = t * t3; + final float t5 = t * t4; + return 6f * t5 - 15f * t4 + 10f * t3; + } + + /** + * plot a given value on the quintic S-curve: 6t^5 - 15t^4 + 10t^3 + * + * @param t + * our input value + * @return the plotted value + */ + public static double scurve5(final double t) { + final double t3 = t * t * t; + final double t4 = t * t3; + final double t5 = t * t4; + return 6. * t5 - 15. * t4 + 10. * t3; + } + + /** + * + * @param left + * @param right + * @param bottom + * @param top + * @param nearZ + * @param farZ + * @param store + */ + public static void matrixFrustum(final double left, final double right, final double bottom, final double top, + final double nearZ, final double farZ, final Matrix4 store) { + final double x = 2.0 * nearZ / (right - left); + final double y = 2.0 * nearZ / (top - bottom); + final double a = (right + left) / (right - left); + final double b = (top + bottom) / (top - bottom); + final double c = -(farZ + nearZ) / (farZ - nearZ); + final double d = -(2.0 * farZ * nearZ) / (farZ - nearZ); + + store.set(x, 0.0, 0.0, 0.0, 0.0, y, 0.0, 0.0, a, b, c, -1.0, 0.0, 0.0, d, 0.0); + } + + /** + * + * @param left + * @param right + * @param bottom + * @param top + * @param nearZ + * @param farZ + * @param store + */ + public static void matrixOrtho(final double left, final double right, final double bottom, final double top, + final double nearZ, final double farZ, final Matrix4 store) { + store.set(2.0 / (right - left), 0.0, 0.0, 0.0, 0.0, 2.0 / (top - bottom), 0.0, 0.0, 0.0, 0.0, -2.0 + / (farZ - nearZ), 0.0, -(right + left) / (right - left), -(top + bottom) / (top - bottom), + -(farZ + nearZ) / (farZ - nearZ), 1.0); + } + + /** + * + * @param fovY + * @param aspect + * @param zNear + * @param zFar + * @param store + */ + public static void matrixPerspective(final double fovY, final double aspect, final double zNear, final double zFar, + final Matrix4 store) { + final double height = zNear * tan(fovY * 0.5 * MathUtils.DEG_TO_RAD); + final double width = height * aspect; + + matrixFrustum(-width, width, -height, height, zNear, zFar, store); + } + + /** + * + * @param position + * @param target + * @param up + * @param store + */ + public static void matrixLookAt(final ReadOnlyVector3 position, final ReadOnlyVector3 target, + final ReadOnlyVector3 worldUp, final Matrix4 store) { + final Vector3 direction = Vector3.fetchTempInstance(); + final Vector3 side = Vector3.fetchTempInstance(); + final Vector3 up = Vector3.fetchTempInstance(); + + direction.set(target).subtractLocal(position).normalizeLocal(); + direction.cross(worldUp, side).normalizeLocal(); + side.cross(direction, up); + + store.set(side.getX(), up.getX(), -direction.getX(), 0.0, side.getY(), up.getY(), -direction.getY(), 0.0, + side.getZ(), up.getZ(), -direction.getZ(), 0.0, side.getX() * -position.getX() + side.getY() + * -position.getY() + side.getZ() * -position.getZ(), up.getX() * -position.getX() + up.getY() + * -position.getY() + up.getZ() * -position.getZ(), -direction.getX() * -position.getX() + + -direction.getY() * -position.getY() + -direction.getZ() * -position.getZ(), 1.0); + + Vector3.releaseTempInstance(up); + Vector3.releaseTempInstance(side); + Vector3.releaseTempInstance(direction); + } + + /** + * + * @param position + * @param target + * @param up + * @param store + */ + public static void matrixLookAt(final ReadOnlyVector3 position, final ReadOnlyVector3 target, + final ReadOnlyVector3 worldUp, final Matrix3 store) { + final Vector3 direction = Vector3.fetchTempInstance(); + final Vector3 side = Vector3.fetchTempInstance(); + final Vector3 up = Vector3.fetchTempInstance(); + + direction.set(target).subtractLocal(position).normalizeLocal(); + direction.cross(worldUp, side).normalizeLocal(); + side.cross(direction, up); + + store.set(side.getX(), up.getX(), -direction.getX(), side.getY(), up.getY(), -direction.getY(), side.getZ(), + up.getZ(), -direction.getZ()); + + Vector3.releaseTempInstance(up); + Vector3.releaseTempInstance(side); + Vector3.releaseTempInstance(direction); + } + + /** + * Faster floor function. Does not handle NaN and Infinity. (Not handled when doing Math.floor and just casting + * anyways, so question is if we want to handle it or not) + * + * @param val + * Value to floor + * @return Floored int value + */ + public static int floor(final float val) { + final int intVal = (int) val; + return val < 0 ? val == intVal ? intVal : intVal - 1 : intVal; + } + + /** + * Faster floor function. Does not handle NaN and Infinity. (Not handled when doing Math.floor and just casting + * anyways, so question is if we want to handle it or not) + * + * @param val + * Value to floor + * @return Floored long value + */ + public static long floor(final double val) { + final long longVal = (long) val; + return val < 0 ? val == longVal ? longVal : longVal - 1 : longVal; + } + + public static int round(final float val) { + return floor(val + 0.5f); + } + + public static long round(final double val) { + return floor(val + 0.5d); + } + + public static double clamp(final double val, final double min, final double max) { + return val < min ? min : val > max ? max : val; + } + + public static float clamp(final float val, final float min, final float max) { + return val < min ? min : val > max ? max : val; + } + + public static int clamp(final int val, final int min, final int max) { + return val < min ? min : val > max ? max : val; + } + + public static int moduloPositive(final int value, final int size) { + int wrappedValue = value % size; + wrappedValue += wrappedValue < 0 ? size : 0; + return wrappedValue; + } + + public static float moduloPositive(final float value, final float size) { + float wrappedValue = value % size; + wrappedValue += wrappedValue < 0 ? size : 0; + return wrappedValue; + } + + public static double moduloPositive(final double value, final double size) { + double wrappedValue = value % size; + wrappedValue += wrappedValue < 0 ? size : 0; + return wrappedValue; + } + + /** + * Simple 2^x + * + * @param x + * power + * @return 2^x + */ + public static int pow2(final int x) { + if (x <= 0) { + return 1; + } + return 2 << x - 1; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Matrix3.java b/ardor3d-math/src/main/java/com/ardor3d/math/Matrix3.java new file mode 100644 index 0000000..a13ddc4 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Matrix3.java @@ -0,0 +1,1959 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.nio.BufferOverflowException; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import com.ardor3d.math.type.ReadOnlyMatrix3; +import com.ardor3d.math.type.ReadOnlyQuaternion; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Matrix3 represents a double precision 3x3 matrix. + * + * Note: some algorithms in this class were ported from Eberly, Wolfram, Game Gems and others to Java. + */ +public class Matrix3 implements Cloneable, Savable, Externalizable, ReadOnlyMatrix3, Poolable { + + /** Used with equals method to determine if two Matrix3 objects are close enough to be considered equal. */ + public static final double ALLOWED_DEVIANCE = 0.00000001; + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Matrix3> MAT_POOL = ObjectPool.create(Matrix3.class, MathConstants.maxMathPoolSize); + + /** + * <pre> + * 1, 0, 0 + * 0, 1, 0 + * 0, 0, 1 + * </pre> + */ + public final static ReadOnlyMatrix3 IDENTITY = new Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1); + + protected double _m00, _m01, _m02, // + _m10, _m11, _m12, // + _m20, _m21, _m22; + + /** + * Constructs a new, mutable matrix set to identity. + */ + public Matrix3() { + this(Matrix3.IDENTITY); + } + + /** + * Constructs a new, mutable matrix using the given matrix values (names are mRC = m[ROW][COL]) + * + * @param m00 + * @param m01 + * @param m02 + * @param m10 + * @param m11 + * @param m12 + * @param m20 + * @param m21 + * @param m22 + */ + public Matrix3(final double m00, final double m01, final double m02, final double m10, final double m11, + final double m12, final double m20, final double m21, final double m22) { + + _m00 = m00; + _m01 = m01; + _m02 = m02; + _m10 = m10; + _m11 = m11; + _m12 = m12; + _m20 = m20; + _m21 = m21; + _m22 = m22; + } + + /** + * Constructs a new, mutable matrix using the values from the given matrix + * + * @param source + */ + public Matrix3(final ReadOnlyMatrix3 source) { + set(source); + } + + /** + * @param row + * @param column + * @return the value stored in this matrix at row, column. + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 2] + */ + @Override + public double getValue(final int row, final int column) { + switch (row) { + case 0: + switch (column) { + case 0: + return _m00; + case 1: + return _m01; + case 2: + return _m02; + } + break; + case 1: + switch (column) { + case 0: + return _m10; + case 1: + return _m11; + case 2: + return _m12; + } + break; + + case 2: + switch (column) { + case 0: + return _m20; + case 1: + return _m21; + case 2: + return _m22; + } + break; + } + throw new IllegalArgumentException(); + } + + /** + * @param row + * @param column + * @return the value stored in this matrix at row, column, pre-cast to a float for convenience. + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 2] + */ + @Override + public float getValuef(final int row, final int column) { + return (float) getValue(row, column); + } + + @Override + public double getM00() { + return _m00; + } + + @Override + public double getM01() { + return _m01; + } + + @Override + public double getM02() { + return _m02; + } + + @Override + public double getM10() { + return _m10; + } + + @Override + public double getM11() { + return _m11; + } + + @Override + public double getM12() { + return _m12; + } + + @Override + public double getM20() { + return _m20; + } + + @Override + public double getM21() { + return _m21; + } + + @Override + public double getM22() { + return _m22; + } + + public void setM00(final double m00) { + _m00 = m00; + } + + public void setM01(final double m01) { + _m01 = m01; + } + + public void setM02(final double m02) { + _m02 = m02; + } + + public void setM10(final double m10) { + _m10 = m10; + } + + public void setM11(final double m11) { + _m11 = m11; + } + + public void setM12(final double m12) { + _m12 = m12; + } + + public void setM20(final double m20) { + _m20 = m20; + } + + public void setM21(final double m21) { + _m21 = m21; + } + + public void setM22(final double m22) { + _m22 = m22; + } + + /** + * Same as set(IDENTITY) + * + * @return this matrix for chaining + */ + public Matrix3 setIdentity() { + return set(Matrix3.IDENTITY); + } + + /** + * @return true if this matrix equals the 3x3 identity matrix + */ + @Override + public boolean isIdentity() { + return strictEquals(Matrix3.IDENTITY); + } + + /** + * Sets the value of this matrix at row, column to the given value. + * + * @param row + * @param column + * @param value + * @return this matrix for chaining + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 2] + */ + public Matrix3 setValue(final int row, final int column, final double value) { + switch (row) { + case 0: + switch (column) { + case 0: + _m00 = value; + break; + case 1: + _m01 = value; + break; + case 2: + _m02 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + case 1: + switch (column) { + case 0: + _m10 = value; + break; + case 1: + _m11 = value; + break; + case 2: + _m12 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + case 2: + switch (column) { + case 0: + _m20 = value; + break; + case 1: + _m21 = value; + break; + case 2: + _m22 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + default: + throw new IllegalArgumentException(); + } + + return this; + } + + /** + * Sets the values of this matrix to the values given. + * + * @param m00 + * @param m01 + * @param m02 + * @param m10 + * @param m11 + * @param m12 + * @param m20 + * @param m21 + * @param m22 + * @return this matrix for chaining + */ + public Matrix3 set(final double m00, final double m01, final double m02, final double m10, final double m11, + final double m12, final double m20, final double m21, final double m22) { + + _m00 = m00; + _m01 = m01; + _m02 = m02; + _m10 = m10; + _m11 = m11; + _m12 = m12; + _m20 = m20; + _m21 = m21; + _m22 = m22; + + return this; + } + + /** + * Sets the values of this matrix to the values of the provided source matrix. + * + * @param source + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + */ + public Matrix3 set(final ReadOnlyMatrix3 source) { + _m00 = source.getM00(); + _m10 = source.getM10(); + _m20 = source.getM20(); + + _m01 = source.getM01(); + _m11 = source.getM11(); + _m21 = source.getM21(); + + _m02 = source.getM02(); + _m12 = source.getM12(); + _m22 = source.getM22(); + + return this; + } + + /** + * Sets the values of this matrix to the rotational value of the given quaternion. + * + * @param quaternion + * @return this matrix for chaining + */ + public Matrix3 set(final ReadOnlyQuaternion quaternion) { + return quaternion.toRotationMatrix(this); + } + + /** + * @param source + * the buffer to read our matrix data from. + * @return this matrix for chaining. + */ + public Matrix3 fromDoubleBuffer(final DoubleBuffer source) { + return fromDoubleBuffer(source, true); + } + + /** + * @param source + * the buffer to read our matrix data from. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return this matrix for chaining. + */ + public Matrix3 fromDoubleBuffer(final DoubleBuffer source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source.get(); + _m01 = source.get(); + _m02 = source.get(); + _m10 = source.get(); + _m11 = source.get(); + _m12 = source.get(); + _m20 = source.get(); + _m21 = source.get(); + _m22 = source.get(); + } else { + _m00 = source.get(); + _m10 = source.get(); + _m20 = source.get(); + _m01 = source.get(); + _m11 = source.get(); + _m21 = source.get(); + _m02 = source.get(); + _m12 = source.get(); + _m22 = source.get(); + } + + return this; + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to read our matrix data from. + * @return this matrix for chaining. + */ + public Matrix3 fromFloatBuffer(final FloatBuffer source) { + return fromFloatBuffer(source, true); + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to read our matrix data from. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return this matrix for chaining. + */ + public Matrix3 fromFloatBuffer(final FloatBuffer source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source.get(); + _m01 = source.get(); + _m02 = source.get(); + _m10 = source.get(); + _m11 = source.get(); + _m12 = source.get(); + _m20 = source.get(); + _m21 = source.get(); + _m22 = source.get(); + } else { + _m00 = source.get(); + _m10 = source.get(); + _m20 = source.get(); + _m01 = source.get(); + _m11 = source.get(); + _m21 = source.get(); + _m02 = source.get(); + _m12 = source.get(); + _m22 = source.get(); + } + + return this; + } + + /** + * Sets the values of this matrix to the values of the provided double array. + * + * @param source + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + * @throws ArrayIndexOutOfBoundsException + * if source array has a length less than 9. + */ + public Matrix3 fromArray(final double[] source) { + return fromArray(source, true); + } + + /** + * Sets the values of this matrix to the values of the provided double array. + * + * @param source + * @param rowMajor + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + * @throws ArrayIndexOutOfBoundsException + * if source array has a length less than 9. + */ + public Matrix3 fromArray(final double[] source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source[0]; + _m01 = source[1]; + _m02 = source[2]; + _m10 = source[3]; + _m11 = source[4]; + _m12 = source[5]; + _m20 = source[6]; + _m21 = source[7]; + _m22 = source[8]; + } else { + _m00 = source[0]; + _m10 = source[1]; + _m20 = source[2]; + _m01 = source[3]; + _m11 = source[4]; + _m21 = source[5]; + _m02 = source[6]; + _m12 = source[7]; + _m22 = source[8]; + } + return this; + } + + /** + * Replaces a column in this matrix with the values of the given vector. + * + * @param columnIndex + * @param columnData + * @return this matrix for chaining + * @throws NullPointerException + * if columnData is null. + * @throws IllegalArgumentException + * if columnIndex is not in [0, 2] + */ + public Matrix3 setColumn(final int columnIndex, final ReadOnlyVector3 columnData) { + switch (columnIndex) { + case 0: + _m00 = columnData.getX(); + _m10 = columnData.getY(); + _m20 = columnData.getZ(); + break; + case 1: + _m01 = columnData.getX(); + _m11 = columnData.getY(); + _m21 = columnData.getZ(); + break; + case 2: + _m02 = columnData.getX(); + _m12 = columnData.getY(); + _m22 = columnData.getZ(); + break; + default: + throw new IllegalArgumentException("Bad columnIndex: " + columnIndex); + } + return this; + } + + /** + * Replaces a row in this matrix with the values of the given vector. + * + * @param rowIndex + * @param rowData + * @return this matrix for chaining + * @throws NullPointerException + * if rowData is null. + * @throws IllegalArgumentException + * if rowIndex is not in [0, 2] + */ + public Matrix3 setRow(final int rowIndex, final ReadOnlyVector3 rowData) { + switch (rowIndex) { + case 0: + _m00 = rowData.getX(); + _m01 = rowData.getY(); + _m02 = rowData.getZ(); + break; + case 1: + _m10 = rowData.getX(); + _m11 = rowData.getY(); + _m12 = rowData.getZ(); + break; + case 2: + _m20 = rowData.getX(); + _m21 = rowData.getY(); + _m22 = rowData.getZ(); + break; + default: + throw new IllegalArgumentException("Bad rowIndex: " + rowIndex); + } + return this; + } + + /** + * Set the values of this matrix from the axes (columns) provided. + * + * @param uAxis + * @param vAxis + * @param wAxis + * @return this matrix for chaining + * @throws NullPointerException + * if any of the axes are null. + */ + public Matrix3 fromAxes(final ReadOnlyVector3 uAxis, final ReadOnlyVector3 vAxis, final ReadOnlyVector3 wAxis) { + setColumn(0, uAxis); + setColumn(1, vAxis); + setColumn(2, wAxis); + return this; + } + + /** + * Sets this matrix to the rotation indicated by the given angle and axis of rotation. Note: This method creates an + * object, so use fromAngleNormalAxis when possible, particularly if your axis is already normalized. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation. + * @return this matrix for chaining + * @throws NullPointerException + * if axis is null. + */ + public Matrix3 fromAngleAxis(final double angle, final ReadOnlyVector3 axis) { + final Vector3 normAxis = Vector3.fetchTempInstance(); + axis.normalize(normAxis); + fromAngleNormalAxis(angle, normAxis); + Vector3.releaseTempInstance(normAxis); + return this; + } + + /** + * Sets this matrix to the rotation indicated by the given angle and a unit-length axis of rotation. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation (already normalized). + * @return this matrix for chaining + * @throws NullPointerException + * if axis is null. + */ + public Matrix3 fromAngleNormalAxis(final double angle, final ReadOnlyVector3 axis) { + final double fCos = MathUtils.cos(angle); + final double fSin = MathUtils.sin(angle); + final double fOneMinusCos = 1.0 - fCos; + final double fX2 = axis.getX() * axis.getX(); + final double fY2 = axis.getY() * axis.getY(); + final double fZ2 = axis.getZ() * axis.getZ(); + final double fXYM = axis.getX() * axis.getY() * fOneMinusCos; + final double fXZM = axis.getX() * axis.getZ() * fOneMinusCos; + final double fYZM = axis.getY() * axis.getZ() * fOneMinusCos; + final double fXSin = axis.getX() * fSin; + final double fYSin = axis.getY() * fSin; + final double fZSin = axis.getZ() * fSin; + + _m00 = fX2 * fOneMinusCos + fCos; + _m01 = fXYM - fZSin; + _m02 = fXZM + fYSin; + _m10 = fXYM + fZSin; + _m11 = fY2 * fOneMinusCos + fCos; + _m12 = fYZM - fXSin; + _m20 = fXZM - fYSin; + _m21 = fYZM + fXSin; + _m22 = fZ2 * fOneMinusCos + fCos; + + return this; + } + + /** + * XXX: Need to redo this again... or at least correct the terms. YRP are arbitrary terms, based on a specific frame + * of axis. + * + * Updates this matrix from the given Euler rotation angles (y,r,p). Note that we are applying in order: roll, + * pitch, yaw but we've ordered them in x, y, and z for convenience. See: + * http://www.euclideanspace.com/maths/geometry/rotations/conversions/eulerToMatrix/index.htm + * + * @param yaw + * the Euler yaw of rotation (in radians). (aka Bank, often rot around x) + * @param roll + * the Euler roll of rotation (in radians). (aka Heading, often rot around y) + * @param pitch + * the Euler pitch of rotation (in radians). (aka Attitude, often rot around z) + * @return this matrix for chaining + */ + public Matrix3 fromAngles(final double yaw, final double roll, final double pitch) { + final double ch = Math.cos(roll); + final double sh = Math.sin(roll); + final double cp = Math.cos(pitch); + final double sp = Math.sin(pitch); + final double cy = Math.cos(yaw); + final double sy = Math.sin(yaw); + + _m00 = ch * cp; + _m01 = sh * sy - ch * sp * cy; + _m02 = ch * sp * sy + sh * cy; + _m10 = sp; + _m11 = cp * cy; + _m12 = -cp * sy; + _m20 = -sh * cp; + _m21 = sh * sp * cy + ch * sy; + _m22 = -sh * sp * sy + ch * cy; + return this; + } + + public Matrix3 applyRotation(final double angle, final double x, final double y, final double z) { + final double m00 = _m00, m01 = _m01, m02 = _m02, // + m10 = _m10, m11 = _m11, m12 = _m12, // + m20 = _m20, m21 = _m21, m22 = _m22; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + final double oneMinusCos = 1.0f - cosAngle; + final double xyOneMinusCos = x * y * oneMinusCos; + final double xzOneMinusCos = x * z * oneMinusCos; + final double yzOneMinusCos = y * z * oneMinusCos; + final double xSin = x * sinAngle; + final double ySin = y * sinAngle; + final double zSin = z * sinAngle; + + final double r00 = x * x * oneMinusCos + cosAngle; + final double r01 = xyOneMinusCos - zSin; + final double r02 = xzOneMinusCos + ySin; + final double r10 = xyOneMinusCos + zSin; + final double r11 = y * y * oneMinusCos + cosAngle; + final double r12 = yzOneMinusCos - xSin; + final double r20 = xzOneMinusCos - ySin; + final double r21 = yzOneMinusCos + xSin; + final double r22 = z * z * oneMinusCos + cosAngle; + + _m00 = m00 * r00 + m01 * r10 + m02 * r20; + _m01 = m00 * r01 + m01 * r11 + m02 * r21; + _m02 = m00 * r02 + m01 * r12 + m02 * r22; + + _m10 = m10 * r00 + m11 * r10 + m12 * r20; + _m11 = m10 * r01 + m11 * r11 + m12 * r21; + _m12 = m10 * r02 + m11 * r12 + m12 * r22; + + _m20 = m20 * r00 + m21 * r10 + m22 * r20; + _m21 = m20 * r01 + m21 * r11 + m22 * r21; + _m22 = m20 * r02 + m21 * r12 + m22 * r22; + + return this; + } + + /** + * Apply rotation around X (Mrx * this) + * + * @param angle + * @return + */ + public Matrix3 applyRotationX(final double angle) { + final double m01 = _m01, m02 = _m02, // + m11 = _m11, m12 = _m12, // + m21 = _m21, m22 = _m22; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m01 = m01 * cosAngle + m02 * sinAngle; + _m02 = m02 * cosAngle - m01 * sinAngle; + + _m11 = m11 * cosAngle + m12 * sinAngle; + _m12 = m12 * cosAngle - m11 * sinAngle; + + _m21 = m21 * cosAngle + m22 * sinAngle; + _m22 = m22 * cosAngle - m21 * sinAngle; + + return this; + } + + /** + * Apply rotation around Y (Mry * this) + * + * @param angle + * @return + */ + public Matrix3 applyRotationY(final double angle) { + final double m00 = _m00, m02 = _m02, // + m10 = _m10, m12 = _m12, // + m20 = _m20, m22 = _m22; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m00 = m00 * cosAngle - m02 * sinAngle; + _m02 = m00 * sinAngle + m02 * cosAngle; + + _m10 = m10 * cosAngle - m12 * sinAngle; + _m12 = m10 * sinAngle + m12 * cosAngle; + + _m20 = m20 * cosAngle - m22 * sinAngle; + _m22 = m20 * sinAngle + m22 * cosAngle; + + return this; + } + + /** + * Apply rotation around Z (Mrz * this) + * + * @param angle + * @return + */ + public Matrix3 applyRotationZ(final double angle) { + final double m00 = _m00, m01 = _m01, // + m10 = _m10, m11 = _m11, // + m20 = _m20, m21 = _m21; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m00 = m00 * cosAngle + m01 * sinAngle; + _m01 = m01 * cosAngle - m00 * sinAngle; + + _m10 = m10 * cosAngle + m11 * sinAngle; + _m11 = m11 * cosAngle - m10 * sinAngle; + + _m20 = m20 * cosAngle + m21 * sinAngle; + _m21 = m21 * cosAngle - m20 * sinAngle; + + return this; + } + + /** + * @param index + * @param store + * the vector object to store the result in. if null, a new one is created. + * @return the column specified by the index. + * @throws IllegalArgumentException + * if index is not in bounds [0, 2] + */ + @Override + public Vector3 getColumn(final int index, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + switch (index) { + case 0: + result.setX(_m00); + result.setY(_m10); + result.setZ(_m20); + break; + case 1: + result.setX(_m01); + result.setY(_m11); + result.setZ(_m21); + break; + case 2: + result.setX(_m02); + result.setY(_m12); + result.setZ(_m22); + break; + default: + throw new IllegalArgumentException("invalid column index: " + index); + } + + return result; + } + + /** + * @param index + * @param store + * the vector object to store the result in. if null, a new one is created. + * @return the row specified by the index. + * @throws IllegalArgumentException + * if index is not in bounds [0, 2] + */ + @Override + public Vector3 getRow(final int index, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + switch (index) { + case 0: + result.setX(_m00); + result.setY(_m01); + result.setZ(_m02); + break; + case 1: + result.setX(_m10); + result.setY(_m11); + result.setZ(_m12); + break; + case 2: + result.setX(_m20); + result.setY(_m21); + result.setZ(_m22); + break; + default: + throw new IllegalArgumentException("invalid row index: " + index); + } + return result; + } + + /** + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * position. + * @return matrix data as a DoubleBuffer in row major order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 9 values. + */ + @Override + public DoubleBuffer toDoubleBuffer(final DoubleBuffer store) { + return toDoubleBuffer(store, true); + } + + /** + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * position. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a DoubleBuffer in the specified order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 9 values. + */ + @Override + public DoubleBuffer toDoubleBuffer(final DoubleBuffer store, final boolean rowMajor) { + if (rowMajor) { + store.put(_m00); + store.put(_m01); + store.put(_m02); + store.put(_m10); + store.put(_m11); + store.put(_m12); + store.put(_m20); + store.put(_m21); + store.put(_m22); + } else { + store.put(_m00); + store.put(_m10); + store.put(_m20); + store.put(_m01); + store.put(_m11); + store.put(_m21); + store.put(_m02); + store.put(_m12); + store.put(_m22); + } + + return store; + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * position. + * @return matrix data as a FloatBuffer in row major order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 9 values. + */ + @Override + public FloatBuffer toFloatBuffer(final FloatBuffer store) { + return toFloatBuffer(store, true); + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * position. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a FloatBuffer in the specified order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 9 values. + */ + @Override + public FloatBuffer toFloatBuffer(final FloatBuffer store, final boolean rowMajor) { + if (rowMajor) { + store.put((float) _m00); + store.put((float) _m01); + store.put((float) _m02); + store.put((float) _m10); + store.put((float) _m11); + store.put((float) _m12); + store.put((float) _m20); + store.put((float) _m21); + store.put((float) _m22); + } else { + store.put((float) _m00); + store.put((float) _m10); + store.put((float) _m20); + store.put((float) _m01); + store.put((float) _m11); + store.put((float) _m21); + store.put((float) _m02); + store.put((float) _m12); + store.put((float) _m22); + } + + return store; + } + + /** + * @param store + * the double array to store our matrix data in. If null, a new array is created. + * @return matrix data as a double array in row major order. + * @throws IllegalArgumentException + * if the store is non-null and has a length < 9 + */ + @Override + public double[] toArray(final double[] store) { + return toArray(store, true); + } + + /** + * @param store + * the double array to store our matrix data in. If null, a new array is created. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a double array in the specified order. + * @throws IllegalArgumentException + * if the store is non-null and has a length < 9 + */ + @Override + public double[] toArray(final double[] store, final boolean rowMajor) { + double[] result = store; + if (result == null) { + result = new double[9]; + } else if (result.length < 9) { + throw new IllegalArgumentException("store must be at least length 9."); + } + + if (rowMajor) { + result[0] = _m00; + result[1] = _m01; + result[2] = _m02; + result[3] = _m10; + result[4] = _m11; + result[5] = _m12; + result[6] = _m20; + result[7] = _m21; + result[8] = _m22; + } else { + result[0] = _m00; + result[1] = _m10; + result[2] = _m20; + result[3] = _m01; + result[4] = _m11; + result[5] = _m21; + result[6] = _m02; + result[7] = _m12; + result[8] = _m22; + } + + return result; + } + + /** + * converts this matrix to Euler rotation angles (yaw, roll, pitch). See + * http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToEuler/index.htm + * + * @param store + * the double[] array to store the computed angles in. If null, a new double[] will be created + * @return the double[] array. + * @throws IllegalArgumentException + * if non-null store is not at least length 3 + * @see #fromAngles(double, double, double) + */ + @Override + public double[] toAngles(final double[] store) { + double[] result = store; + if (result == null) { + result = new double[3]; + } else if (result.length < 3) { + throw new IllegalArgumentException("store array must have at least three elements"); + } + + double heading, attitude, bank; + if (_m10 > 1 - MathUtils.ZERO_TOLERANCE) { // singularity at north pole + heading = Math.atan2(_m02, _m22); + attitude = Math.PI / 2; + bank = 0; + } else if (_m10 < -1 + MathUtils.ZERO_TOLERANCE) { // singularity at south pole + heading = Math.atan2(_m02, _m22); + attitude = -Math.PI / 2; + bank = 0; + } else { + heading = Math.atan2(-_m20, _m00); + bank = Math.atan2(-_m12, _m11); + attitude = Math.asin(_m10); + } + result[0] = bank; + result[1] = heading; + result[2] = attitude; + + return result; + } + + /** + * @param matrix + * @return This matrix for chaining, modified internally to reflect multiplication against the given matrix + * @throws NullPointerException + * if matrix is null + */ + public Matrix3 multiplyLocal(final ReadOnlyMatrix3 matrix) { + return multiply(matrix, this); + } + + /** + * @param matrix + * @param store + * a matrix to store the result in. if null, a new matrix is created. It is safe for the given matrix and + * this parameter to be the same object. + * @return this matrix multiplied by the given matrix. + * @throws NullPointerException + * if matrix is null. + */ + @Override + public Matrix3 multiply(final ReadOnlyMatrix3 matrix, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + final double temp00 = _m00 * matrix.getM00() + _m01 * matrix.getM10() + _m02 * matrix.getM20(); + final double temp01 = _m00 * matrix.getM01() + _m01 * matrix.getM11() + _m02 * matrix.getM21(); + final double temp02 = _m00 * matrix.getM02() + _m01 * matrix.getM12() + _m02 * matrix.getM22(); + final double temp10 = _m10 * matrix.getM00() + _m11 * matrix.getM10() + _m12 * matrix.getM20(); + final double temp11 = _m10 * matrix.getM01() + _m11 * matrix.getM11() + _m12 * matrix.getM21(); + final double temp12 = _m10 * matrix.getM02() + _m11 * matrix.getM12() + _m12 * matrix.getM22(); + final double temp20 = _m20 * matrix.getM00() + _m21 * matrix.getM10() + _m22 * matrix.getM20(); + final double temp21 = _m20 * matrix.getM01() + _m21 * matrix.getM11() + _m22 * matrix.getM21(); + final double temp22 = _m20 * matrix.getM02() + _m21 * matrix.getM12() + _m22 * matrix.getM22(); + + result.set(temp00, temp01, temp02, temp10, temp11, temp12, temp20, temp21, temp22); + + return result; + } + + /** + * Multiplies this matrix by the diagonal matrix formed by the given vector (v^D * M). If supplied, the result is + * stored into the supplied "store" matrix. + * + * @param vec + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store matrix, or a new matrix if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Matrix3 multiplyDiagonalPre(final ReadOnlyVector3 vec, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + result.set( // + vec.getX() * _m00, vec.getX() * _m01, vec.getX() * _m02, // + vec.getY() * _m10, vec.getY() * _m11, vec.getY() * _m12, // + vec.getZ() * _m20, vec.getZ() * _m21, vec.getZ() * _m22); + + return result; + } + + /** + * Multiplies this matrix by the diagonal matrix formed by the given vector (M * v^D). If supplied, the result is + * stored into the supplied "store" matrix. + * + * @param vec + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store matrix, or a new matrix if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Matrix3 multiplyDiagonalPost(final ReadOnlyVector3 vec, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + result.set( // + vec.getX() * _m00, vec.getY() * _m01, vec.getZ() * _m02, // + vec.getX() * _m10, vec.getY() * _m11, vec.getZ() * _m12, // + vec.getX() * _m20, vec.getY() * _m21, vec.getZ() * _m22); + + return result; + } + + /** + * Internally scales all values of this matrix by the given scalar. + * + * @param scalar + * @return this matrix for chaining. + */ + public Matrix3 multiplyLocal(final double scalar) { + _m00 *= scalar; + _m01 *= scalar; + _m02 *= scalar; + _m10 *= scalar; + _m11 *= scalar; + _m12 *= scalar; + _m20 *= scalar; + _m21 *= scalar; + _m22 *= scalar; + return this; + } + + /** + * @param matrix + * the matrix to add to this. + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * matrix and store to be the same object. + * @return the result. + * @throws NullPointerException + * if matrix is null + */ + @Override + public Matrix3 add(final ReadOnlyMatrix3 matrix, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + result._m00 = _m00 + matrix.getM00(); + result._m01 = _m01 + matrix.getM01(); + result._m02 = _m02 + matrix.getM02(); + result._m10 = _m10 + matrix.getM10(); + result._m11 = _m11 + matrix.getM11(); + result._m12 = _m12 + matrix.getM12(); + result._m20 = _m20 + matrix.getM20(); + result._m21 = _m21 + matrix.getM21(); + result._m22 = _m22 + matrix.getM22(); + + return result; + } + + /** + * Internally adds the values of the given matrix to this matrix. + * + * @param matrix + * the matrix to add to this. + * @return this matrix for chaining + * @throws NullPointerException + * if matrix is null + */ + public Matrix3 addLocal(final ReadOnlyMatrix3 matrix) { + return add(matrix, this); + } + + /** + * @param matrix + * the matrix to subtract from this. + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * matrix and store to be the same object. + * @return the result. + * @throws NullPointerException + * if matrix is null + */ + @Override + public Matrix3 subtract(final ReadOnlyMatrix3 matrix, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + result._m00 = _m00 - matrix.getM00(); + result._m01 = _m01 - matrix.getM01(); + result._m02 = _m02 - matrix.getM02(); + result._m10 = _m10 - matrix.getM10(); + result._m11 = _m11 - matrix.getM11(); + result._m12 = _m12 - matrix.getM12(); + result._m20 = _m20 - matrix.getM20(); + result._m21 = _m21 - matrix.getM21(); + result._m22 = _m22 - matrix.getM22(); + + return result; + } + + /** + * Internally subtracts the values of the given matrix from this matrix. + * + * @param matrix + * the matrix to subtract from this. + * @return this matrix for chaining + * @throws NullPointerException + * if matrix is null + */ + public Matrix3 subtractLocal(final ReadOnlyMatrix3 matrix) { + return subtract(matrix, this); + } + + /** + * Applies the given scale to this matrix and returns the result as a new matrix + * + * @param scale + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. + * @return the new matrix + * @throws NullPointerException + * if scale is null. + */ + @Override + public Matrix3 scale(final ReadOnlyVector3 scale, final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + return result.set( // + _m00 * scale.getX(), _m01 * scale.getY(), _m02 * scale.getZ(), // + _m10 * scale.getX(), _m11 * scale.getY(), _m12 * scale.getZ(), // + _m20 * scale.getX(), _m21 * scale.getY(), _m22 * scale.getZ()); + } + + /** + * Applies the given scale to this matrix values internally + * + * @param scale + * @return this matrix for chaining. + * @throws NullPointerException + * if scale is null. + */ + public Matrix3 scaleLocal(final ReadOnlyVector3 scale) { + return scale(scale, this); + } + + /** + * transposes this matrix as a new matrix, basically flipping it across the diagonal + * + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. + * @return this matrix for chaining. + * @see <a href="http://en.wikipedia.org/wiki/Transpose">wikipedia.org-Transpose</a> + */ + @Override + public Matrix3 transpose(final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + result._m00 = _m00; + result._m01 = _m10; + result._m02 = _m20; + result._m10 = _m01; + result._m11 = _m11; + result._m12 = _m21; + result._m20 = _m02; + result._m21 = _m12; + result._m22 = _m22; + + return result; + } + + /** + * transposes this matrix in place + * + * @return this matrix for chaining. + * @see <a href="http://en.wikipedia.org/wiki/Transpose">wikipedia.org-Transpose</a> + */ + public Matrix3 transposeLocal() { + final double m01 = _m01; + final double m02 = _m02; + final double m12 = _m12; + _m01 = _m10; + _m02 = _m20; + _m12 = _m21; + _m10 = m01; + _m20 = m02; + _m21 = m12; + return this; + } + + /** + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * store == this. + * @return a matrix that represents this matrix, inverted. + * + * if store is not null and is read only + * @throws ArithmeticException + * if this matrix can not be inverted. + */ + @Override + public Matrix3 invert(final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + final double det = determinant(); + if (Math.abs(det) <= MathUtils.EPSILON) { + throw new ArithmeticException("This matrix cannot be inverted."); + } + + final double temp00 = _m11 * _m22 - _m12 * _m21; + final double temp01 = _m02 * _m21 - _m01 * _m22; + final double temp02 = _m01 * _m12 - _m02 * _m11; + final double temp10 = _m12 * _m20 - _m10 * _m22; + final double temp11 = _m00 * _m22 - _m02 * _m20; + final double temp12 = _m02 * _m10 - _m00 * _m12; + final double temp20 = _m10 * _m21 - _m11 * _m20; + final double temp21 = _m01 * _m20 - _m00 * _m21; + final double temp22 = _m00 * _m11 - _m01 * _m10; + result.set(temp00, temp01, temp02, temp10, temp11, temp12, temp20, temp21, temp22); + result.multiplyLocal(1.0 / det); + return result; + } + + /** + * Inverts this matrix locally. + * + * @return this matrix inverted internally. + * @throws ArithmeticException + * if this matrix can not be inverted. + */ + public Matrix3 invertLocal() { + return invert(this); + } + + /** + * @param store + * The matrix to store the result in. If null, a new matrix is created. + * @return The adjugate, or classical adjoint, of this matrix + * @see <a href="http://en.wikipedia.org/wiki/Adjugate_matrix">wikipedia.org-Adjugate_matrix</a> + */ + @Override + public Matrix3 adjugate(final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + final double temp00 = _m11 * _m22 - _m12 * _m21; + final double temp01 = _m02 * _m21 - _m01 * _m22; + final double temp02 = _m01 * _m12 - _m02 * _m11; + final double temp10 = _m12 * _m20 - _m10 * _m22; + final double temp11 = _m00 * _m22 - _m02 * _m20; + final double temp12 = _m02 * _m10 - _m00 * _m12; + final double temp20 = _m10 * _m21 - _m11 * _m20; + final double temp21 = _m01 * _m20 - _m00 * _m21; + final double temp22 = _m00 * _m11 - _m01 * _m10; + + return result.set(temp00, temp01, temp02, temp10, temp11, temp12, temp20, temp21, temp22); + } + + /** + * @return this matrix, modified to represent its adjugate, or classical adjoint + * @see <a href="http://en.wikipedia.org/wiki/Adjugate_matrix">wikipedia.org-Adjugate_matrix</a> + */ + public Matrix3 adjugateLocal() { + return adjugate(this); + } + + /** + * @return the determinate of this 3x3 matrix (aei+bfg+cdh-ceg-bdi-afh) + * @see <a href="http://en.wikipedia.org/wiki/Determinant">wikipedia.org-Determinant</a> + */ + @Override + public double determinant() { + return _m00 * _m11 * _m22 + _m01 * _m12 * _m20 + _m02 * _m10 * _m21 - // + _m02 * _m11 * _m20 - _m01 * _m10 * _m22 - _m00 * _m12 * _m21; + } + + /** + * A function for creating a rotation matrix that rotates a vector called "start" into another vector called "end". + * + * @param start + * normalized non-zero starting vector + * @param end + * normalized non-zero ending vector + * @return this matrix, for chaining + * @see "Tomas Möller, John Hughes 'Efficiently Building a Matrix to Rotate One Vector to Another' Journal of Graphics Tools, 4(4):1-4, 1999" + */ + public Matrix3 fromStartEndLocal(final ReadOnlyVector3 start, final ReadOnlyVector3 end) { + final Vector3 v = new Vector3(); + double e, h, f; + + start.cross(end, v); + e = start.dot(end); + f = e < 0 ? -e : e; + + // if "from" and "to" vectors are nearly parallel + if (f > 1.0 - MathUtils.ZERO_TOLERANCE) { + final Vector3 u = new Vector3(); + final Vector3 x = new Vector3(); + double c1, c2, c3; /* coefficients for later use */ + + x.setX(start.getX() > 0.0 ? start.getX() : -start.getX()); + x.setY(start.getY() > 0.0 ? start.getY() : -start.getY()); + x.setZ(start.getZ() > 0.0 ? start.getZ() : -start.getZ()); + + if (x.getX() < x.getY()) { + if (x.getX() < x.getZ()) { + x.set(1.0, 0.0, 0.0); + } else { + x.set(0.0, 0.0, 1.0); + } + } else { + if (x.getY() < x.getZ()) { + x.set(0.0, 1.0, 0.0); + } else { + x.set(0.0, 0.0, 1.0); + } + } + + u.set(x).subtractLocal(start); + v.set(x).subtractLocal(end); + + c1 = 2.0 / u.dot(u); + c2 = 2.0 / v.dot(v); + c3 = c1 * c2 * u.dot(v); + + _m00 = -c1 * u.getX() * u.getX() - c2 * v.getX() * v.getX() + c3 * v.getX() * u.getX() + 1.0; + _m01 = -c1 * u.getX() * u.getY() - c2 * v.getX() * v.getY() + c3 * v.getX() * u.getY(); + _m02 = -c1 * u.getX() * u.getZ() - c2 * v.getX() * v.getZ() + c3 * v.getX() * u.getZ(); + _m10 = -c1 * u.getY() * u.getX() - c2 * v.getY() * v.getX() + c3 * v.getY() * u.getX(); + _m11 = -c1 * u.getY() * u.getY() - c2 * v.getY() * v.getY() + c3 * v.getY() * u.getY() + 1.0; + _m12 = -c1 * u.getY() * u.getZ() - c2 * v.getY() * v.getZ() + c3 * v.getY() * u.getZ(); + _m20 = -c1 * u.getZ() * u.getX() - c2 * v.getZ() * v.getX() + c3 * v.getZ() * u.getX(); + _m21 = -c1 * u.getZ() * u.getY() - c2 * v.getZ() * v.getY() + c3 * v.getZ() * u.getY(); + _m22 = -c1 * u.getZ() * u.getZ() - c2 * v.getZ() * v.getZ() + c3 * v.getZ() * u.getZ() + 1.0; + } else { + // the most common case, unless "start"="end", or "start"=-"end" + double hvx, hvz, hvxy, hvxz, hvyz; + h = 1.0 / (1.0 + e); + hvx = h * v.getX(); + hvz = h * v.getZ(); + hvxy = hvx * v.getY(); + hvxz = hvx * v.getZ(); + hvyz = hvz * v.getY(); + _m00 = e + hvx * v.getX(); + _m01 = hvxy - v.getZ(); + _m02 = hvxz + v.getY(); + + _m10 = hvxy + v.getZ(); + _m11 = e + h * v.getY() * v.getY(); + _m12 = hvyz - v.getX(); + + _m20 = hvxz - v.getY(); + _m21 = hvyz + v.getX(); + _m22 = e + hvz * v.getZ(); + } + return this; + } + + /** + * Multiplies the given vector by this matrix (v * M). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param vec + * the vector to multiply this matrix by. + * @param store + * a vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Vector3 applyPre(final ReadOnlyVector3 vec, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final double x = vec.getX(); + final double y = vec.getY(); + final double z = vec.getZ(); + + result.setX(_m00 * x + _m10 * y + _m20 * z); + result.setY(_m01 * x + _m11 * y + _m21 * z); + result.setZ(_m02 * x + _m12 * y + _m22 * z); + return result; + } + + /** + * Multiplies the given vector by this matrix (M * v). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param vec + * the vector to multiply this matrix by. + * @param store + * a vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Vector3 applyPost(final ReadOnlyVector3 vec, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final double x = vec.getX(); + final double y = vec.getY(); + final double z = vec.getZ(); + + result.setX(_m00 * x + _m01 * y + _m02 * z); + result.setY(_m10 * x + _m11 * y + _m12 * z); + result.setZ(_m20 * x + _m21 * y + _m22 * z); + return result; + } + + /** + * Modifies this matrix to equal the rotation required to point the z-axis at 'direction' and the y-axis to 'up'. + * + * @param direction + * where to 'look' at + * @param up + * a vector indicating the local up direction. + * @return this matrix for chaining + */ + public Matrix3 lookAt(final ReadOnlyVector3 direction, final ReadOnlyVector3 up) { + final Vector3 xAxis = Vector3.fetchTempInstance(); + final Vector3 yAxis = Vector3.fetchTempInstance(); + final Vector3 zAxis = Vector3.fetchTempInstance(); + direction.normalize(zAxis); + up.normalize(xAxis).crossLocal(zAxis).normalizeLocal(); + zAxis.cross(xAxis, yAxis); + + fromAxes(xAxis, yAxis, zAxis); + + Vector3.releaseTempInstance(xAxis); + Vector3.releaseTempInstance(yAxis); + Vector3.releaseTempInstance(zAxis); + return this; + } + + /** + * Check a matrix... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param matrix + * the vector to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyMatrix3 matrix) { + if (matrix == null) { + return false; + } + + if (Double.isNaN(matrix.getM00()) || Double.isInfinite(matrix.getM00())) { + return false; + } else if (Double.isNaN(matrix.getM01()) || Double.isInfinite(matrix.getM01())) { + return false; + } else if (Double.isNaN(matrix.getM02()) || Double.isInfinite(matrix.getM02())) { + return false; + } else if (Double.isNaN(matrix.getM10()) || Double.isInfinite(matrix.getM10())) { + return false; + } else if (Double.isNaN(matrix.getM11()) || Double.isInfinite(matrix.getM11())) { + return false; + } else if (Double.isNaN(matrix.getM12()) || Double.isInfinite(matrix.getM12())) { + return false; + } else if (Double.isNaN(matrix.getM20()) || Double.isInfinite(matrix.getM20())) { + return false; + } else if (Double.isNaN(matrix.getM21()) || Double.isInfinite(matrix.getM21())) { + return false; + } else if (Double.isNaN(matrix.getM22()) || Double.isInfinite(matrix.getM22())) { + return false; + } + + return true; + } + + /** + * @return true if this Matrix is orthonormal - its rows are orthogonal, unit vectors. + */ + @Override + public boolean isOrthonormal() { + if (Math.abs(_m00 * _m00 + _m01 * _m01 + _m02 * _m02 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m00 * _m10 + _m01 * _m11 + _m02 * _m12 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m00 * _m20 + _m01 * _m21 + _m02 * _m22 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m10 * _m00 + _m11 * _m01 + _m12 * _m02 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m10 * _m10 + _m11 * _m11 + _m12 * _m12 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m10 * _m20 + _m11 * _m21 + _m12 * _m22 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m20 * _m00 + _m21 * _m01 + _m22 * _m02 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m20 * _m10 + _m21 * _m11 + _m22 * _m12 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } else if (Math.abs(_m20 * _m20 + _m21 * _m21 + _m22 * _m22 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + + return true; + } + + /** + * @return the string representation of this matrix. + */ + @Override + public String toString() { + final StringBuffer result = new StringBuffer("com.ardor3d.math.Matrix3\n[\n"); + result.append(" "); + result.append(_m00); + result.append(" "); + result.append(_m01); + result.append(" "); + result.append(_m02); + result.append(" \n"); + + result.append(" "); + result.append(_m10); + result.append(" "); + result.append(_m11); + result.append(" "); + result.append(_m12); + result.append(" \n"); + + result.append(" "); + result.append(_m20); + result.append(" "); + result.append(_m21); + result.append(" "); + result.append(_m22); + result.append(" \n"); + + result.append("]"); + return result.toString(); + } + + /** + * @return returns a unique code for this matrix object based on its values. If two matrices are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + long val = Double.doubleToLongBits(_m00); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m01); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m02); + result += 31 * result + (int) (val ^ val >>> 32); + + val = Double.doubleToLongBits(_m10); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m11); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m12); + result += 31 * result + (int) (val ^ val >>> 32); + + val = Double.doubleToLongBits(_m20); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m21); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m22); + result += 31 * result + (int) (val ^ val >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this matrix and the provided matrix have the double values that are within the + * MathUtils.ZERO_TOLERANCE. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyMatrix3)) { + return false; + } + final ReadOnlyMatrix3 comp = (ReadOnlyMatrix3) o; + if (Math.abs(getM00() - comp.getM00()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM01() - comp.getM01()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM02() - comp.getM02()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM10() - comp.getM10()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM11() - comp.getM11()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM12() - comp.getM12()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM20() - comp.getM20()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM21() - comp.getM21()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM22() - comp.getM22()) > Matrix3.ALLOWED_DEVIANCE) { + return false; + } + + return true; + } + + /** + * @param o + * the object to compare for equality + * @return true if this matrix and the provided matrix have the exact same double values. + */ + public boolean strictEquals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyMatrix3)) { + return false; + } + final ReadOnlyMatrix3 comp = (ReadOnlyMatrix3) o; + if (getM00() != comp.getM00()) { + return false; + } else if (getM01() != comp.getM01()) { + return false; + } else if (getM02() != comp.getM02()) { + return false; + } else if (getM10() != comp.getM10()) { + return false; + } else if (getM11() != comp.getM11()) { + return false; + } else if (getM12() != comp.getM12()) { + return false; + } else if (getM20() != comp.getM20()) { + return false; + } else if (getM21() != comp.getM21()) { + return false; + } else if (getM22() != comp.getM22()) { + return false; + } + + return true; + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Matrix3 clone() { + return new Matrix3(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Matrix3> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_m00, "m00", 1.0); + capsule.write(_m01, "m01", 0.0); + capsule.write(_m02, "m02", 0.0); + capsule.write(_m10, "m10", 0.0); + capsule.write(_m11, "m11", 1.0); + capsule.write(_m12, "m12", 0.0); + capsule.write(_m20, "m20", 0.0); + capsule.write(_m21, "m21", 0.0); + capsule.write(_m22, "m22", 1.0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _m00 = capsule.readDouble("m00", 1.0); + _m01 = capsule.readDouble("m01", 0.0); + _m02 = capsule.readDouble("m02", 0.0); + _m10 = capsule.readDouble("m10", 0.0); + _m11 = capsule.readDouble("m11", 1.0); + _m12 = capsule.readDouble("m12", 0.0); + _m20 = capsule.readDouble("m20", 0.0); + _m21 = capsule.readDouble("m21", 0.0); + _m22 = capsule.readDouble("m22", 1.0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + _m00 = in.readDouble(); + _m01 = in.readDouble(); + _m02 = in.readDouble(); + _m10 = in.readDouble(); + _m11 = in.readDouble(); + _m12 = in.readDouble(); + _m20 = in.readDouble(); + _m21 = in.readDouble(); + _m22 = in.readDouble(); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(_m00); + out.writeDouble(_m01); + out.writeDouble(_m02); + out.writeDouble(_m10); + out.writeDouble(_m11); + out.writeDouble(_m12); + out.writeDouble(_m20); + out.writeDouble(_m21); + out.writeDouble(_m22); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Matrix3 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Matrix3 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Matrix3.MAT_POOL.fetch(); + } else { + return new Matrix3(); + } + } + + /** + * Releases a Matrix3 back to be used by a future call to fetchTempInstance. TAKE CARE: this Matrix3 object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param mat + * the Matrix3 to release. + */ + public final static void releaseTempInstance(final Matrix3 mat) { + if (MathConstants.useMathPools) { + Matrix3.MAT_POOL.release(mat); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Matrix4.java b/ardor3d-math/src/main/java/com/ardor3d/math/Matrix4.java new file mode 100644 index 0000000..9b2131f --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Matrix4.java @@ -0,0 +1,2440 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.nio.BufferOverflowException; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import com.ardor3d.math.type.ReadOnlyMatrix3; +import com.ardor3d.math.type.ReadOnlyMatrix4; +import com.ardor3d.math.type.ReadOnlyQuaternion; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.math.type.ReadOnlyVector4; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Matrix4 represents a double precision 4x4 matrix and contains a flag, set at object creation, indicating if the given + * Matrix4 object is mutable. + * + * Note: some algorithms in this class were ported from Eberly, Wolfram, Game Gems and others to Java. + */ +public class Matrix4 implements Cloneable, Savable, Externalizable, ReadOnlyMatrix4, Poolable { + /** Used with equals method to determine if two Matrix4 objects are close enough to be considered equal. */ + public static final double ALLOWED_DEVIANCE = 0.00000001; + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Matrix4> MAT_POOL = ObjectPool.create(Matrix4.class, MathConstants.maxMathPoolSize); + + /** + * <pre> + * 1, 0, 0, 0 + * 0, 1, 0, 0 + * 0, 0, 1, 0 + * 0, 0, 0, 1 + * </pre> + */ + public final static ReadOnlyMatrix4 IDENTITY = new Matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); + + protected double _m00, _m01, _m02, _m03, // + _m10, _m11, _m12, _m13, // + _m20, _m21, _m22, _m23, // + _m30, _m31, _m32, _m33; + + /** + * Constructs a new matrix set to identity. + */ + public Matrix4() { + this(Matrix4.IDENTITY); + } + + /** + * Constructs a new matrix set to the given matrix values. (names are mRC = m[ROW][COL]) + * + * @param m00 + * @param m01 + * @param m02 + * @param m03 + * @param m10 + * @param m11 + * @param m12 + * @param m13 + * @param m20 + * @param m21 + * @param m22 + * @param m23 + * @param m30 + * @param m31 + * @param m32 + * @param m33 + */ + public Matrix4(final double m00, final double m01, final double m02, final double m03, final double m10, + final double m11, final double m12, final double m13, final double m20, final double m21, final double m22, + final double m23, final double m30, final double m31, final double m32, final double m33) { + + _m00 = m00; + _m01 = m01; + _m02 = m02; + _m03 = m03; + _m10 = m10; + _m11 = m11; + _m12 = m12; + _m13 = m13; + _m20 = m20; + _m21 = m21; + _m22 = m22; + _m23 = m23; + _m30 = m30; + _m31 = m31; + _m32 = m32; + _m33 = m33; + } + + /** + * Constructs a new matrix set to the values of the given matrix. + * + * @param source + */ + public Matrix4(final ReadOnlyMatrix4 source) { + set(source); + } + + /** + * @param row + * @param column + * @return the value stored in this matrix at row, column. + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 3] + */ + @Override + public double getValue(final int row, final int column) { + switch (row) { + case 0: + switch (column) { + case 0: + return _m00; + case 1: + return _m01; + case 2: + return _m02; + case 3: + return _m03; + } + break; + case 1: + switch (column) { + case 0: + return _m10; + case 1: + return _m11; + case 2: + return _m12; + case 3: + return _m13; + } + break; + + case 2: + switch (column) { + case 0: + return _m20; + case 1: + return _m21; + case 2: + return _m22; + case 3: + return _m23; + } + break; + + case 3: + switch (column) { + case 0: + return _m30; + case 1: + return _m31; + case 2: + return _m32; + case 3: + return _m33; + } + break; + } + throw new IllegalArgumentException(); + } + + /** + * @param row + * @param column + * @return the value stored in this matrix at row, column, pre-cast to a float for convenience. + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 2] + */ + @Override + public float getValuef(final int row, final int column) { + return (float) getValue(row, column); + } + + @Override + public double getM00() { + return _m00; + } + + @Override + public double getM01() { + return _m01; + } + + @Override + public double getM02() { + return _m02; + } + + @Override + public double getM03() { + return _m03; + } + + @Override + public double getM10() { + return _m10; + } + + @Override + public double getM11() { + return _m11; + } + + @Override + public double getM12() { + return _m12; + } + + @Override + public double getM13() { + return _m13; + } + + @Override + public double getM20() { + return _m20; + } + + @Override + public double getM21() { + return _m21; + } + + @Override + public double getM22() { + return _m22; + } + + @Override + public double getM23() { + return _m23; + } + + @Override + public double getM30() { + return _m30; + } + + @Override + public double getM31() { + return _m31; + } + + @Override + public double getM32() { + return _m32; + } + + @Override + public double getM33() { + return _m33; + } + + public void setM00(final double m00) { + _m00 = m00; + } + + public void setM01(final double m01) { + _m01 = m01; + } + + public void setM02(final double m02) { + _m02 = m02; + } + + public void setM03(final double m03) { + _m03 = m03; + } + + public void setM10(final double m10) { + _m10 = m10; + } + + public void setM11(final double m11) { + _m11 = m11; + } + + public void setM12(final double m12) { + _m12 = m12; + } + + public void setM13(final double m13) { + _m13 = m13; + } + + public void setM20(final double m20) { + _m20 = m20; + } + + public void setM21(final double m21) { + _m21 = m21; + } + + public void setM22(final double m22) { + _m22 = m22; + } + + public void setM23(final double m23) { + _m23 = m23; + } + + public void setM30(final double m30) { + _m30 = m30; + } + + public void setM31(final double m31) { + _m31 = m31; + } + + public void setM32(final double m32) { + _m32 = m32; + } + + public void setM33(final double m33) { + _m33 = m33; + } + + /** + * Same as set(IDENTITY) + * + * @return this matrix for chaining + */ + public Matrix4 setIdentity() { + return set(Matrix4.IDENTITY); + } + + /** + * @return true if this matrix equals the 4x4 identity matrix + */ + @Override + public boolean isIdentity() { + return strictEquals(Matrix4.IDENTITY); + } + + /** + * Sets the value of this matrix at row, column to the given value. + * + * @param row + * @param column + * @param value + * @return this matrix for chaining + * @throws IllegalArgumentException + * if row and column are not in bounds [0, 3] + */ + public Matrix4 setValue(final int row, final int column, final double value) { + switch (row) { + case 0: + switch (column) { + case 0: + _m00 = value; + break; + case 1: + _m01 = value; + break; + case 2: + _m02 = value; + break; + case 3: + _m03 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + case 1: + switch (column) { + case 0: + _m10 = value; + break; + case 1: + _m11 = value; + break; + case 2: + _m12 = value; + break; + case 3: + _m13 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + case 2: + switch (column) { + case 0: + _m20 = value; + break; + case 1: + _m21 = value; + break; + case 2: + _m22 = value; + break; + case 3: + _m23 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + case 3: + switch (column) { + case 0: + _m30 = value; + break; + case 1: + _m31 = value; + break; + case 2: + _m32 = value; + break; + case 3: + _m33 = value; + break; + default: + throw new IllegalArgumentException(); + } + break; + + default: + throw new IllegalArgumentException(); + } + + return this; + } + + /** + * Sets the values of this matrix to the values given. + * + * @param m00 + * @param m01 + * @param m02 + * @param m03 + * @param m10 + * @param m11 + * @param m12 + * @param m13 + * @param m20 + * @param m21 + * @param m22 + * @param m23 + * @param m30 + * @param m31 + * @param m32 + * @param m33 + * @return this matrix for chaining + */ + public Matrix4 set(final double m00, final double m01, final double m02, final double m03, final double m10, + final double m11, final double m12, final double m13, final double m20, final double m21, final double m22, + final double m23, final double m30, final double m31, final double m32, final double m33) { + + _m00 = m00; + _m01 = m01; + _m02 = m02; + _m03 = m03; + _m10 = m10; + _m11 = m11; + _m12 = m12; + _m13 = m13; + _m20 = m20; + _m21 = m21; + _m22 = m22; + _m23 = m23; + _m30 = m30; + _m31 = m31; + _m32 = m32; + _m33 = m33; + + return this; + } + + /** + * Sets the values of this matrix to the values of the provided source matrix. + * + * @param source + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + */ + public Matrix4 set(final ReadOnlyMatrix4 source) { + _m00 = source.getM00(); + _m01 = source.getM01(); + _m02 = source.getM02(); + _m03 = source.getM03(); + + _m10 = source.getM10(); + _m11 = source.getM11(); + _m12 = source.getM12(); + _m13 = source.getM13(); + + _m20 = source.getM20(); + _m21 = source.getM21(); + _m22 = source.getM22(); + _m23 = source.getM23(); + + _m30 = source.getM30(); + _m31 = source.getM31(); + _m32 = source.getM32(); + _m33 = source.getM33(); + + return this; + } + + /** + * Sets the 3x3 rotation part of this matrix to the values of the provided source matrix. + * + * @param source + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + */ + public Matrix4 set(final ReadOnlyMatrix3 source) { + _m00 = source.getM00(); + _m01 = source.getM01(); + _m02 = source.getM02(); + _m10 = source.getM10(); + _m11 = source.getM11(); + _m12 = source.getM12(); + _m20 = source.getM20(); + _m21 = source.getM21(); + _m22 = source.getM22(); + return this; + } + + /** + * Sets the values of this matrix to the rotational value of the given quaternion. Only modifies the 3x3 rotation + * part of this matrix. + * + * @param quaternion + * @return this matrix for chaining + */ + public Matrix4 set(final ReadOnlyQuaternion quaternion) { + return quaternion.toRotationMatrix(this); + } + + /** + * @param source + * the buffer to read our matrix data from. + * @return this matrix for chaining. + */ + public Matrix4 fromDoubleBuffer(final DoubleBuffer source) { + return fromDoubleBuffer(source, true); + } + + /** + * @param source + * the buffer to read our matrix data from. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return this matrix for chaining. + */ + public Matrix4 fromDoubleBuffer(final DoubleBuffer source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source.get(); + _m01 = source.get(); + _m02 = source.get(); + _m03 = source.get(); + _m10 = source.get(); + _m11 = source.get(); + _m12 = source.get(); + _m13 = source.get(); + _m20 = source.get(); + _m21 = source.get(); + _m22 = source.get(); + _m23 = source.get(); + _m30 = source.get(); + _m31 = source.get(); + _m32 = source.get(); + _m33 = source.get(); + } else { + _m00 = source.get(); + _m10 = source.get(); + _m20 = source.get(); + _m30 = source.get(); + _m01 = source.get(); + _m11 = source.get(); + _m21 = source.get(); + _m31 = source.get(); + _m02 = source.get(); + _m12 = source.get(); + _m22 = source.get(); + _m32 = source.get(); + _m03 = source.get(); + _m13 = source.get(); + _m23 = source.get(); + _m33 = source.get(); + } + + return this; + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to read our matrix data from. + * @return this matrix for chaining. + */ + public Matrix4 fromFloatBuffer(final FloatBuffer source) { + return fromFloatBuffer(source, true); + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to read our matrix data from. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return this matrix for chaining. + */ + public Matrix4 fromFloatBuffer(final FloatBuffer source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source.get(); + _m01 = source.get(); + _m02 = source.get(); + _m03 = source.get(); + _m10 = source.get(); + _m11 = source.get(); + _m12 = source.get(); + _m13 = source.get(); + _m20 = source.get(); + _m21 = source.get(); + _m22 = source.get(); + _m23 = source.get(); + _m30 = source.get(); + _m31 = source.get(); + _m32 = source.get(); + _m33 = source.get(); + } else { + _m00 = source.get(); + _m10 = source.get(); + _m20 = source.get(); + _m30 = source.get(); + _m01 = source.get(); + _m11 = source.get(); + _m21 = source.get(); + _m31 = source.get(); + _m02 = source.get(); + _m12 = source.get(); + _m22 = source.get(); + _m32 = source.get(); + _m03 = source.get(); + _m13 = source.get(); + _m23 = source.get(); + _m33 = source.get(); + } + + return this; + } + + /** + * Sets the values of this matrix to the values of the provided double array. + * + * @param source + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + * @throws ArrayIndexOutOfBoundsException + * if source array has a length less than 16. + */ + public Matrix4 fromArray(final double[] source) { + return fromArray(source, true); + } + + /** + * Sets the values of this matrix to the values of the provided double array. + * + * @param source + * @param rowMajor + * @return this matrix for chaining + * @throws NullPointerException + * if source is null. + * @throws ArrayIndexOutOfBoundsException + * if source array has a length less than 16. + */ + public Matrix4 fromArray(final double[] source, final boolean rowMajor) { + if (rowMajor) { + _m00 = source[0]; + _m01 = source[1]; + _m02 = source[2]; + _m03 = source[3]; + _m10 = source[4]; + _m11 = source[5]; + _m12 = source[6]; + _m13 = source[7]; + _m20 = source[8]; + _m21 = source[9]; + _m22 = source[10]; + _m23 = source[11]; + _m30 = source[12]; + _m31 = source[13]; + _m32 = source[14]; + _m33 = source[15]; + } else { + _m00 = source[0]; + _m10 = source[1]; + _m20 = source[2]; + _m30 = source[3]; + _m01 = source[4]; + _m11 = source[5]; + _m21 = source[6]; + _m31 = source[7]; + _m02 = source[8]; + _m12 = source[9]; + _m22 = source[10]; + _m32 = source[11]; + _m03 = source[12]; + _m13 = source[13]; + _m23 = source[14]; + _m33 = source[15]; + } + return this; + } + + /** + * Replaces a column in this matrix with the values of the given array. + * + * @param columnIndex + * @param columnData + * @return this matrix for chaining + * @throws NullPointerException + * if columnData is null. + * @throws IllegalArgumentException + * if columnData has a length < 4 + * @throws IllegalArgumentException + * if columnIndex is not in [0, 3] + */ + public Matrix4 setColumn(final int columnIndex, final Vector4 columnData) { + switch (columnIndex) { + case 0: + _m00 = columnData.getX(); + _m10 = columnData.getY(); + _m20 = columnData.getZ(); + _m30 = columnData.getW(); + break; + case 1: + _m01 = columnData.getX(); + _m11 = columnData.getY(); + _m21 = columnData.getZ(); + _m31 = columnData.getW(); + break; + case 2: + _m02 = columnData.getX(); + _m12 = columnData.getY(); + _m22 = columnData.getZ(); + _m32 = columnData.getW(); + break; + case 3: + _m03 = columnData.getX(); + _m13 = columnData.getY(); + _m23 = columnData.getZ(); + _m33 = columnData.getW(); + break; + default: + throw new IllegalArgumentException("Bad columnIndex: " + columnIndex); + } + return this; + } + + /** + * Replaces a row in this matrix with the values of the given array. + * + * @param rowIndex + * @param rowData + * @return this matrix for chaining + * @throws NullPointerException + * if rowData is null. + * @throws IllegalArgumentException + * if rowData has a length < 4 + * @throws IllegalArgumentException + * if rowIndex is not in [0, 3] + */ + public Matrix4 setRow(final int rowIndex, final Vector4 rowData) { + switch (rowIndex) { + case 0: + _m00 = rowData.getX(); + _m01 = rowData.getY(); + _m02 = rowData.getZ(); + _m03 = rowData.getW(); + break; + case 1: + _m10 = rowData.getX(); + _m11 = rowData.getY(); + _m12 = rowData.getZ(); + _m13 = rowData.getW(); + break; + case 2: + _m20 = rowData.getX(); + _m21 = rowData.getY(); + _m22 = rowData.getZ(); + _m23 = rowData.getW(); + break; + case 3: + _m30 = rowData.getX(); + _m31 = rowData.getY(); + _m32 = rowData.getZ(); + _m33 = rowData.getW(); + break; + default: + throw new IllegalArgumentException("Bad rowIndex: " + rowIndex); + } + return this; + } + + /** + * Sets the 3x3 rotation portion of this matrix to the rotation indicated by the given angle and axis of rotation. + * Note: This method creates an object, so use fromAngleNormalAxis when possible, particularly if your axis is + * already normalized. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation. + * @return this matrix for chaining + * @throws NullPointerException + * if axis is null. + */ + public Matrix4 fromAngleAxis(final double angle, final ReadOnlyVector3 axis) { + final Vector3 normAxis = Vector3.fetchTempInstance(); + axis.normalize(normAxis); + fromAngleNormalAxis(angle, normAxis); + Vector3.releaseTempInstance(normAxis); + return this; + } + + /** + * Sets the 3x3 rotation portion of this matrix to the rotation indicated by the given angle and a unit-length axis + * of rotation. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation (already normalized). + * @return this matrix for chaining + * @throws NullPointerException + * if axis is null. + */ + public Matrix4 fromAngleNormalAxis(final double angle, final ReadOnlyVector3 axis) { + final double fCos = MathUtils.cos(angle); + final double fSin = MathUtils.sin(angle); + final double fOneMinusCos = 1.0 - fCos; + final double fX2 = axis.getX() * axis.getX(); + final double fY2 = axis.getY() * axis.getY(); + final double fZ2 = axis.getZ() * axis.getZ(); + final double fXYM = axis.getX() * axis.getY() * fOneMinusCos; + final double fXZM = axis.getX() * axis.getZ() * fOneMinusCos; + final double fYZM = axis.getY() * axis.getZ() * fOneMinusCos; + final double fXSin = axis.getX() * fSin; + final double fYSin = axis.getY() * fSin; + final double fZSin = axis.getZ() * fSin; + + _m00 = fX2 * fOneMinusCos + fCos; + _m01 = fXYM - fZSin; + _m02 = fXZM + fYSin; + _m10 = fXYM + fZSin; + _m11 = fY2 * fOneMinusCos + fCos; + _m12 = fYZM - fXSin; + _m20 = fXZM - fYSin; + _m21 = fYZM + fXSin; + _m22 = fZ2 * fOneMinusCos + fCos; + + return this; + } + + public Matrix4 applyRotation(final double angle, final double x, final double y, final double z) { + final double m00 = _m00, m01 = _m01, m02 = _m02, // + m10 = _m10, m11 = _m11, m12 = _m12, // + m20 = _m20, m21 = _m21, m22 = _m22, // + m30 = _m30, m31 = _m31, m32 = _m32; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + final double oneMinusCos = 1.0f - cosAngle; + final double xyOneMinusCos = x * y * oneMinusCos; + final double xzOneMinusCos = x * z * oneMinusCos; + final double yzOneMinusCos = y * z * oneMinusCos; + final double xSin = x * sinAngle; + final double ySin = y * sinAngle; + final double zSin = z * sinAngle; + + final double r00 = x * x * oneMinusCos + cosAngle; + final double r01 = xyOneMinusCos - zSin; + final double r02 = xzOneMinusCos + ySin; + final double r10 = xyOneMinusCos + zSin; + final double r11 = y * y * oneMinusCos + cosAngle; + final double r12 = yzOneMinusCos - xSin; + final double r20 = xzOneMinusCos - ySin; + final double r21 = yzOneMinusCos + xSin; + final double r22 = z * z * oneMinusCos + cosAngle; + + _m00 = m00 * r00 + m01 * r10 + m02 * r20; + _m01 = m00 * r01 + m01 * r11 + m02 * r21; + _m02 = m00 * r02 + m01 * r12 + m02 * r22; + // _m03 is unchanged + + _m10 = m10 * r00 + m11 * r10 + m12 * r20; + _m11 = m10 * r01 + m11 * r11 + m12 * r21; + _m12 = m10 * r02 + m11 * r12 + m12 * r22; + // _m13 is unchanged + + _m20 = m20 * r00 + m21 * r10 + m22 * r20; + _m21 = m20 * r01 + m21 * r11 + m22 * r21; + _m22 = m20 * r02 + m21 * r12 + m22 * r22; + // _m23 is unchanged + + _m30 = m30 * r00 + m31 * r10 + m32 * r20; + _m31 = m30 * r01 + m31 * r11 + m32 * r21; + _m32 = m30 * r02 + m31 * r12 + m32 * r22; + // _m33 is unchanged + + return this; + } + + public Matrix4 applyRotationX(final double angle) { + final double m01 = _m01, m02 = _m02, // + m11 = _m11, m12 = _m12, // + m21 = _m21, m22 = _m22, // + m31 = _m31, m32 = _m32; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m01 = m01 * cosAngle + m02 * sinAngle; + _m02 = m02 * cosAngle - m01 * sinAngle; + + _m11 = m11 * cosAngle + m12 * sinAngle; + _m12 = m12 * cosAngle - m11 * sinAngle; + + _m21 = m21 * cosAngle + m22 * sinAngle; + _m22 = m22 * cosAngle - m21 * sinAngle; + + _m31 = m31 * cosAngle + m32 * sinAngle; + _m32 = m32 * cosAngle - m31 * sinAngle; + + return this; + } + + public Matrix4 applyRotationY(final double angle) { + final double m00 = _m00, m02 = _m02, // + m10 = _m10, m12 = _m12, // + m20 = _m20, m22 = _m22, // + m30 = _m30, m32 = _m32; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m00 = m00 * cosAngle - m02 * sinAngle; + _m02 = m00 * sinAngle + m02 * cosAngle; + + _m10 = m10 * cosAngle - m12 * sinAngle; + _m12 = m10 * sinAngle + m12 * cosAngle; + + _m20 = m20 * cosAngle - m22 * sinAngle; + _m22 = m20 * sinAngle + m22 * cosAngle; + + _m30 = m30 * cosAngle - m32 * sinAngle; + _m32 = m30 * sinAngle + m32 * cosAngle; + + return this; + } + + public Matrix4 applyRotationZ(final double angle) { + final double m00 = _m00, m01 = _m01, // + m10 = _m10, m11 = _m11, // + m20 = _m20, m21 = _m21, // + m30 = _m30, m31 = _m31; + + final double cosAngle = Math.cos(angle); + final double sinAngle = Math.sin(angle); + + _m00 = m00 * cosAngle + m01 * sinAngle; + _m01 = m01 * cosAngle - m00 * sinAngle; + + _m10 = m10 * cosAngle + m11 * sinAngle; + _m11 = m11 * cosAngle - m10 * sinAngle; + + _m20 = m20 * cosAngle + m21 * sinAngle; + _m21 = m21 * cosAngle - m20 * sinAngle; + + _m20 = m30 * cosAngle + m31 * sinAngle; + _m21 = m31 * cosAngle - m30 * sinAngle; + + return this; + } + + /** + * M*T + * + * @param x + * @param y + * @param z + * @return + */ + public Matrix4 applyTranslationPost(final double x, final double y, final double z) { + _m03 = _m00 * x + _m01 * y + _m02 * z + _m03; + _m13 = _m10 * x + _m11 * y + _m12 * z + _m13; + _m23 = _m20 * x + _m21 * y + _m22 * z + _m23; + _m33 = _m30 * x + _m31 * y + _m32 * z + _m33; + + return this; + } + + /** + * T*M + * + * @param x + * @param y + * @param z + * @return + */ + public Matrix4 applyTranslationPre(final double x, final double y, final double z) { + _m03 = x; + _m13 = y; + _m23 = z; + + return this; + } + + /** + * @param index + * @param store + * the vector to store the result in. if null, a new one is created. + * @return the column specified by the index. + * @throws IllegalArgumentException + * if index is not in bounds [0, 3] + */ + @Override + public Vector4 getColumn(final int index, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + switch (index) { + case 0: + result.setX(_m00); + result.setY(_m10); + result.setZ(_m20); + result.setW(_m30); + break; + case 1: + result.setX(_m01); + result.setY(_m11); + result.setZ(_m21); + result.setW(_m31); + break; + case 2: + result.setX(_m02); + result.setY(_m12); + result.setZ(_m22); + result.setW(_m32); + break; + case 3: + result.setX(_m03); + result.setY(_m13); + result.setZ(_m23); + result.setW(_m33); + break; + default: + throw new IllegalArgumentException("invalid column index: " + index); + } + + return result; + } + + /** + * @param index + * @param store + * the vector to store the result in. if null, a new one is created. + * @return the row specified by the index. + * @throws IllegalArgumentException + * if index is not in bounds [0, 3] + */ + @Override + public Vector4 getRow(final int index, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + switch (index) { + case 0: + result.setX(_m00); + result.setY(_m01); + result.setZ(_m02); + result.setW(_m03); + break; + case 1: + result.setX(_m10); + result.setY(_m11); + result.setZ(_m12); + result.setW(_m13); + break; + case 2: + result.setX(_m20); + result.setY(_m21); + result.setZ(_m22); + result.setW(_m23); + break; + case 3: + result.setX(_m30); + result.setY(_m31); + result.setZ(_m32); + result.setW(_m33); + break; + default: + throw new IllegalArgumentException("invalid row index: " + index); + } + return result; + } + + /** + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * @return matrix data as a DoubleBuffer in row major order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 16 values. + */ + @Override + public DoubleBuffer toDoubleBuffer(final DoubleBuffer store) { + return toDoubleBuffer(store, true); + } + + /** + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * position. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a DoubleBuffer in the specified order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 16 values. + */ + @Override + public DoubleBuffer toDoubleBuffer(final DoubleBuffer store, final boolean rowMajor) { + if (rowMajor) { + store.put(_m00); + store.put(_m01); + store.put(_m02); + store.put(_m03); + store.put(_m10); + store.put(_m11); + store.put(_m12); + store.put(_m13); + store.put(_m20); + store.put(_m21); + store.put(_m22); + store.put(_m23); + store.put(_m30); + store.put(_m31); + store.put(_m32); + store.put(_m33); + } else { + store.put(_m00); + store.put(_m10); + store.put(_m20); + store.put(_m30); + store.put(_m01); + store.put(_m11); + store.put(_m21); + store.put(_m31); + store.put(_m02); + store.put(_m12); + store.put(_m22); + store.put(_m32); + store.put(_m03); + store.put(_m13); + store.put(_m23); + store.put(_m33); + } + + return store; + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * @return matrix data as a FloatBuffer in row major order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 16 values. + */ + @Override + public FloatBuffer toFloatBuffer(final FloatBuffer store) { + return toFloatBuffer(store, true); + } + + /** + * Note: data is cast to floats. + * + * @param store + * the buffer to store our matrix data in. Must not be null. Data is entered starting at current buffer + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a FloatBuffer in the specified order. The position is at the end of the inserted data. + * @throws NullPointerException + * if store is null. + * @throws BufferOverflowException + * if there is not enough room left in the buffer to write all 16 values. + */ + @Override + public FloatBuffer toFloatBuffer(final FloatBuffer store, final boolean rowMajor) { + if (rowMajor) { + store.put((float) _m00); + store.put((float) _m01); + store.put((float) _m02); + store.put((float) _m03); + store.put((float) _m10); + store.put((float) _m11); + store.put((float) _m12); + store.put((float) _m13); + store.put((float) _m20); + store.put((float) _m21); + store.put((float) _m22); + store.put((float) _m23); + store.put((float) _m30); + store.put((float) _m31); + store.put((float) _m32); + store.put((float) _m33); + } else { + store.put((float) _m00); + store.put((float) _m10); + store.put((float) _m20); + store.put((float) _m30); + store.put((float) _m01); + store.put((float) _m11); + store.put((float) _m21); + store.put((float) _m31); + store.put((float) _m02); + store.put((float) _m12); + store.put((float) _m22); + store.put((float) _m32); + store.put((float) _m03); + store.put((float) _m13); + store.put((float) _m23); + store.put((float) _m33); + } + + return store; + } + + /** + * @param store + * the double array to store our matrix data in. If null, a new array is created. + * @return matrix data as a double array in row major order. + * @throws IllegalArgumentException + * if the store is non-null and has a length < 16 + */ + @Override + public double[] toArray(final double[] store) { + return toArray(store, true); + } + + /** + * @param store + * the double array to store our matrix data in. If null, a new array is created. + * @param rowMajor + * if true, data is stored row by row. Otherwise it is stored column by column. + * @return matrix data as a double array in the specified order. + * @throws IllegalArgumentException + * if the store is non-null and has a length < 16 + */ + @Override + public double[] toArray(final double[] store, final boolean rowMajor) { + double[] result = store; + if (result == null) { + result = new double[16]; + } else if (result.length < 16) { + throw new IllegalArgumentException("store must be at least length 16."); + } + + if (rowMajor) { + result[0] = _m00; + result[1] = _m01; + result[2] = _m02; + result[3] = _m03; + result[4] = _m10; + result[5] = _m11; + result[6] = _m12; + result[7] = _m13; + result[8] = _m20; + result[9] = _m21; + result[10] = _m22; + result[11] = _m23; + result[12] = _m30; + result[13] = _m31; + result[14] = _m32; + result[15] = _m33; + } else { + result[0] = _m00; + result[1] = _m10; + result[2] = _m20; + result[3] = _m30; + result[4] = _m01; + result[5] = _m11; + result[6] = _m21; + result[7] = _m31; + result[8] = _m02; + result[9] = _m12; + result[10] = _m22; + result[11] = _m32; + result[12] = _m03; + result[13] = _m13; + result[14] = _m23; + result[15] = _m33; + } + + return result; + } + + /** + * Multiplies this matrix by the diagonal matrix formed by the given vector (v^D * M). If supplied, the result is + * stored into the supplied "store" matrix. + * + * @param vec + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store matrix, or a new matrix if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Matrix4 multiplyDiagonalPre(final ReadOnlyVector4 vec, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + result.set( // + vec.getX() * _m00, vec.getX() * _m01, vec.getX() * _m02, vec.getX() * _m03, // + vec.getY() * _m10, vec.getY() * _m11, vec.getY() * _m12, vec.getY() * _m13, // + vec.getZ() * _m20, vec.getZ() * _m21, vec.getZ() * _m22, vec.getZ() * _m23, // + vec.getW() * _m30, vec.getW() * _m31, vec.getW() * _m32, vec.getW() * _m33); + + return result; + } + + /** + * Multiplies this matrix by the diagonal matrix formed by the given vector (M * v^D). If supplied, the result is + * stored into the supplied "store" matrix. + * + * @param vec + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store matrix, or a new matrix if store is null. + * @throws NullPointerException + * if vec is null + */ + @Override + public Matrix4 multiplyDiagonalPost(final ReadOnlyVector4 vec, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + result.set( // + vec.getX() * _m00, vec.getY() * _m01, vec.getZ() * _m02, vec.getW() * _m03, // + vec.getX() * _m10, vec.getY() * _m11, vec.getZ() * _m12, vec.getW() * _m13, // + vec.getX() * _m20, vec.getY() * _m21, vec.getZ() * _m22, vec.getW() * _m23, // + vec.getX() * _m30, vec.getY() * _m31, vec.getZ() * _m32, vec.getW() * _m33); + + return result; + } + + /** + * @param matrix + * @return This matrix for chaining, modified internally to reflect multiplication against the given matrix + * @throws NullPointerException + * if matrix is null + */ + public Matrix4 multiplyLocal(final ReadOnlyMatrix4 matrix) { + return multiply(matrix, this); + } + + /** + * @param matrix + * @param store + * a matrix to store the result in. if null, a new matrix is created. Note that it IS safe for matrix and + * store to be the same object. + * @return this matrix multiplied by the given matrix. + * @throws NullPointerException + * if matrix is null. + */ + @Override + public Matrix4 multiply(final ReadOnlyMatrix4 matrix, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + final double temp00 = _m00 * matrix.getM00() + _m01 * matrix.getM10() + _m02 * matrix.getM20() + _m03 + * matrix.getM30(); + final double temp01 = _m00 * matrix.getM01() + _m01 * matrix.getM11() + _m02 * matrix.getM21() + _m03 + * matrix.getM31(); + final double temp02 = _m00 * matrix.getM02() + _m01 * matrix.getM12() + _m02 * matrix.getM22() + _m03 + * matrix.getM32(); + final double temp03 = _m00 * matrix.getM03() + _m01 * matrix.getM13() + _m02 * matrix.getM23() + _m03 + * matrix.getM33(); + + final double temp10 = _m10 * matrix.getM00() + _m11 * matrix.getM10() + _m12 * matrix.getM20() + _m13 + * matrix.getM30(); + final double temp11 = _m10 * matrix.getM01() + _m11 * matrix.getM11() + _m12 * matrix.getM21() + _m13 + * matrix.getM31(); + final double temp12 = _m10 * matrix.getM02() + _m11 * matrix.getM12() + _m12 * matrix.getM22() + _m13 + * matrix.getM32(); + final double temp13 = _m10 * matrix.getM03() + _m11 * matrix.getM13() + _m12 * matrix.getM23() + _m13 + * matrix.getM33(); + + final double temp20 = _m20 * matrix.getM00() + _m21 * matrix.getM10() + _m22 * matrix.getM20() + _m23 + * matrix.getM30(); + final double temp21 = _m20 * matrix.getM01() + _m21 * matrix.getM11() + _m22 * matrix.getM21() + _m23 + * matrix.getM31(); + final double temp22 = _m20 * matrix.getM02() + _m21 * matrix.getM12() + _m22 * matrix.getM22() + _m23 + * matrix.getM32(); + final double temp23 = _m20 * matrix.getM03() + _m21 * matrix.getM13() + _m22 * matrix.getM23() + _m23 + * matrix.getM33(); + + final double temp30 = _m30 * matrix.getM00() + _m31 * matrix.getM10() + _m32 * matrix.getM20() + _m33 + * matrix.getM30(); + final double temp31 = _m30 * matrix.getM01() + _m31 * matrix.getM11() + _m32 * matrix.getM21() + _m33 + * matrix.getM31(); + final double temp32 = _m30 * matrix.getM02() + _m31 * matrix.getM12() + _m32 * matrix.getM22() + _m33 + * matrix.getM32(); + final double temp33 = _m30 * matrix.getM03() + _m31 * matrix.getM13() + _m32 * matrix.getM23() + _m33 + * matrix.getM33(); + + result._m00 = temp00; + result._m01 = temp01; + result._m02 = temp02; + result._m03 = temp03; + result._m10 = temp10; + result._m11 = temp11; + result._m12 = temp12; + result._m13 = temp13; + result._m20 = temp20; + result._m21 = temp21; + result._m22 = temp22; + result._m23 = temp23; + result._m30 = temp30; + result._m31 = temp31; + result._m32 = temp32; + result._m33 = temp33; + + return result; + } + + /** + * Internally scales all values of this matrix by the given scalar. + * + * @param scalar + * @return this matrix for chaining. + */ + public Matrix4 multiplyLocal(final double scalar) { + _m00 *= scalar; + _m01 *= scalar; + _m02 *= scalar; + _m03 *= scalar; + _m10 *= scalar; + _m11 *= scalar; + _m12 *= scalar; + _m13 *= scalar; + _m20 *= scalar; + _m21 *= scalar; + _m22 *= scalar; + _m23 *= scalar; + _m30 *= scalar; + _m31 *= scalar; + _m32 *= scalar; + _m33 *= scalar; + + return this; + } + + /** + * @param matrix + * the matrix to add to this. + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * matrix and store to be the same object. + * @return the result. + * @throws NullPointerException + * if matrix is null + */ + @Override + public Matrix4 add(final ReadOnlyMatrix4 matrix, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + result._m00 = _m00 + matrix.getM00(); + result._m01 = _m01 + matrix.getM01(); + result._m02 = _m02 + matrix.getM02(); + result._m03 = _m03 + matrix.getM03(); + result._m10 = _m10 + matrix.getM10(); + result._m11 = _m11 + matrix.getM11(); + result._m12 = _m12 + matrix.getM12(); + result._m13 = _m13 + matrix.getM13(); + result._m20 = _m20 + matrix.getM20(); + result._m21 = _m21 + matrix.getM21(); + result._m22 = _m22 + matrix.getM22(); + result._m23 = _m23 + matrix.getM23(); + result._m30 = _m30 + matrix.getM30(); + result._m31 = _m31 + matrix.getM31(); + result._m32 = _m32 + matrix.getM32(); + result._m33 = _m33 + matrix.getM33(); + + return result; + } + + /** + * Internally adds the values of the given matrix to this matrix. + * + * @param matrix + * the matrix to add to this. + * @return this matrix for chaining + * @throws NullPointerException + * if matrix is null + */ + public Matrix4 addLocal(final ReadOnlyMatrix4 matrix) { + return add(matrix, this); + } + + /** + * @param matrix + * the matrix to subtract from this. + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * matrix and store to be the same object. + * @return the result. + * @throws NullPointerException + * if matrix is null + */ + @Override + public Matrix4 subtract(final ReadOnlyMatrix4 matrix, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + result._m00 = _m00 - matrix.getM00(); + result._m01 = _m01 - matrix.getM01(); + result._m02 = _m02 - matrix.getM02(); + result._m03 = _m03 - matrix.getM03(); + result._m10 = _m10 - matrix.getM10(); + result._m11 = _m11 - matrix.getM11(); + result._m12 = _m12 - matrix.getM12(); + result._m13 = _m13 - matrix.getM13(); + result._m20 = _m20 - matrix.getM20(); + result._m21 = _m21 - matrix.getM21(); + result._m22 = _m22 - matrix.getM22(); + result._m23 = _m23 - matrix.getM23(); + result._m30 = _m30 - matrix.getM30(); + result._m31 = _m31 - matrix.getM31(); + result._m32 = _m32 - matrix.getM32(); + result._m33 = _m33 - matrix.getM33(); + + return result; + } + + /** + * Internally subtracts the values of the given matrix from this matrix. + * + * @param matrix + * the matrix to subtract from this. + * @return this matrix for chaining + * @throws NullPointerException + * if matrix is null + */ + public Matrix4 subtractLocal(final ReadOnlyMatrix4 matrix) { + return subtract(matrix, this); + } + + /** + * Applies the given scale to this matrix and returns the result as a new matrix + * + * @param scale + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. + * @return the new matrix + * @throws NullPointerException + * if scale is null. + */ + @Override + public Matrix4 scale(final ReadOnlyVector4 scale, final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + return result.set( // + _m00 * scale.getX(), _m01 * scale.getY(), _m02 * scale.getZ(), _m03 * scale.getW(), // + _m10 * scale.getX(), _m11 * scale.getY(), _m12 * scale.getZ(), _m13 * scale.getW(), // + _m20 * scale.getX(), _m21 * scale.getY(), _m22 * scale.getZ(), _m23 * scale.getW(), // + _m30 * scale.getX(), _m31 * scale.getY(), _m32 * scale.getZ(), _m33 * scale.getW()); + } + + /** + * Applies the given scale to this matrix values internally + * + * @param scale + * @return this matrix for chaining. + * @throws NullPointerException + * if scale is null. + */ + public Matrix4 scaleLocal(final ReadOnlyVector4 scale) { + return scale(scale, this); + } + + /** + * transposes this matrix as a new matrix, basically flipping it across the diagonal + * + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. It is NOT safe for store + * to == this. + * @return this matrix for chaining. + * @see <a href="http://en.wikipedia.org/wiki/Transpose">wikipedia.org-Transpose</a> + */ + @Override + public Matrix4 transpose(final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + result._m00 = _m00; + result._m01 = _m10; + result._m02 = _m20; + result._m03 = _m30; + result._m10 = _m01; + result._m11 = _m11; + result._m12 = _m21; + result._m13 = _m31; + result._m20 = _m02; + result._m21 = _m12; + result._m22 = _m22; + result._m23 = _m32; + result._m30 = _m03; + result._m31 = _m13; + result._m32 = _m23; + result._m33 = _m33; + + return result; + } + + /** + * transposes this matrix in place + * + * @return this matrix for chaining. + * @see <a href="http://en.wikipedia.org/wiki/Transpose">wikipedia.org-Transpose</a> + */ + public Matrix4 transposeLocal() { + final double m01 = _m01; + final double m02 = _m02; + final double m03 = _m03; + final double m12 = _m12; + final double m13 = _m13; + final double m23 = _m23; + _m01 = _m10; + _m02 = _m20; + _m03 = _m30; + _m12 = _m21; + _m13 = _m31; + _m23 = _m32; + _m10 = m01; + _m20 = m02; + _m30 = m03; + _m21 = m12; + _m31 = m13; + _m32 = m23; + return this; + } + + /** + * @param store + * a matrix to store the result in. If store is null, a new matrix is created. Note that it IS safe for + * store == this. + * @return a matrix that represents this matrix, inverted. + * @throws ArithmeticException + * if this matrix can not be inverted. + */ + @Override + public Matrix4 invert(final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + final double dA0 = _m00 * _m11 - _m01 * _m10; + final double dA1 = _m00 * _m12 - _m02 * _m10; + final double dA2 = _m00 * _m13 - _m03 * _m10; + final double dA3 = _m01 * _m12 - _m02 * _m11; + final double dA4 = _m01 * _m13 - _m03 * _m11; + final double dA5 = _m02 * _m13 - _m03 * _m12; + final double dB0 = _m20 * _m31 - _m21 * _m30; + final double dB1 = _m20 * _m32 - _m22 * _m30; + final double dB2 = _m20 * _m33 - _m23 * _m30; + final double dB3 = _m21 * _m32 - _m22 * _m31; + final double dB4 = _m21 * _m33 - _m23 * _m31; + final double dB5 = _m22 * _m33 - _m23 * _m32; + final double det = dA0 * dB5 - dA1 * dB4 + dA2 * dB3 + dA3 * dB2 - dA4 * dB1 + dA5 * dB0; + + if (Math.abs(det) <= MathUtils.EPSILON) { + throw new ArithmeticException("This matrix cannot be inverted"); + } + + final double temp00 = +_m11 * dB5 - _m12 * dB4 + _m13 * dB3; + final double temp10 = -_m10 * dB5 + _m12 * dB2 - _m13 * dB1; + final double temp20 = +_m10 * dB4 - _m11 * dB2 + _m13 * dB0; + final double temp30 = -_m10 * dB3 + _m11 * dB1 - _m12 * dB0; + final double temp01 = -_m01 * dB5 + _m02 * dB4 - _m03 * dB3; + final double temp11 = +_m00 * dB5 - _m02 * dB2 + _m03 * dB1; + final double temp21 = -_m00 * dB4 + _m01 * dB2 - _m03 * dB0; + final double temp31 = +_m00 * dB3 - _m01 * dB1 + _m02 * dB0; + final double temp02 = +_m31 * dA5 - _m32 * dA4 + _m33 * dA3; + final double temp12 = -_m30 * dA5 + _m32 * dA2 - _m33 * dA1; + final double temp22 = +_m30 * dA4 - _m31 * dA2 + _m33 * dA0; + final double temp32 = -_m30 * dA3 + _m31 * dA1 - _m32 * dA0; + final double temp03 = -_m21 * dA5 + _m22 * dA4 - _m23 * dA3; + final double temp13 = +_m20 * dA5 - _m22 * dA2 + _m23 * dA1; + final double temp23 = -_m20 * dA4 + _m21 * dA2 - _m23 * dA0; + final double temp33 = +_m20 * dA3 - _m21 * dA1 + _m22 * dA0; + + result.set(temp00, temp01, temp02, temp03, temp10, temp11, temp12, temp13, temp20, temp21, temp22, temp23, + temp30, temp31, temp32, temp33); + result.multiplyLocal(1.0 / det); + + return result; + } + + /** + * inverts this matrix locally. + * + * @return this matrix inverted internally. + * @throws ArithmeticException + * if this matrix can not be inverted. + */ + public Matrix4 invertLocal() { + return invert(this); + } + + /** + * @param store + * The matrix to store the result in. If null, a new matrix is created. + * @return The adjugate, or classical adjoint, of this matrix + * @see <a href="http://en.wikipedia.org/wiki/Adjugate_matrix">wikipedia.org-Adjugate_matrix</a> + */ + @Override + public Matrix4 adjugate(final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + final double dA0 = _m00 * _m11 - _m01 * _m10; + final double dA1 = _m00 * _m12 - _m02 * _m10; + final double dA2 = _m00 * _m13 - _m03 * _m10; + final double dA3 = _m01 * _m12 - _m02 * _m11; + final double dA4 = _m01 * _m13 - _m03 * _m11; + final double dA5 = _m02 * _m13 - _m03 * _m12; + final double dB0 = _m20 * _m31 - _m21 * _m30; + final double dB1 = _m20 * _m32 - _m22 * _m30; + final double dB2 = _m20 * _m33 - _m23 * _m30; + final double dB3 = _m21 * _m32 - _m22 * _m31; + final double dB4 = _m21 * _m33 - _m23 * _m31; + final double dB5 = _m22 * _m33 - _m23 * _m32; + + final double temp00 = +_m11 * dB5 - _m12 * dB4 + _m13 * dB3; + final double temp10 = -_m10 * dB5 + _m12 * dB2 - _m13 * dB1; + final double temp20 = +_m10 * dB4 - _m11 * dB2 + _m13 * dB0; + final double temp30 = -_m10 * dB3 + _m11 * dB1 - _m12 * dB0; + final double temp01 = -_m01 * dB5 + _m02 * dB4 - _m03 * dB3; + final double temp11 = +_m00 * dB5 - _m02 * dB2 + _m03 * dB1; + final double temp21 = -_m00 * dB4 + _m01 * dB2 - _m03 * dB0; + final double temp31 = +_m00 * dB3 - _m01 * dB1 + _m02 * dB0; + final double temp02 = +_m31 * dA5 - _m32 * dA4 + _m33 * dA3; + final double temp12 = -_m30 * dA5 + _m32 * dA2 - _m33 * dA1; + final double temp22 = +_m30 * dA4 - _m31 * dA2 + _m33 * dA0; + final double temp32 = -_m30 * dA3 + _m31 * dA1 - _m32 * dA0; + final double temp03 = -_m21 * dA5 + _m22 * dA4 - _m23 * dA3; + final double temp13 = +_m20 * dA5 - _m22 * dA2 + _m23 * dA1; + final double temp23 = -_m20 * dA4 + _m21 * dA2 - _m23 * dA0; + final double temp33 = +_m20 * dA3 - _m21 * dA1 + _m22 * dA0; + + return result.set(temp00, temp01, temp02, temp03, temp10, temp11, temp12, temp13, temp20, temp21, temp22, + temp23, temp30, temp31, temp32, temp33); + } + + /** + * @return this matrix, modified to represent its adjugate, or classical adjoint + * @see <a href="http://en.wikipedia.org/wiki/Adjugate_matrix">wikipedia.org-Adjugate_matrix</a> + */ + public Matrix4 adjugateLocal() { + return adjugate(this); + } + + /** + * @return the determinate of this matrix + * @see <a href="http://en.wikipedia.org/wiki/Determinant">wikipedia.org-Determinant</a> + */ + @Override + public double determinant() { + final double val1 = _m11 * _m22 * _m33 + _m12 * _m23 * _m31 + _m13 * _m21 * _m32 - // + _m13 * _m22 * _m31 - _m12 * _m21 * _m33 - _m11 * _m23 * _m32; + final double val2 = _m10 * _m22 * _m33 + _m12 * _m23 * _m30 + _m13 * _m20 * _m32 - // + _m13 * _m22 * _m30 - _m12 * _m20 * _m33 - _m10 * _m23 * _m32; + final double val3 = _m10 * _m21 * _m33 + _m11 * _m23 * _m30 + _m13 * _m20 * _m31 - // + _m13 * _m21 * _m30 - _m11 * _m20 * _m33 - _m10 * _m23 * _m31; + final double val4 = _m10 * _m21 * _m32 + _m11 * _m22 * _m30 + _m12 * _m20 * _m31 - // + _m12 * _m21 * _m30 - _m11 * _m20 * _m32 - _m10 * _m22 * _m31; + + return _m00 * val1 - _m01 * val2 + _m02 * val3 - _m03 * val4; + } + + /** + * Multiplies the given vector by this matrix (v * M). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param vector + * the vector to multiply this matrix by. + * @param store + * the vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vector and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vector is null + */ + @Override + public Vector4 applyPre(final ReadOnlyVector4 vector, Vector4 store) { + if (store == null) { + store = new Vector4(); + } + + final double x = vector.getX(); + final double y = vector.getY(); + final double z = vector.getZ(); + final double w = vector.getW(); + + store.setX(_m00 * x + _m10 * y + _m20 * z + _m30 * w); + store.setY(_m01 * x + _m11 * y + _m21 * z + _m31 * w); + store.setZ(_m02 * x + _m12 * y + _m22 * z + _m32 * w); + store.setW(_m03 * x + _m13 * y + _m23 * z + _m33 * w); + + return store; + } + + /** + * Multiplies the given vector by this matrix (M * v). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param vector + * the vector to multiply this matrix by. + * @param store + * the vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vector and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vector is null + */ + @Override + public Vector4 applyPost(final ReadOnlyVector4 vector, Vector4 store) { + if (store == null) { + store = new Vector4(); + } + + final double x = vector.getX(); + final double y = vector.getY(); + final double z = vector.getZ(); + final double w = vector.getW(); + + store.setX(_m00 * x + _m01 * y + _m02 * z + _m03 * w); + store.setY(_m10 * x + _m11 * y + _m12 * z + _m13 * w); + store.setZ(_m20 * x + _m21 * y + _m22 * z + _m23 * w); + store.setW(_m30 * x + _m31 * y + _m32 * z + _m33 * w); + + return store; + } + + /** + * Multiplies the given point by this matrix (M * p). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param point + * the point to multiply against this matrix. + * @param store + * the point to store the result in. If store is null, a new Vector3 object is created. Note that it IS + * safe for point and store to be the same object. + * @return the store object, or a new Vector3 if store is null. + * @throws NullPointerException + * if point is null + */ + @Override + public Vector3 applyPostPoint(final ReadOnlyVector3 point, Vector3 store) { + if (store == null) { + store = new Vector3(); + } + + final double x = point.getX(); + final double y = point.getY(); + final double z = point.getZ(); + + store.setX(_m00 * x + _m01 * y + _m02 * z + _m03); + store.setY(_m10 * x + _m11 * y + _m12 * z + _m13); + store.setZ(_m20 * x + _m21 * y + _m22 * z + _m23); + + return store; + } + + /** + * Multiplies the given vector by this matrix (M * v). If supplied, the result is stored into the supplied "store" + * vector. + * + * @param vector + * the vector to multiply this matrix by. + * @param store + * the vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vector and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vector is null + */ + @Override + public Vector3 applyPostVector(final ReadOnlyVector3 vector, Vector3 store) { + if (store == null) { + store = new Vector3(); + } + + final double x = vector.getX(); + final double y = vector.getY(); + final double z = vector.getZ(); + + store.setX(_m00 * x + _m01 * y + _m02 * z); + store.setY(_m10 * x + _m11 * y + _m12 * z); + store.setZ(_m20 * x + _m21 * y + _m22 * z); + + return store; + } + + /** + * Check a matrix... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param matrix + * the vector to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyMatrix4 matrix) { + if (matrix == null) { + return false; + } + + if (Double.isNaN(matrix.getM00()) || Double.isInfinite(matrix.getM00())) { + return false; + } else if (Double.isNaN(matrix.getM01()) || Double.isInfinite(matrix.getM01())) { + return false; + } else if (Double.isNaN(matrix.getM02()) || Double.isInfinite(matrix.getM02())) { + return false; + } else if (Double.isNaN(matrix.getM03()) || Double.isInfinite(matrix.getM03())) { + return false; + } else if (Double.isNaN(matrix.getM10()) || Double.isInfinite(matrix.getM10())) { + return false; + } else if (Double.isNaN(matrix.getM11()) || Double.isInfinite(matrix.getM11())) { + return false; + } else if (Double.isNaN(matrix.getM12()) || Double.isInfinite(matrix.getM12())) { + return false; + } else if (Double.isNaN(matrix.getM13()) || Double.isInfinite(matrix.getM13())) { + return false; + } else if (Double.isNaN(matrix.getM20()) || Double.isInfinite(matrix.getM20())) { + return false; + } else if (Double.isNaN(matrix.getM21()) || Double.isInfinite(matrix.getM21())) { + return false; + } else if (Double.isNaN(matrix.getM22()) || Double.isInfinite(matrix.getM22())) { + return false; + } else if (Double.isNaN(matrix.getM23()) || Double.isInfinite(matrix.getM23())) { + return false; + } else if (Double.isNaN(matrix.getM30()) || Double.isInfinite(matrix.getM30())) { + return false; + } else if (Double.isNaN(matrix.getM31()) || Double.isInfinite(matrix.getM31())) { + return false; + } else if (Double.isNaN(matrix.getM32()) || Double.isInfinite(matrix.getM32())) { + return false; + } else if (Double.isNaN(matrix.getM33()) || Double.isInfinite(matrix.getM33())) { + return false; + } + + return true; + } + + /** + * @return true if this Matrix is orthonormal + * @see <a href="http://en.wikipedia.org/wiki/Orthogonal_matrix">wikipedia.org-Orthogonal matrix</a> + */ + public boolean isOrthonormal() { + final double m00 = _m00; + final double m01 = _m01; + final double m02 = _m02; + final double m03 = _m03; + final double m10 = _m10; + final double m11 = _m11; + final double m12 = _m12; + final double m13 = _m13; + final double m20 = _m20; + final double m21 = _m21; + final double m22 = _m22; + final double m23 = _m23; + final double m30 = _m30; + final double m31 = _m31; + final double m32 = _m32; + final double m33 = _m33; + + if (Math.abs(m00 * m00 + m01 * m01 + m02 * m02 + m03 * m03 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m00 * m10 + m01 * m11 + m02 * m12 + m03 * m13 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m00 * m20 + m01 * m21 + m02 * m22 + m03 * m23 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m00 * m30 + m01 * m31 + m02 * m32 + m03 * m33 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + + if (Math.abs(m10 * m00 + m11 * m01 + m12 * m02 + m13 * m03 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m10 * m10 + m11 * m11 + m12 * m12 + m13 * m13 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m10 * m20 + m11 * m21 + m12 * m22 + m13 * m23 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m10 * m30 + m11 * m31 + m12 * m32 + m13 * m33 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + + if (Math.abs(m20 * m00 + m21 * m01 + m22 * m02 + m23 * m03 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m20 * m10 + m21 * m11 + m22 * m12 + m23 * m13 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m20 * m20 + m21 * m21 + m22 * m22 + m23 * m23 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m20 * m30 + m21 * m31 + m22 * m32 + m23 * m33 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + + if (Math.abs(m30 * m00 + m31 * m01 + m32 * m02 + m33 * m03 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m30 * m10 + m31 * m11 + m32 * m12 + m33 * m13 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m30 * m20 + m31 * m21 + m32 * m22 + m33 * m23 - 0.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + if (Math.abs(m30 * m30 + m31 * m31 + m32 * m32 + m33 * m33 - 1.0) > MathUtils.ZERO_TOLERANCE) { + return false; + } + + return true; + } + + /** + * @return the string representation of this matrix. + */ + @Override + public String toString() { + final StringBuffer result = new StringBuffer("com.ardor3d.math.Matrix4\n[\n"); + result.append(" "); + result.append(_m00); + result.append(" "); + result.append(_m01); + result.append(" "); + result.append(_m02); + result.append(" "); + result.append(_m03); + result.append(" \n"); + + result.append(" "); + result.append(_m10); + result.append(" "); + result.append(_m11); + result.append(" "); + result.append(_m12); + result.append(" "); + result.append(_m13); + result.append(" \n"); + + result.append(" "); + result.append(_m20); + result.append(" "); + result.append(_m21); + result.append(" "); + result.append(_m22); + result.append(" "); + result.append(_m23); + result.append(" \n"); + + result.append(" "); + result.append(_m30); + result.append(" "); + result.append(_m31); + result.append(" "); + result.append(_m32); + result.append(" "); + result.append(_m33); + result.append(" \n"); + + result.append("]"); + return result.toString(); + } + + /** + * @return returns a unique code for this matrix object based on its values. If two matrices are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + long val = Double.doubleToLongBits(_m00); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m01); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m02); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m03); + result += 31 * result + (int) (val ^ val >>> 32); + + val = Double.doubleToLongBits(_m10); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m11); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m12); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m13); + result += 31 * result + (int) (val ^ val >>> 32); + + val = Double.doubleToLongBits(_m20); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m21); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m22); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m23); + result += 31 * result + (int) (val ^ val >>> 32); + + val = Double.doubleToLongBits(_m30); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m31); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m32); + result += 31 * result + (int) (val ^ val >>> 32); + val = Double.doubleToLongBits(_m33); + result += 31 * result + (int) (val ^ val >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this matrix and the provided matrix have the double values that are within the + * MathUtils.ZERO_TOLERANCE. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyMatrix4)) { + return false; + } + final ReadOnlyMatrix4 comp = (ReadOnlyMatrix4) o; + if (Math.abs(getM00() - comp.getM00()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM01() - comp.getM01()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM02() - comp.getM02()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM03() - comp.getM03()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM10() - comp.getM10()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM11() - comp.getM11()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM12() - comp.getM12()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM13() - comp.getM13()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM20() - comp.getM20()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM21() - comp.getM21()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM22() - comp.getM22()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM23() - comp.getM23()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM30() - comp.getM30()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM31() - comp.getM31()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM32() - comp.getM32()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } else if (Math.abs(getM33() - comp.getM33()) > Matrix4.ALLOWED_DEVIANCE) { + return false; + } + + return true; + } + + /** + * @param o + * the object to compare for equality + * @return true if this matrix and the provided matrix have the exact same double values. + */ + public boolean strictEquals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyMatrix4)) { + return false; + } + final ReadOnlyMatrix4 comp = (ReadOnlyMatrix4) o; + if (getM00() != comp.getM00()) { + return false; + } else if (getM01() != comp.getM01()) { + return false; + } else if (getM02() != comp.getM02()) { + return false; + } else if (getM03() != comp.getM03()) { + return false; + } else if (getM10() != comp.getM10()) { + return false; + } else if (getM11() != comp.getM11()) { + return false; + } else if (getM12() != comp.getM12()) { + return false; + } else if (getM13() != comp.getM13()) { + return false; + } else if (getM20() != comp.getM20()) { + return false; + } else if (getM21() != comp.getM21()) { + return false; + } else if (getM22() != comp.getM22()) { + return false; + } else if (getM23() != comp.getM23()) { + return false; + } else if (getM30() != comp.getM30()) { + return false; + } else if (getM31() != comp.getM31()) { + return false; + } else if (getM32() != comp.getM32()) { + return false; + } else if (getM33() != comp.getM33()) { + return false; + } + + return true; + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Matrix4 clone() { + return new Matrix4(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Matrix4> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_m00, "m00", 1.0); + capsule.write(_m01, "m01", 0.0); + capsule.write(_m02, "m02", 0.0); + capsule.write(_m03, "m03", 0.0); + capsule.write(_m10, "m10", 0.0); + capsule.write(_m11, "m11", 1.0); + capsule.write(_m12, "m12", 0.0); + capsule.write(_m13, "m13", 0.0); + capsule.write(_m20, "m20", 0.0); + capsule.write(_m21, "m21", 0.0); + capsule.write(_m22, "m22", 1.0); + capsule.write(_m23, "m23", 0.0); + capsule.write(_m30, "m30", 0.0); + capsule.write(_m31, "m31", 0.0); + capsule.write(_m32, "m32", 0.0); + capsule.write(_m33, "m33", 1.0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _m00 = capsule.readDouble("m00", 1.0); + _m01 = capsule.readDouble("m01", 0.0); + _m02 = capsule.readDouble("m02", 0.0); + _m03 = capsule.readDouble("m03", 0.0); + _m10 = capsule.readDouble("m10", 0.0); + _m11 = capsule.readDouble("m11", 1.0); + _m12 = capsule.readDouble("m12", 0.0); + _m13 = capsule.readDouble("m13", 0.0); + _m20 = capsule.readDouble("m20", 0.0); + _m21 = capsule.readDouble("m21", 0.0); + _m22 = capsule.readDouble("m22", 1.0); + _m23 = capsule.readDouble("m23", 0.0); + _m30 = capsule.readDouble("m30", 0.0); + _m31 = capsule.readDouble("m31", 0.0); + _m32 = capsule.readDouble("m32", 0.0); + _m33 = capsule.readDouble("m33", 1.0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + _m00 = in.readDouble(); + _m01 = in.readDouble(); + _m02 = in.readDouble(); + _m03 = in.readDouble(); + _m10 = in.readDouble(); + _m11 = in.readDouble(); + _m12 = in.readDouble(); + _m13 = in.readDouble(); + _m20 = in.readDouble(); + _m21 = in.readDouble(); + _m22 = in.readDouble(); + _m23 = in.readDouble(); + _m30 = in.readDouble(); + _m31 = in.readDouble(); + _m32 = in.readDouble(); + _m33 = in.readDouble(); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(_m00); + out.writeDouble(_m01); + out.writeDouble(_m02); + out.writeDouble(_m03); + out.writeDouble(_m10); + out.writeDouble(_m11); + out.writeDouble(_m12); + out.writeDouble(_m13); + out.writeDouble(_m20); + out.writeDouble(_m21); + out.writeDouble(_m22); + out.writeDouble(_m23); + out.writeDouble(_m30); + out.writeDouble(_m31); + out.writeDouble(_m32); + out.writeDouble(_m33); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Matrix4 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Matrix4 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Matrix4.MAT_POOL.fetch(); + } else { + return new Matrix4(); + } + } + + /** + * Releases a Matrix4 back to be used by a future call to fetchTempInstance. TAKE CARE: this Matrix4 object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param mat + * the Matrix4 to release. + */ + public final static void releaseTempInstance(final Matrix4 mat) { + if (MathConstants.useMathPools) { + Matrix4.MAT_POOL.release(mat); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/ObjectPool.java b/ardor3d-math/src/main/java/com/ardor3d/math/ObjectPool.java new file mode 100644 index 0000000..2c2110b --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/ObjectPool.java @@ -0,0 +1,67 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.util.ArrayList; +import java.util.List; + +/** + * Simple Object pool for use with our Math Library to help reduce object creation during calculations. This class uses + * a ThreadLocal pool of objects to allow for fast multi-threaded use. + * + * @param <T> + * the type. + */ +public abstract class ObjectPool<T extends Poolable> { + private final ThreadLocal<List<T>> _pool = new ThreadLocal<List<T>>() { + @Override + protected List<T> initialValue() { + return new ArrayList<T>(_maxSize); + } + }; + + private final int _maxSize; + + protected ObjectPool(final int maxSize) { + _maxSize = maxSize; + } + + protected abstract T newInstance(); + + public final T fetch() { + final List<T> objects = _pool.get(); + return objects.isEmpty() ? newInstance() : objects.remove(objects.size() - 1); + } + + public final void release(final T object) { + if (object == null) { + throw new RuntimeException("Should not release null objects into ObjectPool."); + } + + final List<T> objects = _pool.get(); + if (objects.size() < _maxSize) { + objects.add(object); + } + } + + public static <T extends Poolable> ObjectPool<T> create(final Class<T> clazz, final int maxSize) { + return new ObjectPool<T>(maxSize) { + @Override + protected T newInstance() { + try { + return clazz.newInstance(); + } catch (final Exception e) { + throw new RuntimeException(e); + } + } + }; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Plane.java b/ardor3d-math/src/main/java/com/ardor3d/math/Plane.java new file mode 100644 index 0000000..7567310 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Plane.java @@ -0,0 +1,338 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyPlane; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * A representation of a mathematical plane using a normal vector and a plane constant (d) whose absolute value + * represents the distance from the origin to the plane. It is generally calculated by taking a point (X) on the plane + * and finding its dot-product with the plane's normal vector. iow: d = N dot X + */ +public class Plane implements Cloneable, Savable, Externalizable, ReadOnlyPlane, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Plane> PLANE_POOL = ObjectPool.create(Plane.class, MathConstants.maxMathPoolSize); + + public static final ReadOnlyPlane XZ = new Plane(Vector3.UNIT_Y, 0); + public static final ReadOnlyPlane XY = new Plane(Vector3.UNIT_Z, 0); + public static final ReadOnlyPlane YZ = new Plane(Vector3.UNIT_X, 0); + + protected final Vector3 _normal = new Vector3(); + protected double _constant = 0; + + /** + * Constructs a new plane with a normal of (0, 1, 0) and a constant value of 0. + */ + public Plane() { + this(Vector3.UNIT_Y, 0); + } + + /** + * Copy constructor. + * + * @param source + * the plane to copy from. + */ + public Plane(final ReadOnlyPlane source) { + this(source.getNormal(), source.getConstant()); + } + + /** + * Constructs a new plane using the supplied normal vector and plane constant + * + * @param normal + * @param constant + */ + public Plane(final ReadOnlyVector3 normal, final double constant) { + _normal.set(normal); + _constant = constant; + } + + @Override + public double getConstant() { + return _constant; + } + + /** + * + * @return normal as a readable vector + */ + @Override + public ReadOnlyVector3 getNormal() { + return _normal; + } + + /** + * Sets the value of this plane to the constant and normal values of the provided source plane. + * + * @param source + * @return this plane for chaining + * @throws NullPointerException + * if source is null. + */ + public Plane set(final ReadOnlyPlane source) { + setConstant(source.getConstant()); + setNormal(source.getNormal()); + return this; + } + + /** + * Sets the constant value of this plane to the given double value. + * + * @param constant + */ + public void setConstant(final double constant) { + _constant = constant; + } + + /** + * Sets the plane normal to the values of the given vector. + * + * @param normal + * @throws NullPointerException + * if normal is null. + */ + public void setNormal(final ReadOnlyVector3 normal) { + _normal.set(normal); + } + + /** + * @param point + * @return the distance from this plane to a provided point. If the point is on the negative side of the plane the + * distance returned is negative, otherwise it is positive. If the point is on the plane, it is zero. + * @throws NullPointerException + * if point is null. + */ + @Override + public double pseudoDistance(final ReadOnlyVector3 point) { + return _normal.dot(point) - _constant; + } + + /** + * @param point + * @return the side of this plane on which the given point lies. + * @see Side + * @throws NullPointerException + * if point is null. + */ + @Override + public Side whichSide(final ReadOnlyVector3 point) { + final double dis = pseudoDistance(point); + if (dis < 0) { + return Side.Inside; + } else if (dis > 0) { + return Side.Outside; + } else { + return Side.Neither; + } + } + + /** + * Sets this plane to the plane defined by the given three points. + * + * @param pointA + * @param pointB + * @param pointC + * @return this plane for chaining + * @throws NullPointerException + * if one or more of the points are null. + */ + public Plane setPlanePoints(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, final ReadOnlyVector3 pointC) { + _normal.set(pointB).subtractLocal(pointA); + _normal.crossLocal(pointC.getX() - pointA.getX(), pointC.getY() - pointA.getY(), pointC.getZ() - pointA.getZ()) + .normalizeLocal(); + _constant = _normal.dot(pointA); + return this; + } + + /** + * Reflects an incoming vector across the normal of this Plane. + * + * @param unitVector + * the incoming vector. Must be a unit vector. + * @param store + * optional Vector to store the result in. May be the same as the unitVector. + * @return the reflected vector. + */ + @Override + public Vector3 reflectVector(final ReadOnlyVector3 unitVector, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final double dotProd = _normal.dot(unitVector) * 2; + result.set(unitVector).subtractLocal(_normal.getX() * dotProd, _normal.getY() * dotProd, + _normal.getZ() * dotProd); + return result; + } + + /** + * Check a plane... if it is null or its constant, or the doubles of its normal are NaN or infinite, return false. + * Else return true. + * + * @param plane + * the plane to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyPlane plane) { + if (plane == null) { + return false; + } + if (Double.isNaN(plane.getConstant()) || Double.isInfinite(plane.getConstant())) { + return false; + } + + return Vector3.isValid(plane.getNormal()); + } + + /** + * @return the string representation of this plane. + */ + @Override + public String toString() { + return "com.ardor3d.math.Plane [Normal: " + _normal + " - Constant: " + _constant + "]"; + } + + /** + * @return returns a unique code for this plane object based on its values. If two planes are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _normal.hashCode(); + + final long c = Double.doubleToLongBits(getConstant()); + result += 31 * result + (int) (c ^ c >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this plane and the provided plane have the same constant and normal values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyPlane)) { + return false; + } + final ReadOnlyPlane comp = (ReadOnlyPlane) o; + return getConstant() == comp.getConstant() && _normal.equals(comp.getNormal()); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Plane clone() { + return new Plane(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Plane> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_normal, "normal", new Vector3(Vector3.UNIT_Y)); + capsule.write(_constant, "constant", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _normal.set((Vector3) capsule.readSavable("normal", new Vector3(Vector3.UNIT_Y))); + _constant = capsule.readDouble("constant", 0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setNormal((Vector3) in.readObject()); + setConstant(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeObject(_normal); + out.writeDouble(getConstant()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Plane that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Plane fetchTempInstance() { + if (MathConstants.useMathPools) { + return Plane.PLANE_POOL.fetch(); + } else { + return new Plane(); + } + } + + /** + * Releases a Plane back to be used by a future call to fetchTempInstance. TAKE CARE: this Plane object should no + * longer have other classes referencing it or "Bad Things" will happen. + * + * @param plane + * the Plane to release. + */ + public final static void releaseTempInstance(final Plane plane) { + if (MathConstants.useMathPools) { + Plane.PLANE_POOL.release(plane); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Poolable.java b/ardor3d-math/src/main/java/com/ardor3d/math/Poolable.java new file mode 100644 index 0000000..46ec934 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Poolable.java @@ -0,0 +1,13 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +public interface Poolable {} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Quaternion.java b/ardor3d-math/src/main/java/com/ardor3d/math/Quaternion.java new file mode 100644 index 0000000..7cb1b3b --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Quaternion.java @@ -0,0 +1,1560 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyMatrix3; +import com.ardor3d.math.type.ReadOnlyQuaternion; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Quaternion represents a 4 value math object used in Ardor3D to describe rotations. It has the advantage of being able + * to avoid lock by adding a 4th dimension to rotation. + * + * Note: some algorithms in this class were ported from Eberly, Wolfram, Game Gems and others to Java. + */ +public class Quaternion implements Cloneable, Savable, Externalizable, ReadOnlyQuaternion, Poolable { + + /** Used with equals method to determine if two Quaternions are close enough to be considered equal. */ + public static final double ALLOWED_DEVIANCE = 0.00000001; + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Quaternion> QUAT_POOL = ObjectPool.create(Quaternion.class, + MathConstants.maxMathPoolSize); + + /** + * x=0, y=0, z=0, w=1 + */ + public final static ReadOnlyQuaternion IDENTITY = new Quaternion(0, 0, 0, 1); + + protected double _x = 0; + protected double _y = 0; + protected double _z = 0; + protected double _w = 1; + + /** + * Constructs a new quaternion set to (0, 0, 0, 1). + */ + public Quaternion() { + this(Quaternion.IDENTITY); + } + + /** + * Constructs a new quaternion set to the (x, y, z, w) values of the given source quaternion. + * + * @param source + */ + public Quaternion(final ReadOnlyQuaternion source) { + this(source.getX(), source.getY(), source.getZ(), source.getW()); + } + + /** + * Constructs a new quaternion set to (x, y, z, w). + * + * @param x + * @param y + * @param z + * @param w + */ + public Quaternion(final double x, final double y, final double z, final double w) { + _x = x; + _y = y; + _z = z; + _w = w; + } + + @Override + public double getX() { + return _x; + } + + @Override + public double getY() { + return _y; + } + + @Override + public double getZ() { + return _z; + } + + @Override + public double getW() { + return _w; + } + + @Override + public float getXf() { + return (float) _x; + } + + @Override + public float getYf() { + return (float) _y; + } + + @Override + public float getZf() { + return (float) _z; + } + + @Override + public float getWf() { + return (float) _w; + } + + /** + * Stores the double values of this quaternion in the given double array as (x,y,z,w). + * + * @param store + * The array in which to store the values of this quaternion. If null, a new double[4] array is created. + * @return the double array + * @throws ArrayIndexOutOfBoundsException + * if store is not null and is not at least length 4 + */ + @Override + public double[] toArray(final double[] store) { + double[] result = store; + if (result == null) { + result = new double[4]; + } + result[3] = getW(); + result[2] = getZ(); + result[1] = getY(); + result[0] = getX(); + return result; + } + + /** + * Sets the x component of this quaternion to the given double value. + * + * @param x + */ + public void setX(final double x) { + _x = x; + } + + /** + * Sets the y component of this quaternion to the given double value. + * + * @param y + */ + public void setY(final double y) { + _y = y; + } + + /** + * Sets the z component of this quaternion to the given double value. + * + * @param z + */ + public void setZ(final double z) { + _z = z; + } + + /** + * Sets the w component of this quaternion to the given double value. + * + * @param w + */ + public void setW(final double w) { + _w = w; + } + + /** + * Sets the value of this quaternion to (x, y, z, w) + * + * @param x + * @param y + * @param z + * @param w + * @return this quaternion for chaining + */ + public Quaternion set(final double x, final double y, final double z, final double w) { + setX(x); + setY(y); + setZ(z); + setW(w); + return this; + } + + /** + * Sets the value of this quaternion to the (x, y, z, w) values of the provided source quaternion. + * + * @param source + * @return this quaternion for chaining + * @throws NullPointerException + * if source is null. + */ + public Quaternion set(final ReadOnlyQuaternion source) { + setX(source.getX()); + setY(source.getY()); + setZ(source.getZ()); + setW(source.getW()); + return this; + } + + /** + * Updates this quaternion from the given Euler rotation angles, applied in the given order: heading, attitude, + * bank. + * + * @param angles + * the Euler angles of rotation (in radians) stored as heading, attitude, and bank. + * @return this quaternion for chaining + * @throws ArrayIndexOutOfBoundsException + * if angles is less than length 3 + * @throws NullPointerException + * if angles is null. + */ + public Quaternion fromEulerAngles(final double[] angles) { + return fromEulerAngles(angles[0], angles[1], angles[2]); + } + + /** + * Updates this quaternion from the given Euler rotation angles, applied in the given order: heading, attitude, + * bank. + * + * @param heading + * the Euler heading angle in radians. (rotation about the y axis) + * @param attitude + * the Euler attitude angle in radians. (rotation about the z axis) + * @param bank + * the Euler bank angle in radians. (rotation about the x axis) + * @return this quaternion for chaining + * @see <a + * href="http://www.euclideanspace.com/maths/geometry/rotations/conversions/eulerToQuaternion/index.htm">euclideanspace.com-eulerToQuaternion</a> + */ + public Quaternion fromEulerAngles(final double heading, final double attitude, final double bank) { + double angle = heading * 0.5; + final double sinHeading = MathUtils.sin(angle); + final double cosHeading = MathUtils.cos(angle); + angle = attitude * 0.5; + final double sinAttitude = MathUtils.sin(angle); + final double cosAttitude = MathUtils.cos(angle); + angle = bank * 0.5; + final double sinBank = MathUtils.sin(angle); + final double cosBank = MathUtils.cos(angle); + + // variables used to reduce multiplication calls. + final double cosHeadingXcosAttitude = cosHeading * cosAttitude; + final double sinHeadingXsinAttitude = sinHeading * sinAttitude; + final double cosHeadingXsinAttitude = cosHeading * sinAttitude; + final double sinHeadingXcosAttitude = sinHeading * cosAttitude; + + final double w = cosHeadingXcosAttitude * cosBank - sinHeadingXsinAttitude * sinBank; + final double x = cosHeadingXcosAttitude * sinBank + sinHeadingXsinAttitude * cosBank; + final double y = sinHeadingXcosAttitude * cosBank + cosHeadingXsinAttitude * sinBank; + final double z = cosHeadingXsinAttitude * cosBank - sinHeadingXcosAttitude * sinBank; + + set(x, y, z, w); + + return normalizeLocal(); + } + + /** + * Converts this quaternion to Euler rotation angles in radians (heading, attitude, bank). + * + * @param store + * the double[] array to store the computed angles in. If null, a new double[] will be created + * @return the double[] array, filled with heading, attitude and bank in that order.. + * @throws ArrayIndexOutOfBoundsException + * if non-null store is not at least length 3 + * @see <a + * href="http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/index.htm">euclideanspace.com-quaternionToEuler</a> + * @see #fromEulerAngles(double, double, double) + */ + @Override + public double[] toEulerAngles(final double[] store) { + double[] result = store; + if (result == null) { + result = new double[3]; + } else if (result.length < 3) { + throw new ArrayIndexOutOfBoundsException("store array must have at least three elements"); + } + + final double sqw = getW() * getW(); + final double sqx = getX() * getX(); + final double sqy = getY() * getY(); + final double sqz = getZ() * getZ(); + final double unit = sqx + sqy + sqz + sqw; // if normalized is one, otherwise + // is correction factor + final double test = getX() * getY() + getZ() * getW(); + if (test > 0.499 * unit) { // singularity at north pole + result[0] = 2 * Math.atan2(getX(), getW()); + result[1] = MathUtils.HALF_PI; + result[2] = 0; + } else if (test < -0.499 * unit) { // singularity at south pole + result[0] = -2 * Math.atan2(getX(), getW()); + result[1] = -MathUtils.HALF_PI; + result[2] = 0; + } else { + result[0] = Math.atan2(2 * getY() * getW() - 2 * getX() * getZ(), sqx - sqy - sqz + sqw); + result[1] = Math.asin(2 * test / unit); + result[2] = Math.atan2(2 * getX() * getW() - 2 * getY() * getZ(), -sqx + sqy - sqz + sqw); + } + return result; + } + + /** + * Sets the value of this quaternion to the rotation described by the given matrix. + * + * @param matrix + * @return this quaternion for chaining + * @throws NullPointerException + * if matrix is null. + */ + public Quaternion fromRotationMatrix(final ReadOnlyMatrix3 matrix) { + return fromRotationMatrix(matrix.getM00(), matrix.getM01(), matrix.getM02(), matrix.getM10(), matrix.getM11(), + matrix.getM12(), matrix.getM20(), matrix.getM21(), matrix.getM22()); + } + + /** + * Sets the value of this quaternion to the rotation described by the given matrix values. + * + * @param m00 + * @param m01 + * @param m02 + * @param m10 + * @param m11 + * @param m12 + * @param m20 + * @param m21 + * @param m22 + * @return this quaternion for chaining + */ + public Quaternion fromRotationMatrix(final double m00, final double m01, final double m02, final double m10, + final double m11, final double m12, final double m20, final double m21, final double m22) { + // Uses the Graphics Gems code, from + // ftp://ftp.cis.upenn.edu/pub/graphics/shoemake/quatut.ps.Z + // *NOT* the "Matrix and Quaternions FAQ", which has errors! + + // the trace is the sum of the diagonal elements; see + // http://mathworld.wolfram.com/MatrixTrace.html + final double t = m00 + m11 + m22; + + // we protect the division by s by ensuring that s>=1 + double x, y, z, w; + if (t >= 0) { // |w| >= .5 + double s = Math.sqrt(t + 1); // |s|>=1 ... + w = 0.5 * s; + s = 0.5 / s; // so this division isn't bad + x = (m21 - m12) * s; + y = (m02 - m20) * s; + z = (m10 - m01) * s; + } else if (m00 > m11 && m00 > m22) { + double s = Math.sqrt(1.0 + m00 - m11 - m22); // |s|>=1 + x = s * 0.5; // |x| >= .5 + s = 0.5 / s; + y = (m10 + m01) * s; + z = (m02 + m20) * s; + w = (m21 - m12) * s; + } else if (m11 > m22) { + double s = Math.sqrt(1.0 + m11 - m00 - m22); // |s|>=1 + y = s * 0.5; // |y| >= .5 + s = 0.5 / s; + x = (m10 + m01) * s; + z = (m21 + m12) * s; + w = (m02 - m20) * s; + } else { + double s = Math.sqrt(1.0 + m22 - m00 - m11); // |s|>=1 + z = s * 0.5; // |z| >= .5 + s = 0.5 / s; + x = (m02 + m20) * s; + y = (m21 + m12) * s; + w = (m10 - m01) * s; + } + + return set(x, y, z, w); + } + + /** + * @param store + * the matrix to store our result in. If null, a new matrix is created. + * @return the rotation matrix representation of this quaternion (normalized) + * + * if store is not null and is read only. + */ + @Override + public Matrix3 toRotationMatrix(final Matrix3 store) { + Matrix3 result = store; + if (result == null) { + result = new Matrix3(); + } + + final double norm = magnitudeSquared(); + final double s = norm > 0.0 ? 2.0 / norm : 0.0; + + // compute xs/ys/zs first to save 6 multiplications, since xs/ys/zs + // will be used 2-4 times each. + final double xs = getX() * s; + final double ys = getY() * s; + final double zs = getZ() * s; + final double xx = getX() * xs; + final double xy = getX() * ys; + final double xz = getX() * zs; + final double xw = getW() * xs; + final double yy = getY() * ys; + final double yz = getY() * zs; + final double yw = getW() * ys; + final double zz = getZ() * zs; + final double zw = getW() * zs; + + // using s=2/norm (instead of 1/norm) saves 9 multiplications by 2 here + result.setM00(1.0 - (yy + zz)); + result.setM01(xy - zw); + result.setM02(xz + yw); + result.setM10(xy + zw); + result.setM11(1.0 - (xx + zz)); + result.setM12(yz - xw); + result.setM20(xz - yw); + result.setM21(yz + xw); + result.setM22(1.0 - (xx + yy)); + + return result; + } + + /** + * @param store + * the matrix to store our result in. If null, a new matrix is created. + * @return the rotation matrix representation of this quaternion (normalized) + */ + @Override + public Matrix4 toRotationMatrix(final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + final double norm = magnitudeSquared(); + final double s = norm == 1.0 ? 2.0 : norm > 0.0 ? 2.0 / norm : 0; + + // compute xs/ys/zs first to save 6 multiplications, since xs/ys/zs + // will be used 2-4 times each. + final double xs = getX() * s; + final double ys = getY() * s; + final double zs = getZ() * s; + final double xx = getX() * xs; + final double xy = getX() * ys; + final double xz = getX() * zs; + final double xw = getW() * xs; + final double yy = getY() * ys; + final double yz = getY() * zs; + final double yw = getW() * ys; + final double zz = getZ() * zs; + final double zw = getW() * zs; + + // using s=2/norm (instead of 1/norm) saves 9 multiplications by 2 here + result.setM00(1.0 - (yy + zz)); + result.setM01(xy - zw); + result.setM02(xz + yw); + result.setM10(xy + zw); + result.setM11(1.0 - (xx + zz)); + result.setM12(yz - xw); + result.setM20(xz - yw); + result.setM21(yz + xw); + result.setM22(1.0 - (xx + yy)); + + return result; + } + + /** + * @param index + * the 3x3 rotation matrix column to retrieve from this quaternion (normalized). Must be between 0 and 2. + * @param store + * the vector object to store the result in. if null, a new one is created. + * @return the column specified by the index. + */ + @Override + public Vector3 getRotationColumn(final int index, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final double norm = magnitudeSquared(); + final double s = norm == 1.0 ? 2.0 : norm > 0.0 ? 2.0 / norm : 0; + + // compute xs/ys/zs first to save 6 multiplications, since xs/ys/zs + // will be used 2-4 times each. + final double xs = getX() * s; + final double ys = getY() * s; + final double zs = getZ() * s; + final double xx = getX() * xs; + final double xy = getX() * ys; + final double xz = getX() * zs; + final double xw = getW() * xs; + final double yy = getY() * ys; + final double yz = getY() * zs; + final double yw = getW() * ys; + final double zz = getZ() * zs; + final double zw = getW() * zs; + + // using s=2/norm (instead of 1/norm) saves 3 multiplications by 2 here + double x, y, z; + switch (index) { + case 0: + x = 1.0 - (yy + zz); + y = xy + zw; + z = xz - yw; + break; + case 1: + x = xy - zw; + y = 1.0 - (xx + zz); + z = yz + xw; + break; + case 2: + x = xz + yw; + y = yz - xw; + z = 1.0 - (xx + yy); + break; + default: + throw new IllegalArgumentException("Invalid column index. " + index); + } + + return result.set(x, y, z); + } + + /** + * Sets the values of this quaternion to the values represented by a given angle and axis of rotation. Note that + * this method creates an object, so use fromAngleNormalAxis if your axis is already normalized. If axis == 0,0,0 + * the quaternion is set to identity. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation. + * @return this quaternion for chaining + * @throws NullPointerException + * if axis is null + */ + public Quaternion fromAngleAxis(final double angle, final ReadOnlyVector3 axis) { + final Vector3 temp = Vector3.fetchTempInstance(); + final Quaternion quat = fromAngleNormalAxis(angle, axis.normalize(temp)); + Vector3.releaseTempInstance(temp); + return quat; + } + + /** + * Sets the values of this quaternion to the values represented by a given angle and unit length axis of rotation. + * If axis == 0,0,0 the quaternion is set to identity. + * + * @param angle + * the angle to rotate (in radians). + * @param axis + * the axis of rotation (already normalized - unit length). + * @throws NullPointerException + * if axis is null + */ + public Quaternion fromAngleNormalAxis(final double angle, final ReadOnlyVector3 axis) { + if (axis.equals(Vector3.ZERO)) { + return setIdentity(); + } + + final double halfAngle = 0.5 * angle; + final double sin = MathUtils.sin(halfAngle); + final double w = MathUtils.cos(halfAngle); + final double x = sin * axis.getX(); + final double y = sin * axis.getY(); + final double z = sin * axis.getZ(); + return set(x, y, z, w); + } + + /** + * Returns the rotation angle represented by this quaternion. If a non-null vector is provided, the axis of rotation + * is stored in that vector as well. + * + * @param axisStore + * the object we'll store the computed axis in. If null, no computations are done to determine axis. + * @return the angle of rotation in radians. + */ + @Override + public double toAngleAxis(final Vector3 axisStore) { + final double sqrLength = getX() * getX() + getY() * getY() + getZ() * getZ(); + double angle; + if (Math.abs(sqrLength) <= MathUtils.EPSILON) { // length is ~0 + angle = 0.0; + if (axisStore != null) { + axisStore.setX(1.0); + axisStore.setY(0.0); + axisStore.setZ(0.0); + } + } else { + angle = 2.0 * Math.acos(getW()); + if (axisStore != null) { + final double invLength = 1.0 / Math.sqrt(sqrLength); + axisStore.setX(getX() * invLength); + axisStore.setY(getY() * invLength); + axisStore.setZ(getZ() * invLength); + } + } + + return angle; + } + + /** + * Sets this quaternion to that which will rotate vector "from" into vector "to". from and to do not have to be the + * same length. + * + * @param from + * the source vector to rotate + * @param to + * the destination vector into which to rotate the source vector + * @return this quaternion for chaining + */ + public Quaternion fromVectorToVector(final ReadOnlyVector3 from, final ReadOnlyVector3 to) { + final ReadOnlyVector3 a = from; + final ReadOnlyVector3 b = to; + final double factor = a.length() * b.length(); + if (Math.abs(factor) > MathUtils.EPSILON) { + // Vectors have length > 0 + final Vector3 pivotVector = Vector3.fetchTempInstance(); + try { + final double dot = a.dot(b) / factor; + final double theta = Math.acos(Math.max(-1.0, Math.min(dot, 1.0))); + a.cross(b, pivotVector); + if (dot < 0.0 && pivotVector.length() < MathUtils.EPSILON) { + // Vectors parallel and opposite direction, therefore a rotation of 180 degrees about any vector + // perpendicular to this vector will rotate vector a onto vector b. + // + // The following guarantees the dot-product will be 0.0. + int dominantIndex; + if (Math.abs(a.getX()) > Math.abs(a.getY())) { + if (Math.abs(a.getX()) > Math.abs(a.getZ())) { + dominantIndex = 0; + } else { + dominantIndex = 2; + } + } else { + if (Math.abs(a.getY()) > Math.abs(a.getZ())) { + dominantIndex = 1; + } else { + dominantIndex = 2; + } + } + pivotVector.setValue(dominantIndex, -a.getValue((dominantIndex + 1) % 3)); + pivotVector.setValue((dominantIndex + 1) % 3, a.getValue(dominantIndex)); + pivotVector.setValue((dominantIndex + 2) % 3, 0f); + } + return fromAngleAxis(theta, pivotVector); + } finally { + Vector3.releaseTempInstance(pivotVector); + } + } else { + return setIdentity(); + } + } + + /** + * @param store + * the Quaternion to store the result in. if null, a new one is created. + * @return a new quaternion that represents a unit length version of this Quaternion. + */ + @Override + public Quaternion normalize(final Quaternion store) { + Quaternion result = store; + if (result == null) { + result = new Quaternion(); + } + + final double n = 1.0 / magnitude(); + final double x = getX() * n; + final double y = getY() * n; + final double z = getZ() * n; + final double w = getW() * n; + return result.set(x, y, z, w); + } + + /** + * @return this quaternion, modified to be unit length, for chaining. + */ + public Quaternion normalizeLocal() { + final double n = 1.0 / magnitude(); + final double x = getX() * n; + final double y = getY() * n; + final double z = getZ() * n; + final double w = getW() * n; + return set(x, y, z, w); + } + + /** + * Calculates the <i>multiplicative inverse</i> <code>Q<sup>-1</sup></code> of this quaternion <code>Q</code> such + * that <code>QQ<sup>-1</sup> = [0,0,0,1]</code> (the identity quaternion). Note that for unit quaternions, a + * quaternion's inverse is equal to its (far easier to calculate) conjugate. + * + * @param store + * the <code>Quaternion</code> to store the result in. If <code>null</code>, a new one is created. + * @see #conjugate(Quaternion) + * @return the multiplicative inverse of this quaternion. + */ + public Quaternion invert(Quaternion store) { + if (store == null) { + store = new Quaternion(); + } + final double magnitudeSQ = magnitudeSquared(); + conjugate(store); + if (Math.abs(1.0 - magnitudeSQ) <= MathUtils.EPSILON) { + return store; + } else { + return store.multiplyLocal(1.0 / magnitudeSQ); + } + } + + /** + * Locally sets this quaternion <code>Q</code> to its <i>multiplicative inverse</i> <code>Q<sup>-1</sup></code> such + * that <code>QQ<sup>-1</sup> = [0,0,0,1]</code> (the identity quaternion). Note that for unit quaternions, a + * quaternion's inverse is equal to its (far easier to calculate) conjugate. + * + * @see #conjugate(Quaternion) + * + * @return this <code>Quaternion</code> for chaining. + */ + public Quaternion invertLocal() { + final double magnitudeSQ = magnitudeSquared(); + conjugateLocal(); + if (Math.abs(1.0 - magnitudeSQ) <= MathUtils.EPSILON) { + return this; + } else { + return multiplyLocal(1.0 / magnitudeSquared()); + } + } + + /** + * Creates a new quaternion that is the conjugate <code>[-x, -y, -z, w]</code> of this quaternion. + * + * @param store + * the <code>Quaternion</code> to store the result in. If <code>null</code>, a new one is created. + * @return the conjugate to this quaternion. + */ + @Override + public Quaternion conjugate(Quaternion store) { + if (store == null) { + store = new Quaternion(); + } + return store.set(-getX(), -getY(), -getZ(), getW()); + } + + /** + * Internally sets this quaternion to its conjugate <code>[-x, -y, -z, w]</code>. + * + * @return this <code>Quaternion</code> for chaining. + */ + public Quaternion conjugateLocal() { + return set(-getX(), -getY(), -getZ(), getW()); + } + + /** + * Adds this quaternion to another and places the result in the given store. + * + * @param quat + * @param store + * the Quaternion to store the result in. if null, a new one is created. + * @return a quaternion representing the fields of this quaternion added to those of the given quaternion. + */ + @Override + public Quaternion add(final ReadOnlyQuaternion quat, final Quaternion store) { + Quaternion result = store; + if (result == null) { + result = new Quaternion(); + } + + return result.set(getX() + quat.getX(), getY() + quat.getY(), getZ() + quat.getZ(), getW() + quat.getW()); + } + + /** + * Internally increments the fields of this quaternion with the field values of the given quaternion. + * + * @param quat + * @return this quaternion for chaining + */ + public Quaternion addLocal(final ReadOnlyQuaternion quat) { + setX(getX() + quat.getX()); + setY(getY() + quat.getY()); + setZ(getZ() + quat.getZ()); + setW(getW() + quat.getW()); + return this; + } + + /** + * @param quat + * @param store + * the Quaternion to store the result in. if null, a new one is created. + * @return a quaternion representing the fields of this quaternion subtracted from those of the given quaternion. + */ + @Override + public Quaternion subtract(final ReadOnlyQuaternion quat, final Quaternion store) { + Quaternion result = store; + if (result == null) { + result = new Quaternion(); + } + + return result.set(getX() - quat.getX(), getY() - quat.getY(), getZ() - quat.getZ(), getW() - quat.getW()); + } + + /** + * Internally decrements the fields of this quaternion by the field values of the given quaternion. + * + * @param quat + * @return this quaternion for chaining. + */ + public Quaternion subtractLocal(final ReadOnlyQuaternion quat) { + setX(getX() - quat.getX()); + setY(getY() - quat.getY()); + setZ(getZ() - quat.getZ()); + setW(getW() - quat.getW()); + return this; + } + + /** + * Multiplies each value of this quaternion by the given scalar value. + * + * @param scalar + * the quaternion to multiply this quaternion by. + * @param store + * the Quaternion to store the result in. if null, a new one is created. + * @return the resulting quaternion. + */ + @Override + public Quaternion multiply(final double scalar, final Quaternion store) { + Quaternion result = store; + if (result == null) { + result = new Quaternion(); + } + + return result.set(scalar * getX(), scalar * getY(), scalar * getZ(), scalar * getW()); + } + + /** + * Multiplies each value of this quaternion by the given scalar value. The result is stored in this quaternion. + * + * @param scalar + * the quaternion to multiply this quaternion by. + * @return this quaternion for chaining. + */ + public Quaternion multiplyLocal(final double scalar) { + setX(getX() * scalar); + setY(getY() * scalar); + setZ(getZ() * scalar); + setW(getW() * scalar); + return this; + } + + /** + * Multiplies this quaternion by the supplied quaternion. The result is stored in the given store quaternion or a + * new quaternion if store is null. + * + * It IS safe for quat and store to be the same object. + * + * @param quat + * the quaternion to multiply this quaternion by. + * @param store + * the quaternion to store the result in. + * @return the new quaternion. + * + * if the given store is read only. + */ + @Override + public Quaternion multiply(final ReadOnlyQuaternion quat, Quaternion store) { + if (store == null) { + store = new Quaternion(); + } + final double x = getX() * quat.getW() + getY() * quat.getZ() - getZ() * quat.getY() + getW() * quat.getX(); + final double y = -getX() * quat.getZ() + getY() * quat.getW() + getZ() * quat.getX() + getW() * quat.getY(); + final double z = getX() * quat.getY() - getY() * quat.getX() + getZ() * quat.getW() + getW() * quat.getZ(); + final double w = -getX() * quat.getX() - getY() * quat.getY() - getZ() * quat.getZ() + getW() * quat.getW(); + return store.set(x, y, z, w); + } + + /** + * Multiplies this quaternion by the supplied quaternion. The result is stored locally. + * + * @param quat + * The Quaternion to multiply this one by. + * @return this quaternion for chaining + * @throws NullPointerException + * if quat is null. + */ + public Quaternion multiplyLocal(final ReadOnlyQuaternion quat) { + return multiplyLocal(quat.getX(), quat.getY(), quat.getZ(), quat.getW()); + } + + /** + * Multiplies this quaternion by the supplied matrix. The result is stored locally. + * + * @param matrix + * the matrix to apply to this quaternion. + * @return this quaternion for chaining + * @throws NullPointerException + * if matrix is null. + */ + public Quaternion multiplyLocal(final ReadOnlyMatrix3 matrix) { + final double oldX = getX(), oldY = getY(), oldZ = getZ(), oldW = getW(); + fromRotationMatrix(matrix); + final double tempX = getX(), tempY = getY(), tempZ = getZ(), tempW = getW(); + + final double x = oldX * tempW + oldY * tempZ - oldZ * tempY + oldW * tempX; + final double y = -oldX * tempZ + oldY * tempW + oldZ * tempX + oldW * tempY; + final double z = oldX * tempY - oldY * tempX + oldZ * tempW + oldW * tempZ; + final double w = -oldX * tempX - oldY * tempY - oldZ * tempZ + oldW * tempW; + return set(x, y, z, w); + } + + /** + * Multiplies this quaternion by the supplied quaternion values. The result is stored locally. + * + * @param qx + * @param qy + * @param qz + * @param qw + * @return this quaternion for chaining + */ + public Quaternion multiplyLocal(final double qx, final double qy, final double qz, final double qw) { + final double x = getX() * qw + getY() * qz - getZ() * qy + getW() * qx; + final double y = -getX() * qz + getY() * qw + getZ() * qx + getW() * qy; + final double z = getX() * qy - getY() * qx + getZ() * qw + getW() * qz; + final double w = -getX() * qx - getY() * qy - getZ() * qz + getW() * qw; + return set(x, y, z, w); + } + + /** + * Multiply this quaternion by a rotational quaternion made from the given angle and axis. The axis must be a + * normalized vector. + * + * @param angle + * in radians + * @param x + * x coord of rotation axis + * @param y + * y coord of rotation axis + * @param z + * z coord of rotation axis + * @return this quaternion for chaining. + */ + public Quaternion applyRotation(final double angle, final double x, final double y, final double z) { + if (x == 0 && y == 0 && z == 0) { + // no change + return this; + } + + final double halfAngle = 0.5 * angle; + final double sin = MathUtils.sin(halfAngle); + final double qw = MathUtils.cos(halfAngle); + final double qx = sin * x; + final double qy = sin * y; + final double qz = sin * z; + + final double newX = getX() * qw + getY() * qz - getZ() * qy + getW() * qx; + final double newY = -getX() * qz + getY() * qw + getZ() * qx + getW() * qy; + final double newZ = getX() * qy - getY() * qx + getZ() * qw + getW() * qz; + final double newW = -getX() * qx - getY() * qy - getZ() * qz + getW() * qw; + + return set(newX, newY, newZ, newW); + } + + /** + * Apply rotation around X + * + * @param angle + * in radians + * @return this quaternion for chaining. + */ + public Quaternion applyRotationX(final double angle) { + final double halfAngle = 0.5 * angle; + final double sin = MathUtils.sin(halfAngle); + final double cos = MathUtils.cos(halfAngle); + + final double newX = getX() * cos + getW() * sin; + final double newY = getY() * cos + getZ() * sin; + final double newZ = -getY() * sin + getZ() * cos; + final double newW = -getX() * sin + getW() * cos; + + return set(newX, newY, newZ, newW); + } + + /** + * Apply rotation around Y + * + * @param angle + * in radians + * @return this quaternion for chaining. + */ + public Quaternion applyRotationY(final double angle) { + final double halfAngle = 0.5 * angle; + final double sin = MathUtils.sin(halfAngle); + final double cos = MathUtils.cos(halfAngle); + + final double newX = getX() * cos - getZ() * sin; + final double newY = getY() * cos + getW() * sin; + final double newZ = getX() * sin + getZ() * cos; + final double newW = -getY() * sin + getW() * cos; + + return set(newX, newY, newZ, newW); + } + + /** + * Apply rotation around Z + * + * @param angle + * in radians + * @return this quaternion for chaining. + */ + public Quaternion applyRotationZ(final double angle) { + final double halfAngle = 0.5 * angle; + final double sin = MathUtils.sin(halfAngle); + final double cos = MathUtils.cos(halfAngle); + + final double newX = getX() * cos + getY() * sin; + final double newY = -getX() * sin + getY() * cos; + final double newZ = getZ() * cos + getW() * sin; + final double newW = -getZ() * sin + getW() * cos; + + return set(newX, newY, newZ, newW); + } + + /** + * Rotates the given vector by this quaternion. If supplied, the result is stored into the supplied "store" vector. + * + * @param vec + * the vector to multiply this quaternion by. + * @param store + * the vector to store the result in. If store is null, a new vector is created. Note that it IS safe for + * vec and store to be the same object. + * @return the store vector, or a new vector if store is null. + * @throws NullPointerException + * if vec is null + * + * if the given store is read only. + */ + @Override + public Vector3 apply(final ReadOnlyVector3 vec, Vector3 store) { + if (store == null) { + store = new Vector3(); + } + if (vec.equals(Vector3.ZERO)) { + store.set(0, 0, 0); + } else { + final double x = getW() * getW() * vec.getX() + 2 * getY() * getW() * vec.getZ() - 2 * getZ() * getW() + * vec.getY() + getX() * getX() * vec.getX() + 2 * getY() * getX() * vec.getY() + 2 * getZ() + * getX() * vec.getZ() - getZ() * getZ() * vec.getX() - getY() * getY() * vec.getX(); + final double y = 2 * getX() * getY() * vec.getX() + getY() * getY() * vec.getY() + 2 * getZ() * getY() + * vec.getZ() + 2 * getW() * getZ() * vec.getX() - getZ() * getZ() * vec.getY() + getW() * getW() + * vec.getY() - 2 * getX() * getW() * vec.getZ() - getX() * getX() * vec.getY(); + final double z = 2 * getX() * getZ() * vec.getX() + 2 * getY() * getZ() * vec.getY() + getZ() * getZ() + * vec.getZ() - 2 * getW() * getY() * vec.getX() - getY() * getY() * vec.getZ() + 2 * getW() + * getX() * vec.getY() - getX() * getX() * vec.getZ() + getW() * getW() * vec.getZ(); + store.set(x, y, z); + } + return store; + } + + /** + * Updates this quaternion to represent a rotation formed by the given three axes. These axes are assumed to be + * orthogonal and no error checking is applied. It is the user's job to insure that the three axes being provided + * indeed represent a proper right handed coordinate system. + * + * @param xAxis + * vector representing the x-axis of the coordinate system. + * @param yAxis + * vector representing the y-axis of the coordinate system. + * @param zAxis + * vector representing the z-axis of the coordinate system. + * @return this quaternion for chaining + */ + public Quaternion fromAxes(final ReadOnlyVector3 xAxis, final ReadOnlyVector3 yAxis, final ReadOnlyVector3 zAxis) { + return fromRotationMatrix(xAxis.getX(), yAxis.getX(), zAxis.getX(), xAxis.getY(), yAxis.getY(), zAxis.getY(), + xAxis.getZ(), yAxis.getZ(), zAxis.getZ()); + } + + /** + * Converts this quaternion to a rotation matrix and then extracts rotation axes. + * + * @param axes + * the array of vectors to be filled. + * @throws ArrayIndexOutOfBoundsException + * if the given axes array is smaller than 3 elements. + * @return the axes + */ + @Override + public Vector3[] toAxes(final Vector3[] axes) { + final Matrix3 tempMat = toRotationMatrix(Matrix3.fetchTempInstance()); + axes[2] = tempMat.getColumn(2, axes[2]); + axes[1] = tempMat.getColumn(1, axes[1]); + axes[0] = tempMat.getColumn(0, axes[0]); + Matrix3.releaseTempInstance(tempMat); + return axes; + } + + /** + * Does a spherical linear interpolation between this quaternion and the given end quaternion by the given change + * amount. + * + * @param endQuat + * @param changeAmnt + * @param store + * the quaternion to store the result in for return. If null, a new quaternion object is created and + * returned. + * @return a new quaternion containing the result. + */ + @Override + public Quaternion slerp(final ReadOnlyQuaternion endQuat, final double changeAmnt, final Quaternion store) { + return Quaternion.slerp(this, endQuat, changeAmnt, store); + } + + /** + * Does a spherical linear interpolation between this quaternion and the given end quaternion by the given change + * amount. Stores the results locally in this quaternion. + * + * @param endQuat + * @param changeAmnt + * @return this quaternion for chaining. + */ + public Quaternion slerpLocal(final ReadOnlyQuaternion endQuat, final double changeAmnt) { + return slerpLocal(this, endQuat, changeAmnt); + } + + /** + * Does a spherical linear interpolation between the given start and end quaternions by the given change amount. + * Returns the result as a new quaternion. + * + * @param startQuat + * @param endQuat + * @param changeAmnt + * @param store + * the quaternion to store the result in for return. If null, a new quaternion object is created and + * returned. + * @return the new quaternion + */ + public static Quaternion slerp(final ReadOnlyQuaternion startQuat, final ReadOnlyQuaternion endQuat, + final double changeAmnt, final Quaternion store) { + Quaternion result = store; + if (result == null) { + result = new Quaternion(); + } + + // check for weighting at either extreme + if (changeAmnt == 0.0) { + return result.set(startQuat); + } else if (changeAmnt == 1.0) { + return result.set(endQuat); + } + + result.set(endQuat); + // Check for equality and skip operation. + if (startQuat.equals(result)) { + return result; + } + + double dotP = startQuat.dot(result); + + if (dotP < 0.0) { + // Negate the second quaternion and the result of the dot product + result.multiplyLocal(-1); + dotP = -dotP; + } + + // Set the first and second scale for the interpolation + double scale0 = 1 - changeAmnt; + double scale1 = changeAmnt; + + // Check if the angle between the 2 quaternions was big enough to + // warrant such calculations + if (1 - dotP > 0.1) {// Get the angle between the 2 quaternions, + // and then store the sin() of that angle + final double theta = Math.acos(dotP); + final double invSinTheta = 1f / MathUtils.sin(theta); + + // Calculate the scale for q1 and q2, according to the angle and + // it's sine value + scale0 = MathUtils.sin((1 - changeAmnt) * theta) * invSinTheta; + scale1 = MathUtils.sin(changeAmnt * theta) * invSinTheta; + } + + // Calculate the x, y, z and w values for the quaternion by using a + // special form of linear interpolation for quaternions. + final double x = scale0 * startQuat.getX() + scale1 * result.getX(); + final double y = scale0 * startQuat.getY() + scale1 * result.getY(); + final double z = scale0 * startQuat.getZ() + scale1 * result.getZ(); + final double w = scale0 * startQuat.getW() + scale1 * result.getW(); + + // Return the interpolated quaternion + return result.set(x, y, z, w); + } + + /** + * Does a spherical linear interpolation between the given start and end quaternions by the given change amount. + * Stores the result locally. + * + * @param startQuat + * @param endQuat + * @param changeAmnt + * @param workQuat + * a Quaternion to use as scratchpad during calculation + * @return this quaternion for chaining. + * @throws NullPointerException + * if startQuat, endQuat or workQuat are null. + */ + public Quaternion slerpLocal(final ReadOnlyQuaternion startQuat, final ReadOnlyQuaternion endQuat, + final double changeAmnt, final Quaternion workQuat) { + + // check for weighting at either extreme + if (changeAmnt == 0.0) { + return set(startQuat); + } else if (changeAmnt == 1.0) { + return set(endQuat); + } + + // Check for equality and skip operation. + if (startQuat.equals(endQuat)) { + return set(startQuat); + } + + double result = startQuat.dot(endQuat); + workQuat.set(endQuat); + + if (result < 0.0) { + // Negate the second quaternion and the result of the dot product + workQuat.multiplyLocal(-1); + result = -result; + } + + // Set the first and second scale for the interpolation + double scale0 = 1 - changeAmnt; + double scale1 = changeAmnt; + + // Check if the angle between the 2 quaternions was big enough to + // warrant such calculations + if (1 - result > 0.1) {// Get the angle between the 2 quaternions, + // and then store the sin() of that angle + final double theta = MathUtils.acos(result); + final double invSinTheta = 1f / MathUtils.sin(theta); + + // Calculate the scale for q1 and q2, according to the angle and + // it's sine value + scale0 = MathUtils.sin((1 - changeAmnt) * theta) * invSinTheta; + scale1 = MathUtils.sin(changeAmnt * theta) * invSinTheta; + } + + // Calculate the x, y, z and w values for the quaternion by using a + // special form of linear interpolation for quaternions. + final double x = scale0 * startQuat.getX() + scale1 * workQuat.getX(); + final double y = scale0 * startQuat.getY() + scale1 * workQuat.getY(); + final double z = scale0 * startQuat.getZ() + scale1 * workQuat.getZ(); + final double w = scale0 * startQuat.getW() + scale1 * workQuat.getW(); + set(x, y, z, w); + + // Return the interpolated quaternion + return this; + } + + /** + * Does a spherical linear interpolation between the given start and end quaternions by the given change amount. + * Stores the result locally. + * + * @param startQuat + * @param endQuat + * @param changeAmnt + * @return this quaternion for chaining. + * @throws NullPointerException + * if startQuat or endQuat are null. + */ + public Quaternion slerpLocal(final ReadOnlyQuaternion startQuat, final ReadOnlyQuaternion endQuat, + final double changeAmnt) { + final Quaternion end = Quaternion.fetchTempInstance().set(endQuat); + slerpLocal(startQuat, endQuat, changeAmnt, end); + Quaternion.releaseTempInstance(end); + return this; + } + + /** + * Modifies this quaternion to equal the rotation required to point the z-axis at 'direction' and the y-axis to + * 'up'. + * + * @param direction + * where to 'look' at + * @param up + * a vector indicating the local up direction. + * @return this quaternion for chaining. + */ + public Quaternion lookAt(final ReadOnlyVector3 direction, final ReadOnlyVector3 up) { + final Vector3 xAxis = Vector3.fetchTempInstance(); + final Vector3 yAxis = Vector3.fetchTempInstance(); + final Vector3 zAxis = Vector3.fetchTempInstance(); + direction.normalize(zAxis); + up.normalize(xAxis).crossLocal(zAxis); + zAxis.cross(xAxis, yAxis); + + fromAxes(xAxis, yAxis, zAxis); + normalizeLocal(); + + Vector3.releaseTempInstance(xAxis); + Vector3.releaseTempInstance(yAxis); + Vector3.releaseTempInstance(zAxis); + return this; + } + + /** + * @return the squared magnitude of this quaternion. + */ + @Override + public double magnitudeSquared() { + return getW() * getW() + getX() * getX() + getY() * getY() + getZ() * getZ(); + } + + /** + * @return the magnitude of this quaternion. basically sqrt({@link #magnitude()}) + */ + @Override + public double magnitude() { + final double magnitudeSQ = magnitudeSquared(); + if (magnitudeSQ == 1.0) { + return 1.0; + } + + return MathUtils.sqrt(magnitudeSQ); + } + + /** + * @param x + * @param y + * @param z + * @param w + * @return the dot product of this quaternion with the given x,y,z and w values. + */ + @Override + public double dot(final double x, final double y, final double z, final double w) { + return getX() * x + getY() * y + getZ() * z + getW() * w; + } + + /** + * @param quat + * @return the dot product of this quaternion with the given quaternion. + */ + @Override + public double dot(final ReadOnlyQuaternion quat) { + return dot(quat.getX(), quat.getY(), quat.getZ(), quat.getW()); + } + + /** + * Sets the value of this quaternion to (0, 0, 0, 1). Equivalent to calling set(0, 0, 0, 1) + * + * @return this quaternion for chaining + */ + public Quaternion setIdentity() { + return set(0, 0, 0, 1); + } + + /** + * @return true if this quaternion is (0, 0, 0, 1) + */ + @Override + public boolean isIdentity() { + return strictEquals(Quaternion.IDENTITY); + } + + /** + * Check a quaternion... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param quat + * the quaternion to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyQuaternion quat) { + if (quat == null) { + return false; + } + if (Double.isNaN(quat.getX()) || Double.isInfinite(quat.getX())) { + return false; + } + if (Double.isNaN(quat.getY()) || Double.isInfinite(quat.getY())) { + return false; + } + if (Double.isNaN(quat.getZ()) || Double.isInfinite(quat.getZ())) { + return false; + } + if (Double.isNaN(quat.getW()) || Double.isInfinite(quat.getW())) { + return false; + } + return true; + } + + /** + * @return the string representation of this quaternion. + */ + @Override + public String toString() { + return "com.ardor3d.math.Quaternion [X=" + getX() + ", Y=" + getY() + ", Z=" + getZ() + ", W=" + getW() + "]"; + } + + /** + * @return returns a unique code for this quaternion object based on its values. If two quaternions are numerically + * equal, they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + final long x = Double.doubleToLongBits(getX()); + result += 31 * result + (int) (x ^ x >>> 32); + + final long y = Double.doubleToLongBits(getY()); + result += 31 * result + (int) (y ^ y >>> 32); + + final long z = Double.doubleToLongBits(getZ()); + result += 31 * result + (int) (z ^ z >>> 32); + + final long w = Double.doubleToLongBits(getW()); + result += 31 * result + (int) (w ^ w >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this quaternion and the provided quaternion have roughly the same x, y, z and w values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyQuaternion)) { + return false; + } + final ReadOnlyQuaternion comp = (ReadOnlyQuaternion) o; + return Math.abs(_x - comp.getX()) < Quaternion.ALLOWED_DEVIANCE + && Math.abs(_y - comp.getY()) < Quaternion.ALLOWED_DEVIANCE + && Math.abs(_z - comp.getZ()) < Quaternion.ALLOWED_DEVIANCE + && Math.abs(_w - comp.getW()) < Quaternion.ALLOWED_DEVIANCE; + } + + /** + * @param o + * the object to compare for equality + * @return true if this quaternion and the provided quaternion have the exact same double values. + */ + @Override + public boolean strictEquals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyQuaternion)) { + return false; + } + final ReadOnlyQuaternion comp = (ReadOnlyQuaternion) o; + return getX() == comp.getX() && getY() == comp.getY() && getZ() == comp.getZ() && getW() == comp.getW(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Quaternion clone() { + return new Quaternion(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Quaternion> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(getX(), "x", 0); + capsule.write(getY(), "y", 0); + capsule.write(getZ(), "z", 0); + capsule.write(getW(), "w", 1); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + setX(capsule.readDouble("x", 0)); + setY(capsule.readDouble("y", 0)); + setZ(capsule.readDouble("z", 0)); + setW(capsule.readDouble("w", 1)); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setX(in.readDouble()); + setY(in.readDouble()); + setZ(in.readDouble()); + setW(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(getX()); + out.writeDouble(getY()); + out.writeDouble(getZ()); + out.writeDouble(getW()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Quaternion that is intended for temporary use in calculations and so forth. Multiple calls + * to the method should return instances of this class that are not currently in use. + */ + public final static Quaternion fetchTempInstance() { + if (MathConstants.useMathPools) { + return Quaternion.QUAT_POOL.fetch(); + } else { + return new Quaternion(); + } + } + + /** + * Releases a Quaternion back to be used by a future call to fetchTempInstance. TAKE CARE: this Quaternion object + * should no longer have other classes referencing it or "Bad Things" will happen. + * + * @param mat + * the Quaternion to release. + */ + public final static void releaseTempInstance(final Quaternion mat) { + if (MathConstants.useMathPools) { + Quaternion.QUAT_POOL.release(mat); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Ray3.java b/ardor3d-math/src/main/java/com/ardor3d/math/Ray3.java new file mode 100644 index 0000000..9c1432f --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Ray3.java @@ -0,0 +1,395 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import com.ardor3d.math.type.ReadOnlyPlane; +import com.ardor3d.math.type.ReadOnlyRay3; +import com.ardor3d.math.type.ReadOnlyVector3; + +public class Ray3 extends Line3Base implements ReadOnlyRay3, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Ray3> RAY_POOL = ObjectPool.create(Ray3.class, MathConstants.maxMathPoolSize); + + /** + * Constructs a new ray with an origin at (0,0,0) and a direction of (0,0,1). + */ + public Ray3() { + super(Vector3.ZERO, Vector3.UNIT_Z); + } + + /** + * Copy constructor. + * + * @param source + * the ray to copy from. + */ + public Ray3(final ReadOnlyRay3 source) { + this(source.getOrigin(), source.getDirection()); + } + + /** + * Constructs a new ray using the supplied origin point and unit length direction vector + * + * @param origin + * @param direction + * - unit length + */ + public Ray3(final ReadOnlyVector3 origin, final ReadOnlyVector3 direction) { + super(origin, direction); + } + + /** + * Copies the values of the given source ray into this ray. + * + * @param source + * @return this ray for chaining + * @throws NullPointerException + * if source is null. + */ + public Ray3 set(final ReadOnlyRay3 source) { + _origin.set(source.getOrigin()); + _direction.set(source.getDirection()); + return this; + } + + /** + * @param worldVertices + * an array of vectors describing a polygon + * @return the distance from our origin to the primitive or POSITIVE_INFINITY if we do not intersect. + */ + @Override + public double getDistanceToPrimitive(final Vector3[] worldVertices) { + // Intersection test + final Vector3 intersect = Vector3.fetchTempInstance(); + try { + if (intersects(worldVertices, intersect)) { + return getOrigin().distance(intersect); + } + } finally { + Vector3.releaseTempInstance(intersect); + } + return Double.POSITIVE_INFINITY; + } + + /** + * @param polygonVertices + * @param locationStore + * @return true if this ray intersects a polygon described by the given vertices. + */ + @Override + public boolean intersects(final Vector3[] polygonVertices, final Vector3 locationStore) { + if (polygonVertices.length == 3) { + // TRIANGLE + return intersectsTriangle(polygonVertices[0], polygonVertices[1], polygonVertices[2], locationStore); + } else if (polygonVertices.length == 4) { + // QUAD + return intersectsQuad(polygonVertices[0], polygonVertices[1], polygonVertices[2], polygonVertices[3], + locationStore); + } + // TODO: Add support for line and point + return false; + } + + /** + * @param pointA + * @param pointB + * @param pointC + * @param locationStore + * if not null, and this ray intersects, the point of intersection is calculated and stored in this + * Vector3 + * @return true if this ray intersects a triangle formed by the given three points. + * @throws NullPointerException + * if any of the points are null. + */ + @Override + public boolean intersectsTriangle(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, + final ReadOnlyVector3 pointC, final Vector3 locationStore) { + return intersects(pointA, pointB, pointC, locationStore, false); + } + + /** + * @param pointA + * @param pointB + * @param pointC + * @param locationStore + * if not null, and this ray intersects, the point of intersection is calculated and stored in this + * Vector3 as (t, u, v) where t is the distance from the _origin to the point of intersection and (u, v) + * is the intersection point on the triangle plane. + * @return true if this ray intersects a triangle formed by the given three points. + * @throws NullPointerException + * if any of the points are null. + */ + @Override + public boolean intersectsTrianglePlanar(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, + final ReadOnlyVector3 pointC, final Vector3 locationStore) { + return intersects(pointA, pointB, pointC, locationStore, true); + } + + /** + * @param pointA + * @param pointB + * @param pointC + * @param pointD + * @param locationStore + * if not null, and this ray intersects, the point of intersection is calculated and stored in this + * Vector3 + * @return true if this ray intersects a triangle formed by the given three points. The points are assumed to be + * coplanar. + * @throws NullPointerException + * if any of the points are null. + */ + @Override + public boolean intersectsQuad(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, + final ReadOnlyVector3 pointC, final ReadOnlyVector3 pointD, final Vector3 locationStore) { + return intersects(pointA, pointB, pointC, locationStore, false) + || intersects(pointA, pointC, pointD, locationStore, false); + } + + /** + * @param pointA + * @param pointB + * @param pointC + * @param pointD + * @param locationStore + * if not null, and this ray intersects, the point of intersection is calculated and stored in this + * Vector3 as (t, u, v) where t is the distance from the _origin to the point of intersection and (u, v) + * is the intersection point on the triangle plane. + * @return true if this ray intersects a quad formed by the given four points. The points are assumed to be + * coplanar. + * @throws NullPointerException + * if any of the points are null. + */ + @Override + public boolean intersectsQuadPlanar(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, + final ReadOnlyVector3 pointC, final ReadOnlyVector3 pointD, final Vector3 locationStore) { + return intersects(pointA, pointB, pointC, locationStore, true) + || intersects(pointA, pointC, pointD, locationStore, true); + } + + /** + * Ray vs triangle implementation. + * + * @param pointA + * @param pointB + * @param pointC + * @param locationStore + * @param doPlanar + * @return true if this ray intersects a triangle formed by the given three points. + * @throws NullPointerException + * if any of the points are null. + */ + protected boolean intersects(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, + final ReadOnlyVector3 pointC, final Vector3 locationStore, final boolean doPlanar) { + final Vector3 diff = Vector3.fetchTempInstance().set(_origin).subtractLocal(pointA); + final Vector3 edge1 = Vector3.fetchTempInstance().set(pointB).subtractLocal(pointA); + final Vector3 edge2 = Vector3.fetchTempInstance().set(pointC).subtractLocal(pointA); + final Vector3 norm = Vector3.fetchTempInstance().set(edge1).crossLocal(edge2); + + double dirDotNorm = _direction.dot(norm); + double sign; + if (dirDotNorm > MathUtils.EPSILON) { + sign = 1.0; + } else if (dirDotNorm < -MathUtils.EPSILON) { + sign = -1.0; + dirDotNorm = -dirDotNorm; + } else { + // ray and triangle/quad are parallel + return false; + } + + final double dirDotDiffxEdge2 = sign * _direction.dot(diff.cross(edge2, edge2)); + boolean result = false; + if (dirDotDiffxEdge2 >= 0.0) { + final double dirDotEdge1xDiff = sign * _direction.dot(edge1.crossLocal(diff)); + if (dirDotEdge1xDiff >= 0.0) { + if (dirDotDiffxEdge2 + dirDotEdge1xDiff <= dirDotNorm) { + final double diffDotNorm = -sign * diff.dot(norm); + if (diffDotNorm >= 0.0) { + // ray intersects triangle + // if storage vector is null, just return true, + if (locationStore == null) { + return true; + } + // else fill in. + final double inv = 1f / dirDotNorm; + final double t = diffDotNorm * inv; + if (!doPlanar) { + locationStore.set(_origin).addLocal(_direction.getX() * t, _direction.getY() * t, + _direction.getZ() * t); + } else { + // these weights can be used to determine + // interpolated values, such as texture coord. + // eg. texcoord s,t at intersection point: + // s = w0*s0 + w1*s1 + w2*s2; + // t = w0*t0 + w1*t1 + w2*t2; + final double w1 = dirDotDiffxEdge2 * inv; + final double w2 = dirDotEdge1xDiff * inv; + // double w0 = 1.0 - w1 - w2; + locationStore.set(t, w1, w2); + } + result = true; + } + } + } + } + Vector3.releaseTempInstance(diff); + Vector3.releaseTempInstance(edge1); + Vector3.releaseTempInstance(edge2); + Vector3.releaseTempInstance(norm); + return result; + } + + /** + * @param plane + * @param locationStore + * if not null, and this ray intersects the plane, the world location of the point of intersection is + * stored in this vector. + * @return true if the ray collides with the given Plane + * @throws NullPointerException + * if the plane is null. + */ + @Override + public boolean intersectsPlane(final ReadOnlyPlane plane, final Vector3 locationStore) { + final ReadOnlyVector3 normal = plane.getNormal(); + final double denominator = normal.dot(_direction); + + if (denominator > -MathUtils.EPSILON && denominator < MathUtils.EPSILON) { + return false; // coplanar + } + + final double numerator = -normal.dot(_origin) + plane.getConstant(); + final double ratio = numerator / denominator; + + if (ratio < MathUtils.EPSILON) { + return false; // intersects behind _origin + } + + if (locationStore != null) { + locationStore.set(_direction).multiplyLocal(ratio).addLocal(_origin); + } + + return true; + } + + /** + * @param point + * @param store + * if not null, the closest point is stored in this param + * @return the squared distance from this ray to the given point. + * @throws NullPointerException + * if the point is null. + */ + @Override + public double distanceSquared(final ReadOnlyVector3 point, final Vector3 store) { + final Vector3 vectorA = Vector3.fetchTempInstance(); + vectorA.set(point).subtractLocal(_origin); + final double t0 = _direction.dot(vectorA); + if (t0 > 0) { + // d = |P - (O + t*D)| + vectorA.set(_direction).multiplyLocal(t0); + vectorA.addLocal(_origin); + } else { + // ray is closest to origin point + vectorA.set(_origin); + } + + // Save away the closest point if requested. + if (store != null) { + store.set(vectorA); + } + + point.subtract(vectorA, vectorA); + final double lSQ = vectorA.lengthSquared(); + Vector3.releaseTempInstance(vectorA); + return lSQ; + } + + /** + * Check a ray... if it is null or the values of its origin or direction are NaN or infinite, return false. Else + * return true. + * + * @param ray + * the ray to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyRay3 ray) { + if (ray == null) { + return false; + } + + return Vector3.isValid(ray.getDirection()) && Vector3.isValid(ray.getOrigin()); + } + + /** + * @return the string representation of this ray. + */ + @Override + public String toString() { + return "com.ardor3d.math.Ray [Origin: " + _origin + " - Direction: " + _direction + "]"; + } + + /** + * @param o + * the object to compare for equality + * @return true if this ray and the provided ray have the same constant and normal values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyRay3)) { + return false; + } + final ReadOnlyRay3 comp = (ReadOnlyRay3) o; + return _origin.equals(comp.getOrigin()) && _direction.equals(comp.getDirection()); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Ray3 clone() { + return new Ray3(this); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Ray that is intended for temporary use in calculations and so forth. Multiple calls to the + * method should return instances of this class that are not currently in use. + */ + public final static Ray3 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Ray3.RAY_POOL.fetch(); + } else { + return new Ray3(); + } + } + + /** + * Releases a Ray back to be used by a future call to fetchTempInstance. TAKE CARE: this Ray object should no longer + * have other classes referencing it or "Bad Things" will happen. + * + * @param ray + * the Ray to release. + */ + public final static void releaseTempInstance(final Ray3 ray) { + if (MathConstants.useMathPools) { + Ray3.RAY_POOL.release(ray); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle2.java b/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle2.java new file mode 100644 index 0000000..ced2fe8 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle2.java @@ -0,0 +1,295 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyRectangle2; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * <p> + * Defines a finite plane within two dimensional space that is specified via an origin (x,y - considered bottom left + * usually) and a width and height. + * </p> + * This class is at least partially patterned after awt's Rectangle class. + */ + +public class Rectangle2 implements Cloneable, Savable, Externalizable, ReadOnlyRectangle2, Poolable { + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Rectangle2> RECTANGLE_POOL = ObjectPool.create(Rectangle2.class, + MathConstants.maxMathPoolSize); + + private int _x; + private int _y; + private int _width; + private int _height; + + /** + * Constructor creates a new <code>Rectangle2</code> with its origin at 0,0 and width/height of 0. + */ + public Rectangle2() {} + + /** + * Constructor creates a new <code>Rectangle2</code> with using the given x,y,width and height values. + * + */ + public Rectangle2(final int x, final int y, final int width, final int height) { + setX(x); + setY(y); + setWidth(width); + setHeight(height); + } + + /** + * Constructor creates a new <code>Rectangle2</code> using the values of the provided source rectangle. + * + * @param source + * the rectangle to copy from + */ + public Rectangle2(final ReadOnlyRectangle2 source) { + set(source); + } + + @Override + public int getX() { + return _x; + } + + /** + * @param x + * the new x coordinate of the origin of this rectangle + */ + public void setX(final int x) { + _x = x; + } + + @Override + public int getY() { + return _y; + } + + /** + * @param y + * the new y coordinate of the origin of this rectangle + */ + public void setY(final int y) { + _y = y; + } + + @Override + public int getWidth() { + return _width; + } + + /** + * @param width + * the new width of this rectangle + */ + public void setWidth(final int width) { + _width = width; + } + + @Override + public int getHeight() { + return _height; + } + + /** + * @param height + * the new height of this rectangle + */ + public void setHeight(final int height) { + _height = height; + } + + public Rectangle2 set(final int x, final int y, final int width, final int height) { + _x = x; + _y = y; + _width = width; + _height = height; + return this; + } + + public Rectangle2 set(final ReadOnlyRectangle2 rect) { + return set(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()); + } + + public Rectangle2 intersect(final ReadOnlyRectangle2 other, final Rectangle2 store) { + Rectangle2 rVal = store; + if (rVal == null) { + rVal = new Rectangle2(); + } + final int x1 = Math.max(getX(), other.getX()); + final int y1 = Math.max(getY(), other.getY()); + final int x2 = Math.min(getX() + getWidth(), other.getX() + other.getWidth()); + final int y2 = Math.min(getY() + getHeight(), other.getY() + other.getHeight()); + rVal.set(x1, y1, x2 - x1, y2 - y1); + return rVal; + } + + public static Rectangle2 intersect(final ReadOnlyRectangle2 src1, final ReadOnlyRectangle2 src2, + final Rectangle2 store) { + Rectangle2 rVal = store; + if (rVal == null) { + rVal = new Rectangle2(); + } + rVal.set(src1); + return rVal.intersect(src2, rVal); + } + + /** + * @return the string representation of this rectangle. + */ + @Override + public String toString() { + return "com.ardor3d.math.Rectangle2 [origin: " + _x + ", " + _y + " width: " + _width + " height: " + _height + + "]"; + } + + /** + * @return returns a unique code for this rectangle object based on its values. If two rectangles are numerically + * equal, they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _x; + result += 31 * result + _y; + result += 31 * result + _width; + result += 31 * result + _height; + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this rectangle and the provided rectangle have the same origin and dimensions + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyRectangle2)) { + return false; + } + final ReadOnlyRectangle2 comp = (ReadOnlyRectangle2) o; + return comp.getX() == getX() && comp.getY() == getY() && comp.getWidth() == getWidth() + && comp.getHeight() == getHeight(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Rectangle2 clone() { + return new Rectangle2(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_x, "x", 0); + capsule.write(_y, "y", 0); + capsule.write(_width, "width", 0); + capsule.write(_height, "height", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _x = capsule.readInt("x", 0); + _y = capsule.readInt("y", 0); + _width = capsule.readInt("width", 0); + _height = capsule.readInt("height", 0); + } + + @Override + public Class<? extends Rectangle2> getClassTag() { + return this.getClass(); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setX(in.readInt()); + setY(in.readInt()); + setWidth(in.readInt()); + setHeight(in.readInt()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeInt(_x); + out.writeInt(_y); + out.writeInt(_width); + out.writeInt(_height); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Rectangle2 that is intended for temporary use in calculations and so forth. Multiple calls + * to the method should return instances of this class that are not currently in use. + */ + public final static Rectangle2 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Rectangle2.RECTANGLE_POOL.fetch(); + } else { + return new Rectangle2(); + } + } + + /** + * Releases a Rectangle2 back to be used by a future call to fetchTempInstance. TAKE CARE: this object should no + * longer have other classes referencing it or "Bad Things" will happen. + * + * @param rectangle + * the Rectangle2 to release. + */ + public final static void releaseTempInstance(final Rectangle2 rectangle) { + if (MathConstants.useMathPools) { + Rectangle2.RECTANGLE_POOL.release(rectangle); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle3.java b/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle3.java new file mode 100644 index 0000000..3454c4e --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Rectangle3.java @@ -0,0 +1,306 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+
+import com.ardor3d.math.type.ReadOnlyRectangle3;
+import com.ardor3d.math.type.ReadOnlyVector3;
+import com.ardor3d.util.export.InputCapsule;
+import com.ardor3d.util.export.OutputCapsule;
+import com.ardor3d.util.export.Savable;
+
+/**
+ * Defines a finite plane within three dimensional space that is specified via three points (A, B, C). These three
+ * points define a triangle with the forth point defining the rectangle ((B + C) - A.
+ */
+
+public class Rectangle3 implements Cloneable, Savable, Externalizable, ReadOnlyRectangle3, Poolable {
+ private static final long serialVersionUID = 1L;
+
+ private static final ObjectPool<Rectangle3> RECTANGLE_POOL = ObjectPool.create(Rectangle3.class,
+ MathConstants.maxMathPoolSize);
+
+ private final Vector3 _a = new Vector3();
+ private final Vector3 _b = new Vector3();
+ private final Vector3 _c = new Vector3();
+
+ /**
+ * Constructor creates a new Rectangle3 with corners at origin.
+ */
+ public Rectangle3() {}
+
+ /**
+ * Constructor creates a new Rectangle3 using the values of the provided source rectangle.
+ *
+ * @param source
+ * the rectangle to copy from
+ */
+ public Rectangle3(final ReadOnlyRectangle3 source) {
+ this(source.getA(), source.getB(), source.getC());
+ }
+
+ /**
+ * Constructor creates a new Rectangle3 with defined A, B, and C points that define the area of the rectangle.
+ *
+ * @param a
+ * the first corner of the rectangle.
+ * @param b
+ * the second corner of the rectangle.
+ * @param c
+ * the third corner of the rectangle.
+ */
+ public Rectangle3(final ReadOnlyVector3 a, final ReadOnlyVector3 b, final ReadOnlyVector3 c) {
+ setA(a);
+ setB(b);
+ setC(c);
+ }
+
+ /**
+ * Copy the value of the given source Rectangle3 into this Rectangle3.
+ *
+ * @param source
+ * the source of the data to copy.
+ * @return this rectangle for chaining
+ * @throws NullPointerException
+ * if source is null.
+ */
+ public Rectangle3 set(final ReadOnlyRectangle3 source) {
+ _a.set(source.getA());
+ _b.set(source.getB());
+ _c.set(source.getC());
+ return this;
+ }
+
+ /**
+ * getA returns the first point of the rectangle.
+ *
+ * @return the first point of the rectangle.
+ */
+ @Override
+ public ReadOnlyVector3 getA() {
+ return _a;
+ }
+
+ /**
+ * setA sets the first point of the rectangle.
+ *
+ * @param a
+ * the first point of the rectangle.
+ */
+ public void setA(final ReadOnlyVector3 a) {
+ _a.set(a);
+ }
+
+ /**
+ * getB returns the second point of the rectangle.
+ *
+ * @return the second point of the rectangle.
+ */
+ @Override
+ public ReadOnlyVector3 getB() {
+ return _b;
+ }
+
+ /**
+ * setB sets the second point of the rectangle.
+ *
+ * @param b
+ * the second point of the rectangle.
+ */
+ public void setB(final ReadOnlyVector3 b) {
+ _b.set(b);
+ }
+
+ /**
+ * getC returns the third point of the rectangle.
+ *
+ * @return the third point of the rectangle.
+ */
+ @Override
+ public ReadOnlyVector3 getC() {
+ return _c;
+ }
+
+ /**
+ * setC sets the third point of the rectangle.
+ *
+ * @param c
+ * the third point of the rectangle.
+ */
+ public void setC(final ReadOnlyVector3 c) {
+ _c.set(c);
+ }
+
+ /**
+ * random returns a random point within the plane defined by: A, B, C, and (B + C) - A.
+ *
+ * @param result
+ * Vector to store result in
+ * @return a random point within the rectangle.
+ */
+ @Override
+ public Vector3 random(Vector3 result) {
+ if (result == null) {
+ result = new Vector3();
+ }
+
+ final double s = MathUtils.nextRandomFloat();
+ final double t = MathUtils.nextRandomFloat();
+
+ final double aMod = 1.0 - s - t;
+ final Vector3 temp1 = Vector3.fetchTempInstance();
+ final Vector3 temp2 = Vector3.fetchTempInstance();
+ final Vector3 temp3 = Vector3.fetchTempInstance();
+ result.set(_a.multiply(aMod, temp1).addLocal(_b.multiply(s, temp2).addLocal(_c.multiply(t, temp3))));
+ Vector3.releaseTempInstance(temp1);
+ Vector3.releaseTempInstance(temp2);
+ Vector3.releaseTempInstance(temp3);
+ return result;
+ }
+
+ /**
+ * @return the string representation of this rectangle.
+ */
+ @Override
+ public String toString() {
+ return "com.ardor3d.math.Rectangle3 [A: " + _a + " B: " + _b + " C: " + _c + "]";
+ }
+
+ /**
+ * @return returns a unique code for this rectangle object based on its values. If two rectangles are numerically
+ * equal, they will return the same hash code value.
+ */
+ @Override
+ public int hashCode() {
+ int result = 17;
+
+ result += 31 * result + _a.hashCode();
+ result += 31 * result + _b.hashCode();
+ result += 31 * result + _c.hashCode();
+
+ return result;
+ }
+
+ /**
+ * @param o
+ * the object to compare for equality
+ * @return true if this rectangle and the provided rectangle have the same corner values.
+ */
+ @Override
+ public boolean equals(final Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof ReadOnlyRectangle3)) {
+ return false;
+ }
+ final ReadOnlyRectangle3 comp = (ReadOnlyRectangle3) o;
+ return _a.equals(comp.getA()) && _b.equals(comp.getB()) && _c.equals(comp.getC());
+ }
+
+ // /////////////////
+ // Method for Cloneable
+ // /////////////////
+
+ @Override
+ public Rectangle3 clone() {
+ return new Rectangle3(this);
+ }
+
+ // /////////////////
+ // Methods for Savable
+ // /////////////////
+
+ @Override
+ public void write(final OutputCapsule capsule) throws IOException {
+ capsule.write(_a, "a", new Vector3(Vector3.ZERO));
+ capsule.write(_b, "b", new Vector3(Vector3.ZERO));
+ capsule.write(_c, "c", new Vector3(Vector3.ZERO));
+ }
+
+ @Override
+ public void read(final InputCapsule capsule) throws IOException {
+ _a.set((Vector3) capsule.readSavable("a", new Vector3(Vector3.ZERO)));
+ _b.set((Vector3) capsule.readSavable("b", new Vector3(Vector3.ZERO)));
+ _c.set((Vector3) capsule.readSavable("c", new Vector3(Vector3.ZERO)));
+ }
+
+ @Override
+ public Class<? extends Rectangle3> getClassTag() {
+ return this.getClass();
+ }
+
+ // /////////////////
+ // Methods for Externalizable
+ // /////////////////
+
+ /**
+ * Used with serialization. Not to be called manually.
+ *
+ * @param in
+ * ObjectInput
+ * @throws IOException
+ * @throws ClassNotFoundException
+ */
+ @Override
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ setA((Vector3) in.readObject());
+ setB((Vector3) in.readObject());
+ setC((Vector3) in.readObject());
+ }
+
+ /**
+ * Used with serialization. Not to be called manually.
+ *
+ * @param out
+ * ObjectOutput
+ * @throws IOException
+ */
+ @Override
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ out.writeObject(_a);
+ out.writeObject(_b);
+ out.writeObject(_c);
+ }
+
+ // /////////////////
+ // Methods for creating temp variables (pooling)
+ // /////////////////
+
+ /**
+ * @return An instance of Rectangle3 that is intended for temporary use in calculations and so forth. Multiple calls
+ * to the method should return instances of this class that are not currently in use.
+ */
+ public final static Rectangle3 fetchTempInstance() {
+ if (MathConstants.useMathPools) {
+ return Rectangle3.RECTANGLE_POOL.fetch();
+ } else {
+ return new Rectangle3();
+ }
+ }
+
+ /**
+ * Releases a Rectangle3 back to be used by a future call to fetchTempInstance. TAKE CARE: this object should no
+ * longer have other classes referencing it or "Bad Things" will happen.
+ *
+ * @param rectangle
+ * the Rectangle3 to release.
+ */
+ public final static void releaseTempInstance(final Rectangle3 rectangle) {
+ if (MathConstants.useMathPools) {
+ Rectangle3.RECTANGLE_POOL.release(rectangle);
+ }
+ }
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Ring.java b/ardor3d-math/src/main/java/com/ardor3d/math/Ring.java new file mode 100644 index 0000000..d734003 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Ring.java @@ -0,0 +1,380 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyRing; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * <code>Ring</code> defines a flat ring or disk within three dimensional space that is specified via the ring's center + * point, an up vector, an inner radius, and an outer radius. + */ + +public class Ring implements Cloneable, Savable, Externalizable, ReadOnlyRing, Poolable { + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Ring> RING_POOL = ObjectPool.create(Ring.class, MathConstants.maxMathPoolSize); + + private final Vector3 _center = new Vector3(); + private final Vector3 _up = new Vector3(Vector3.UNIT_Y); + private double _innerRadius, _outerRadius; + + /** + * Constructor creates a new <code>Ring</code> lying on the XZ plane, centered at the origin, with an inner radius + * of zero and an outer radius of one (a unit disk). + */ + public Ring() { + _innerRadius = 0.0; + _outerRadius = 1.0; + } + + /** + * Copy constructor. + * + * @param source + * the ring to copy from. + */ + public Ring(final ReadOnlyRing source) { + this(source.getCenter(), source.getUp(), source.getInnerRadius(), source.getOuterRadius()); + } + + /** + * Constructor creates a new <code>Ring</code> with defined center point, up vector, and inner and outer radii. + * + * @param center + * the center of the ring. + * @param up + * the unit up vector defining the ring's orientation. + * @param innerRadius + * the ring's inner radius. + * @param outerRadius + * the ring's outer radius. + */ + public Ring(final ReadOnlyVector3 center, final ReadOnlyVector3 up, final double innerRadius, + final double outerRadius) { + _center.set(center); + _up.set(up); + _innerRadius = innerRadius; + _outerRadius = outerRadius; + } + + /** + * Copy the value of the given source Ring into this Ring. + * + * @param source + * the source of the data to copy. + * @return this ring for chaining + * @throws NullPointerException + * if source is null. + */ + public Ring set(final ReadOnlyRing source) { + _center.set(source.getCenter()); + _up.set(source.getUp()); + _innerRadius = source.getInnerRadius(); + _outerRadius = source.getOuterRadius(); + return this; + } + + /** + * <code>getCenter</code> returns the center of the ring. + * + * @return the center of the ring. + */ + @Override + public ReadOnlyVector3 getCenter() { + return _center; + } + + /** + * <code>setCenter</code> sets the center of the ring. + * + * @param center + * the center of the ring. + */ + public void setCenter(final ReadOnlyVector3 center) { + _center.set(center); + } + + /** + * <code>getUp</code> returns the ring's up vector. + * + * @return the ring's up vector. + */ + @Override + public ReadOnlyVector3 getUp() { + return _up; + } + + /** + * <code>setUp</code> sets the ring's up vector. + * + * @param up + * the ring's up vector. + */ + public void setUp(final ReadOnlyVector3 up) { + _up.set(up); + } + + /** + * <code>getInnerRadius</code> returns the ring's inner radius. + * + * @return the ring's inner radius. + */ + @Override + public double getInnerRadius() { + return _innerRadius; + } + + /** + * <code>setInnerRadius</code> sets the ring's inner radius. + * + * @param innerRadius + * the ring's inner radius. + */ + public void setInnerRadius(final double innerRadius) { + _innerRadius = innerRadius; + } + + /** + * <code>getOuterRadius</code> returns the ring's outer radius. + * + * @return the ring's outer radius. + */ + @Override + public double getOuterRadius() { + return _outerRadius; + } + + /** + * <code>setOuterRadius</code> sets the ring's outer radius. + * + * @param outerRadius + * the ring's outer radius. + */ + public void setOuterRadius(final double outerRadius) { + _outerRadius = outerRadius; + } + + /** + * + * <code>random</code> returns a random point within the ring. + * + * @param store + * Vector to store result in + * @return a random point within the ring. + */ + @Override + public Vector3 random(final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final Vector3 b1 = Vector3.fetchTempInstance(); + final Vector3 b2 = Vector3.fetchTempInstance(); + + // compute a random radius according to the ring area distribution + final double inner2 = _innerRadius * _innerRadius; + final double outer2 = _outerRadius * _outerRadius; + final double r = Math.sqrt(inner2 + MathUtils.nextRandomFloat() * (outer2 - inner2)); + final double theta = MathUtils.nextRandomFloat() * MathUtils.TWO_PI; + + _up.cross(Vector3.UNIT_X, b1); + if (b1.lengthSquared() < MathUtils.EPSILON) { + _up.cross(Vector3.UNIT_Y, b1); + } + b1.normalizeLocal(); + _up.cross(b1, b2); + result.set(b1).multiplyLocal(r * MathUtils.cos(theta)).addLocal(_center); + b2.scaleAdd(r * MathUtils.sin(theta), result, result); + + Vector3.releaseTempInstance(b1); + Vector3.releaseTempInstance(b2); + + return result; + } + + /** + * Check a ring... if it is null or its radii, or the doubles of its center or up are NaN or infinite, return false. + * Else return true. + * + * @param ring + * the ring to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyRing ring) { + if (ring == null) { + return false; + } + if (Double.isNaN(ring.getInnerRadius()) || Double.isInfinite(ring.getInnerRadius())) { + return false; + } + if (Double.isNaN(ring.getOuterRadius()) || Double.isInfinite(ring.getOuterRadius())) { + return false; + } + + return Vector3.isValid(ring.getCenter()) && Vector3.isValid(ring.getUp()); + } + + /** + * @return the string representation of this ring. + */ + @Override + public String toString() { + return "com.ardor3d.math.Ring [Center: " + _center + " Up: " + _up + " - radii, outer: " + _outerRadius + + " inner: " + _innerRadius + "]"; + } + + /** + * @return returns a unique code for this ring object based on its values. If two rings are numerically equal, they + * will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _center.hashCode(); + result += 31 * result + _up.hashCode(); + + final long ir = Double.doubleToLongBits(getInnerRadius()); + result += 31 * result + (int) (ir ^ ir >>> 32); + + final long or = Double.doubleToLongBits(getOuterRadius()); + result += 31 * result + (int) (or ^ or >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this ring and the provided ring have the same constant and normal values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyRing)) { + return false; + } + final ReadOnlyRing comp = (ReadOnlyRing) o; + return getInnerRadius() == comp.getInnerRadius() && getOuterRadius() == comp.getOuterRadius() + && _up.equals(comp.getUp()) && _center.equals(comp.getCenter()); + + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Ring clone() { + return new Ring(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Ring> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_center, "center", new Vector3(Vector3.ZERO)); + capsule.write(_up, "up", new Vector3(Vector3.UNIT_Z)); + capsule.write(_innerRadius, "innerRadius", 0.0); + capsule.write(_outerRadius, "outerRadius", 1.0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _center.set((Vector3) capsule.readSavable("center", new Vector3(Vector3.ZERO))); + _up.set((Vector3) capsule.readSavable("up", new Vector3(Vector3.UNIT_Z))); + _innerRadius = capsule.readDouble("innerRadius", 0.0); + _outerRadius = capsule.readDouble("outerRadius", 1.0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setCenter((Vector3) in.readObject()); + setUp((Vector3) in.readObject()); + setInnerRadius(in.readDouble()); + setOuterRadius(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeObject(_center); + out.writeObject(_up); + out.writeDouble(_innerRadius); + out.writeDouble(_outerRadius); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Ring that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Ring fetchTempInstance() { + if (MathConstants.useMathPools) { + return Ring.RING_POOL.fetch(); + } else { + return new Ring(); + } + } + + /** + * Releases a Ring back to be used by a future call to fetchTempInstance. TAKE CARE: this Ring object should no + * longer have other classes referencing it or "Bad Things" will happen. + * + * @param ring + * the Ring to release. + */ + public final static void releaseTempInstance(final Ring ring) { + if (MathConstants.useMathPools) { + Ring.RING_POOL.release(ring); + } + } +}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Transform.java b/ardor3d-math/src/main/java/com/ardor3d/math/Transform.java new file mode 100644 index 0000000..47d0a88 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Transform.java @@ -0,0 +1,1061 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import com.ardor3d.math.type.ReadOnlyMatrix3; +import com.ardor3d.math.type.ReadOnlyMatrix4; +import com.ardor3d.math.type.ReadOnlyQuaternion; +import com.ardor3d.math.type.ReadOnlyTransform; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Transform models a transformation in 3d space as: Y = M*X+T, with M being a Matrix3 and T is a Vector3. Generally M + * will be a rotation only matrix in which case it is represented by the matrix and scale fields as R*S, where S is a + * positive scale vector. For non-uniform scales and reflections, use setMatrix, which will consider M as being a + * general 3x3 matrix and disregard anything set in scale. + */ +public class Transform implements Cloneable, Savable, Externalizable, ReadOnlyTransform, Poolable { + /** Used with equals method to determine if two Transforms are close enough to be considered equal. */ + public static final double ALLOWED_DEVIANCE = 0.00000001; + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Transform> TRANS_POOL = ObjectPool.create(Transform.class, + MathConstants.maxMathPoolSize); + + /** + * Identity transform. + */ + public static final ReadOnlyTransform IDENTITY = new Transform(Matrix3.IDENTITY, Vector3.ONE, Vector3.ZERO, true, + true, true); + + protected final Matrix3 _matrix = new Matrix3(Matrix3.IDENTITY); + protected final Vector3 _translation = new Vector3(Vector3.ZERO); + protected final Vector3 _scale = new Vector3(Vector3.ONE); + + /** + * true if this transform is guaranteed to be the identity matrix. + */ + protected boolean _identity; + + /** + * true if the matrix portion of this transform is only rotation. + */ + protected boolean _rotationMatrix; + + /** + * true if scale is used and scale is guaranteed to be uniform. + */ + protected boolean _uniformScale; + + /** + * Constructs a new Transform object. + */ + public Transform() { + _identity = true; + _rotationMatrix = true; + _uniformScale = true; + + } + + /** + * Constructs a new Transform object from the information stored in the given source Transform. + * + * @param source + * @throws NullPointerException + * if source is null. + */ + public Transform(final ReadOnlyTransform source) { + _matrix.set(source.getMatrix()); + _scale.set(source.getScale()); + _translation.set(source.getTranslation()); + + _identity = source.isIdentity(); + _rotationMatrix = source.isRotationMatrix(); + _uniformScale = source.isUniformScale(); + + } + + /** + * Internal only constructor, generally used for making an immutable transform. + * + * @param matrix + * @param scale + * @param translation + * @param identity + * @param rotationMatrix + * @param uniformScale + * @throws NullPointerException + * if a param is null. + */ + protected Transform(final ReadOnlyMatrix3 matrix, final ReadOnlyVector3 scale, final ReadOnlyVector3 translation, + final boolean identity, final boolean rotationMatrix, final boolean uniformScale) { + _matrix.set(matrix); + _scale.set(scale); + _translation.set(translation); + + _identity = identity; + _rotationMatrix = rotationMatrix; + _uniformScale = uniformScale; + } + + @Override + public ReadOnlyMatrix3 getMatrix() { + return _matrix; + } + + @Override + public ReadOnlyVector3 getTranslation() { + return _translation; + } + + @Override + public ReadOnlyVector3 getScale() { + return _scale; + } + + /** + * @return true if this transform is guaranteed to be the identity matrix. + */ + @Override + public boolean isIdentity() { + return _identity; + } + + /** + * @return true if the matrix portion of this transform is only rotation. + */ + @Override + public boolean isRotationMatrix() { + return _rotationMatrix; + } + + /** + * @return true if scale is used and scale is guaranteed to be uniform. + */ + @Override + public boolean isUniformScale() { + return _uniformScale; + } + + /** + * Resets this transform to identity and resets all flags. + * + * @return this Transform for chaining. + */ + public Transform setIdentity() { + _matrix.set(Matrix3.IDENTITY); + _scale.set(Vector3.ONE); + _translation.set(Vector3.ZERO); + _identity = true; + _rotationMatrix = true; + _uniformScale = true; + return this; + } + + /** + * Sets the matrix portion of this transform to the given value. + * + * NB: Calling this with a matrix that is not purely rotational (orthonormal) will result in a Transform whose scale + * comes from its matrix. Further attempts to set scale directly will throw an error. + * + * @param rotation + * our new matrix. + * @return this transform for chaining. + * @throws NullPointerException + * if rotation is null. + * @see Matrix3#isOrthonormal() + */ + public Transform setRotation(final ReadOnlyMatrix3 rotation) { + _matrix.set(rotation); + updateFlags(false); + return this; + } + + /** + * Sets the matrix portion of this transform to the rotational value of the given Quaternion. Calling this allows + * scale to be set and used. + * + * @param rotation + * @return this transform for chaining. + * @throws NullPointerException + * if rotation is null. + */ + public Transform setRotation(final ReadOnlyQuaternion rotation) { + _matrix.set(rotation); + updateFlags(true); + return this; + } + + /** + * Sets the translation portion of this transform to the given value. + * + * @param translation + * @return this transform for chaining. + * @throws NullPointerException + * if translation is null. + */ + public Transform setTranslation(final ReadOnlyVector3 translation) { + _translation.set(translation); + _identity = false; + return this; + } + + /** + * Sets the translation portion of this transform to the given values. + * + * @param x + * @param y + * @param z + * @return this transform for chaining. + */ + public Transform setTranslation(final double x, final double y, final double z) { + _translation.set(x, y, z); + _identity = false; + return this; + } + + /** + * Sets the scale portion of this transform to the given value. + * + * @param scale + * @return this transform for chaining. + * @throws NullPointerException + * if scale is null. + * @throws TransformException + * if this transform has a generic 3x3 matrix set. + * @throws IllegalArgumentException + * if scale is (0,0,0) + */ + public Transform setScale(final ReadOnlyVector3 scale) { + if (!_rotationMatrix) { + throw new TransformException( + "Scale is already provided by 3x3 matrix. If this is a mistake, consider using setRotation instead of setMatrix."); + } + if (scale.getX() == 0.0 && scale.getY() == 0.0 && scale.getZ() == 0.0) { + throw new IllegalArgumentException("scale may not be ZERO."); + } + + _scale.set(scale); + _identity = _identity && scale.getX() == 1.0 && scale.getY() == 1.0 && scale.getZ() == 1.0; + _uniformScale = scale.getX() == scale.getY() && scale.getY() == scale.getZ(); + return this; + } + + /** + * Sets the scale portion of this transform to the given values. + * + * @param x + * @param y + * @param z + * @return this transform for chaining. + * @throws NullPointerException + * if scale is null. + * @throws TransformException + * if this transform has a generic 3x3 matrix set. + * @throws IllegalArgumentException + * if scale is (0,0,0) + */ + public Transform setScale(final double x, final double y, final double z) { + if (!_rotationMatrix) { + throw new TransformException( + "Scale is already provided by 3x3 matrix. If this is a mistake, consider using setRotation instead of setMatrix."); + } + if (x == 0.0 && y == 0.0 && z == 0.0) { + throw new IllegalArgumentException("scale may not be ZERO."); + } + + _scale.set(x, y, z); + _identity = false; + _uniformScale = x == y && y == z; + return this; + } + + /** + * Sets the scale portion of this transform to the given value as a vector (u, u, u) + * + * @param uniformScale + * @return this transform for chaining. + * @throws TransformException + * if this transform has a generic 3x3 matrix set. + * @throws IllegalArgumentException + * if uniformScale is 0 + */ + public Transform setScale(final double uniformScale) { + if (!_rotationMatrix) { + throw new TransformException( + "Scale is already provided by 3x3 matrix. If this is a mistake, consider using setRotation instead of setMatrix."); + } + if (uniformScale == 0.0) { + throw new IllegalArgumentException("scale may not be ZERO."); + } + + _scale.set(uniformScale, uniformScale, uniformScale); + _identity = false; + _uniformScale = true; + return this; + } + + /** + * Copies the given transform values into this transform object. + * + * @param source + * @return this transform for chaining. + * @throws NullPointerException + * if source is null. + */ + public Transform set(final ReadOnlyTransform source) { + if (source.isIdentity()) { + setIdentity(); + } else { + _matrix.set(source.getMatrix()); + _scale.set(source.getScale()); + _translation.set(source.getTranslation()); + + _identity = false; + _rotationMatrix = source.isRotationMatrix(); + _uniformScale = source.isUniformScale(); + } + return this; + } + + /** + * Locally adds to the translation of this transform. + * + * @param x + * @param y + * @param z + * @return this transform for chaining. + */ + public Transform translate(final double x, final double y, final double z) { + _translation.addLocal(x, y, z); + _identity = _identity && _translation.equals(Vector3.ZERO); + return this; + } + + /** + * Locally adds to the translation of this transform. + * + * @param vec + * @return this transform for chaining. + */ + public Transform translate(final ReadOnlyVector3 vec) { + _translation.addLocal(vec); + _identity = _identity && _translation.equals(Vector3.ZERO); + return this; + } + + /** + * Locally applies this transform to the given point: P' = M*P+T + * + * @param point + * @return the transformed point. + * @throws NullPointerException + * if point is null. + */ + @Override + public Vector3 applyForward(final Vector3 point) { + if (point == null) { + throw new NullPointerException(); + } + + if (_identity) { + // No need to make changes + // Y = X + return point; + } + + if (_rotationMatrix) { + // Scale is separate from matrix + // Y = R*S*X + T + point.set(point.getX() * _scale.getX(), point.getY() * _scale.getY(), point.getZ() * _scale.getZ()); + _matrix.applyPost(point, point); + point.addLocal(_translation); + return point; + } + + // scale is part of matrix. + // Y = M*X + T + _matrix.applyPost(point, point); + point.addLocal(_translation); + return point; + + } + + /** + * Applies this transform to the given point and returns the result in the given store vector: P' = M*P+T + * + * @param point + * @param store + * the vector to store our result in. if null, a new vector will be created. + * @return the transformed point. + * @throws NullPointerException + * if point is null. + */ + @Override + public Vector3 applyForward(final ReadOnlyVector3 point, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(point); + return applyForward(result); + } + + /** + * Locally applies the inverse of this transform to the given point: P' = M^{-1}*(P-T) + * + * @param point + * @return the transformed point. + * @throws NullPointerException + * if point is null. + */ + @Override + public Vector3 applyInverse(final Vector3 point) { + if (point == null) { + throw new NullPointerException(); + } + + if (_identity) { + // No need to make changes + // P' = P + return point; + } + + // Back track translation + point.subtractLocal(_translation); + + if (_rotationMatrix) { + // Scale is separate from matrix so... + // P' = S^{-1}*R^t*(P - T) + _matrix.applyPre(point, point); + if (_uniformScale) { + point.divideLocal(_scale.getX()); + } else { + point.setX(point.getX() / _scale.getX()); + point.setY(point.getY() / _scale.getY()); + point.setZ(point.getZ() / _scale.getZ()); + } + } else { + // P' = M^{-1}*(P - T) + final Matrix3 invertedMatrix = _matrix.invert(Matrix3.fetchTempInstance()); + invertedMatrix.applyPost(point, point); + Matrix3.releaseTempInstance(invertedMatrix); + } + + return point; + } + + /** + * Applies the inverse of this transform to the given point and returns the result in the given store vector: P' = + * M^{-1}*(P-T) + * + * @param point + * @param store + * the vector to store our result in. if null, a new vector will be created. + * @return the transformed point. + * @throws NullPointerException + * if point is null. + */ + @Override + public Vector3 applyInverse(final ReadOnlyVector3 point, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(point); + return applyInverse(result); + } + + /** + * Locally applies this transform to the given vector: V' = M*V + * + * @param vector + * @return the transformed vector. + * @throws NullPointerException + * if vector is null. + */ + @Override + public Vector3 applyForwardVector(final Vector3 vector) { + if (vector == null) { + throw new NullPointerException(); + } + + if (_identity) { + // No need to make changes + // V' = V + return vector; + } + + if (_rotationMatrix) { + // Scale is separate from matrix + // V' = R*S*V + vector.set(vector.getX() * _scale.getX(), vector.getY() * _scale.getY(), vector.getZ() * _scale.getZ()); + _matrix.applyPost(vector, vector); + return vector; + } + + // scale is part of matrix. + // V' = M*V + _matrix.applyPost(vector, vector); + return vector; + + } + + /** + * Applies this transform to the given vector and returns the result in the given store vector: V' = M*V + * + * @param vector + * @param store + * the vector to store our result in. if null, a new vector will be created. + * @return the transformed vector. + * @throws NullPointerException + * if vector is null. + */ + @Override + public Vector3 applyForwardVector(final ReadOnlyVector3 vector, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(vector); + return applyForwardVector(result); + } + + /** + * Locally applies the inverse of this transform to the given vector: V' = M^{-1}*V + * + * @param vector + * @return the transformed vector. + * @throws NullPointerException + * if vector is null. + */ + @Override + public Vector3 applyInverseVector(final Vector3 vector) { + if (vector == null) { + throw new NullPointerException(); + } + + if (_identity) { + // No need to make changes + // V' = V + return vector; + } + + if (_rotationMatrix) { + // Scale is separate from matrix so... + // V' = S^{-1}*R^t*V + _matrix.applyPre(vector, vector); + if (_uniformScale) { + vector.divideLocal(_scale.getX()); + } else { + vector.setX(vector.getX() / _scale.getX()); + vector.setY(vector.getY() / _scale.getY()); + vector.setZ(vector.getZ() / _scale.getZ()); + } + } else { + // V' = M^{-1}*V + final Matrix3 invertedMatrix = _matrix.invert(Matrix3.fetchTempInstance()); + invertedMatrix.applyPost(vector, vector); + Matrix3.releaseTempInstance(invertedMatrix); + } + + return vector; + } + + /** + * Applies the inverse of this transform to the given vector and returns the result in the given store vector: V' = + * M^{-1}*V + * + * @param vector + * @param store + * the vector to store our result in. if null, a new vector will be created. + * @return the transformed vector. + * @throws NullPointerException + * if vector is null. + */ + @Override + public Vector3 applyInverseVector(final ReadOnlyVector3 vector, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + result.set(vector); + return applyInverseVector(result); + } + + /** + * Calculates the product of this transform with the given "transformBy" transform (P = this * T) and stores this in + * store. + * + * @param transformBy + * @param store + * the transform to store the result in for return. If null, a new transform object is created and + * returned. It is NOT safe for store to be the same object as transformBy or "this". + * @return the product + * @throws NullPointerException + * if transformBy is null. + */ + @Override + public Transform multiply(final ReadOnlyTransform transformBy, final Transform store) { + Transform result = store; + if (result == null) { + result = new Transform(); + } + + if (_identity) { + return result.set(transformBy); + } + + if (transformBy.isIdentity()) { + return result.set(this); + } + + if (_rotationMatrix && transformBy.isRotationMatrix() && _uniformScale) { + result._rotationMatrix = true; + final Matrix3 newRotation = result._matrix; + newRotation.set(_matrix).multiplyLocal(transformBy.getMatrix()); + + final Vector3 newTranslation = result._translation.set(transformBy.getTranslation()); + _matrix.applyPost(newTranslation, newTranslation); + // uniform scale, so just use X. + newTranslation.multiplyLocal(_scale.getX()); + newTranslation.addLocal(_translation); + + if (transformBy.isUniformScale()) { + result.setScale(_scale.getX() * transformBy.getScale().getX()); + } else { + final Vector3 scale = result._scale.set(transformBy.getScale()); + scale.multiplyLocal(_scale.getX()); + } + + // update our flags in one place. + result.updateFlags(true); + + return result; + } + + // In all remaining cases, the matrix cannot be written as R*S*X+T. + final ReadOnlyMatrix3 matrixA = isRotationMatrix() ? _matrix.multiplyDiagonalPost(_scale, + Matrix3.fetchTempInstance()) : _matrix; + + final ReadOnlyMatrix3 matrixB = transformBy.isRotationMatrix() ? transformBy.getMatrix().multiplyDiagonalPost( + transformBy.getScale(), Matrix3.fetchTempInstance()) : transformBy.getMatrix(); + + final Matrix3 newMatrix = result._matrix; + newMatrix.set(matrixA).multiplyLocal(matrixB); + + final Vector3 newTranslate = result._translation; + matrixA.applyPost(transformBy.getTranslation(), newTranslate).addLocal(getTranslation()); + + if (isRotationMatrix()) { + Matrix3.releaseTempInstance((Matrix3) matrixA); + } + if (transformBy.isRotationMatrix()) { + Matrix3.releaseTempInstance((Matrix3) matrixB); + } + + // prevent scale bleeding since we don't set it. + result._scale.set(1.0, 1.0, 1.0); + + // update our flags in one place. + result.updateFlags(false); + + return result; + } + + /** + * Updates _rotationMatrix, _uniformScale and _identity based on the current contents of this Transform. + * + * @param rotationMatrixGuaranteed + * true if we know for sure that the _matrix component is rotational. + */ + protected void updateFlags(final boolean rotationMatrixGuaranteed) { + _identity = _translation.equals(Vector3.ZERO) && _matrix.isIdentity() && _scale.equals(Vector3.ONE); + if (_identity) { + _rotationMatrix = true; + _uniformScale = true; + } else { + _rotationMatrix = rotationMatrixGuaranteed ? true : _matrix.isOrthonormal(); + _uniformScale = _rotationMatrix && _scale.getX() == _scale.getY() && _scale.getY() == _scale.getZ(); + } + } + + /** + * Calculates the inverse of this transform. + * + * @param store + * the transform to store the result in for return. If null, a new transform object is created and + * returned. It IS safe for store to be the same object as "this". + * @return the inverted transform + */ + @Override + public Transform invert(final Transform store) { + Transform result = store; + if (result == null) { + result = new Transform(); + } + + if (_identity) { + result.setIdentity(); + return result; + } + + final Matrix3 newMatrix = result._matrix.set(_matrix); + if (_rotationMatrix) { + if (_uniformScale) { + final double sx = _scale.getX(); + newMatrix.transposeLocal(); + if (sx != 1.0) { + newMatrix.multiplyLocal(1.0 / sx); + } + } else { + newMatrix.multiplyDiagonalPost(_scale, newMatrix).invertLocal(); + } + } else { + newMatrix.invertLocal(); + } + + result._matrix.applyPost(_translation, result._translation).negateLocal(); + result.updateFlags(_rotationMatrix); + + return result; + } + + /** + * @param store + * the matrix to store the result in for return. If null, a new matrix object is created and returned. + * @return this transform represented as a 4x4 matrix: + * + * <pre> + * R R R Tx + * R R R Ty + * R R R Tz + * 0 0 0 1 + * </pre> + */ + @Override + public Matrix4 getHomogeneousMatrix(final Matrix4 store) { + Matrix4 result = store; + if (result == null) { + result = new Matrix4(); + } + + if (_rotationMatrix) { + result._m00 = _scale.getX() * _matrix._m00; + result._m01 = _scale.getX() * _matrix._m01; + result._m02 = _scale.getX() * _matrix._m02; + result._m10 = _scale.getY() * _matrix._m10; + result._m11 = _scale.getY() * _matrix._m11; + result._m12 = _scale.getY() * _matrix._m12; + result._m20 = _scale.getZ() * _matrix._m20; + result._m21 = _scale.getZ() * _matrix._m21; + result._m22 = _scale.getZ() * _matrix._m22; + } else { + result._m00 = _matrix._m00; + result._m01 = _matrix._m01; + result._m02 = _matrix._m02; + result._m10 = _matrix._m10; + result._m11 = _matrix._m11; + result._m12 = _matrix._m12; + result._m20 = _matrix._m20; + result._m21 = _matrix._m21; + result._m22 = _matrix._m22; + } + + result._m30 = 0.0; + result._m31 = 0.0; + result._m32 = 0.0; + + result._m03 = _translation.getX(); + result._m13 = _translation.getY(); + result._m23 = _translation.getZ(); + result._m33 = 1.0; + + return result; + } + + @Override + public void getGLApplyMatrix(final DoubleBuffer store) { + if (_rotationMatrix) { + store.put(0, _scale.getX() * _matrix._m00); + store.put(1, _scale.getX() * _matrix._m10); + store.put(2, _scale.getX() * _matrix._m20); + store.put(4, _scale.getY() * _matrix._m01); + store.put(5, _scale.getY() * _matrix._m11); + store.put(6, _scale.getY() * _matrix._m21); + store.put(8, _scale.getZ() * _matrix._m02); + store.put(9, _scale.getZ() * _matrix._m12); + store.put(10, _scale.getZ() * _matrix._m22); + } else { + store.put(0, _matrix._m00); + store.put(1, _matrix._m10); + store.put(2, _matrix._m20); + store.put(4, _matrix._m01); + store.put(5, _matrix._m11); + store.put(6, _matrix._m21); + store.put(8, _matrix._m02); + store.put(9, _matrix._m12); + store.put(10, _matrix._m22); + } + + store.put(12, _translation.getX()); + store.put(13, _translation.getY()); + store.put(14, _translation.getZ()); + store.put(15, 1.0); + } + + @Override + public void getGLApplyMatrix(final FloatBuffer store) { + if (_rotationMatrix) { + store.put(0, (float) (_scale.getX() * _matrix._m00)); + store.put(1, (float) (_scale.getX() * _matrix._m10)); + store.put(2, (float) (_scale.getX() * _matrix._m20)); + store.put(4, (float) (_scale.getY() * _matrix._m01)); + store.put(5, (float) (_scale.getY() * _matrix._m11)); + store.put(6, (float) (_scale.getY() * _matrix._m21)); + store.put(8, (float) (_scale.getZ() * _matrix._m02)); + store.put(9, (float) (_scale.getZ() * _matrix._m12)); + store.put(10, (float) (_scale.getZ() * _matrix._m22)); + } else { + store.put(0, (float) _matrix._m00); + store.put(1, (float) _matrix._m10); + store.put(2, (float) _matrix._m20); + store.put(4, (float) _matrix._m01); + store.put(5, (float) _matrix._m11); + store.put(6, (float) _matrix._m21); + store.put(8, (float) _matrix._m02); + store.put(9, (float) _matrix._m12); + store.put(10, (float) _matrix._m22); + } + + store.put(12, _translation.getXf()); + store.put(13, _translation.getYf()); + store.put(14, _translation.getZf()); + store.put(15, 1.0f); + } + + /** + * Reads in a 4x4 matrix as a 3x3 matrix and translation. + * + * @param matrix + * @return this matrix for chaining. + * @throws NullPointerException + * if matrix is null. + */ + public Transform fromHomogeneousMatrix(final ReadOnlyMatrix4 matrix) { + _matrix.set(matrix.getM00(), matrix.getM01(), matrix.getM02(), matrix.getM10(), matrix.getM11(), + matrix.getM12(), matrix.getM20(), matrix.getM21(), matrix.getM22()); + _translation.set(matrix.getM03(), matrix.getM13(), matrix.getM23()); + + updateFlags(false); + return this; + } + + /** + * 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 ReadOnlyTransform transform) { + if (transform == null) { + return false; + } + if (!Vector3.isValid(transform.getScale()) || !Vector3.isValid(transform.getTranslation()) + || !Matrix3.isValid(transform.getMatrix())) { + return false; + } + + return true; + } + + /** + * @return the string representation of this triangle. + */ + @Override + public String toString() { + return "com.ardor3d.math.Transform [\n M: " + _matrix + "\n S: " + _scale + "\n T: " + _translation + "\n]"; + } + + /** + * @return returns a unique code for this transform object based on its values. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _matrix.hashCode(); + result += 31 * result + _scale.hashCode(); + result += 31 * result + _translation.hashCode(); + + return result; + } + + /** + * @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 ReadOnlyTransform)) { + return false; + } + final ReadOnlyTransform comp = (ReadOnlyTransform) o; + return _matrix.equals(comp.getMatrix()) + && Math.abs(_translation.getX() - comp.getTranslation().getX()) < Transform.ALLOWED_DEVIANCE + && Math.abs(_translation.getY() - comp.getTranslation().getY()) < Transform.ALLOWED_DEVIANCE + && Math.abs(_translation.getZ() - comp.getTranslation().getZ()) < Transform.ALLOWED_DEVIANCE + && Math.abs(_scale.getX() - comp.getScale().getX()) < Transform.ALLOWED_DEVIANCE + && Math.abs(_scale.getY() - comp.getScale().getY()) < Transform.ALLOWED_DEVIANCE + && Math.abs(_scale.getZ() - comp.getScale().getZ()) < Transform.ALLOWED_DEVIANCE; + } + + /** + * @param o + * the object to compare for equality + * @return true if this transform and the provided transform have the exact same double values. + */ + @Override + public boolean strictEquals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyTransform)) { + return false; + } + final ReadOnlyTransform comp = (ReadOnlyTransform) o; + return _matrix.strictEquals(comp.getMatrix()) && _scale.equals(comp.getScale()) + && _translation.equals(comp.getTranslation()); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Transform clone() { + return new Transform(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Transform> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_matrix, "rotation", new Matrix3(Matrix3.IDENTITY)); + capsule.write(_scale, "scale", new Vector3(Vector3.ONE)); + capsule.write(_translation, "translation", new Vector3(Vector3.ZERO)); + capsule.write(_identity, "identity", true); + capsule.write(_rotationMatrix, "rotationMatrix", true); + capsule.write(_uniformScale, "uniformScale", true); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _matrix.set((Matrix3) capsule.readSavable("rotation", new Matrix3(Matrix3.IDENTITY))); + _scale.set((Vector3) capsule.readSavable("scale", new Vector3(Vector3.ONE))); + _translation.set((Vector3) capsule.readSavable("translation", new Vector3(Vector3.ZERO))); + _identity = capsule.readBoolean("identity", true); + _rotationMatrix = capsule.readBoolean("rotationMatrix", true); + _uniformScale = capsule.readBoolean("uniformScale", true); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + _matrix.set((Matrix3) in.readObject()); + _scale.set((Vector3) in.readObject()); + _translation.set((Vector3) in.readObject()); + _identity = in.readBoolean(); + _rotationMatrix = in.readBoolean(); + _uniformScale = in.readBoolean(); + } + + /* + * Used with serialization. Not to be called manually. + * + * @param out ObjectOutput + * + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeObject(_matrix); + out.writeObject(_scale); + out.writeObject(_translation); + out.writeBoolean(_identity); + out.writeBoolean(_rotationMatrix); + out.writeBoolean(_uniformScale); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Transform that is intended for temporary use in calculations and so forth. Multiple calls + * to the method should return instances of this class that are not currently in use. + */ + public final static Transform fetchTempInstance() { + if (MathConstants.useMathPools) { + return Transform.TRANS_POOL.fetch(); + } else { + return new Transform(); + } + } + + /** + * Releases a Transform back to be used by a future call to fetchTempInstance. TAKE CARE: this Transform object + * should no longer have other classes referencing it or "Bad Things" will happen. + * + * @param trans + * the Transform to release. + */ + public final static void releaseTempInstance(final Transform trans) { + if (MathConstants.useMathPools) { + Transform.TRANS_POOL.release(trans); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/TransformException.java b/ardor3d-math/src/main/java/com/ardor3d/math/TransformException.java new file mode 100644 index 0000000..bfb43bc --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/TransformException.java @@ -0,0 +1,23 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +public class TransformException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public TransformException() {} + + public TransformException(final String message) { + super(message); + } + +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Triangle.java b/ardor3d-math/src/main/java/com/ardor3d/math/Triangle.java new file mode 100644 index 0000000..d1db728 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Triangle.java @@ -0,0 +1,417 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyTriangle; +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Triangle is a math class defining a three sided polygon by three points in space. + */ +public class Triangle implements Cloneable, Savable, Externalizable, ReadOnlyTriangle, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Triangle> TRI_POOL = ObjectPool.create(Triangle.class, + MathConstants.maxMathPoolSize); + + protected final Vector3 _pointA = new Vector3(); + protected final Vector3 _pointB = new Vector3(); + protected final Vector3 _pointC = new Vector3(); + + protected transient Vector3 _center; + protected transient Vector3 _normal; + + protected int _index = 0; + + private boolean _dirtyNormal = true; + + private boolean _dirtyCenter = true; + + /** + * Construct a new, mutable triangle with all points at 0,0,0 and an index of 0. + */ + public Triangle() {} + + /** + * Copy constructor. + * + * @param source + * the triangle to copy from. + */ + public Triangle(final ReadOnlyTriangle source) { + this(source.getA(), source.getB(), source.getC(), source.getIndex()); + } + + /** + * Construct a new, mutable triangle using the given points and an index of 0. + * + * @param pointA + * @param pointB + * @param pointC + */ + public Triangle(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, final ReadOnlyVector3 pointC) { + this(pointA, pointB, pointC, 0); + } + + /** + * Constructs a new triangle using the given points and index. + * + * @param pointA + * @param pointB + * @param pointC + * @param index + */ + public Triangle(final ReadOnlyVector3 pointA, final ReadOnlyVector3 pointB, final ReadOnlyVector3 pointC, + final int index) { + _pointA.set(pointA); + _pointB.set(pointB); + _pointC.set(pointC); + _index = index; + } + + /** + * Copies the values of the given source Triangle into this Triangle. + * + * @param source + * @return this Triangle for chaining + * @throws NullPointerException + * if source is null. + */ + public Triangle set(final ReadOnlyTriangle source) { + _pointA.set(source.getA()); + _pointB.set(source.getB()); + _pointC.set(source.getC()); + _index = source.getIndex(); + return this; + } + + @Override + public int getIndex() { + return _index; + } + + @Override + public ReadOnlyVector3 get(final int index) { + switch (index) { + case 0: + return getA(); + case 1: + return getB(); + case 2: + return getC(); + } + throw new IllegalArgumentException("invalid index: " + index); + } + + @Override + public ReadOnlyVector3 getA() { + return _pointA; + } + + @Override + public ReadOnlyVector3 getB() { + return _pointB; + } + + @Override + public ReadOnlyVector3 getC() { + return _pointC; + } + + /** + * Obtains the unit length normal vector of this triangle... Will create and recalculate this normal vector if this + * is the first request, or if one of the points on the triangle has changed since the last request. + * + * @return the normal vector + * @throws NullPointerException + * if store is null. + */ + @Override + public ReadOnlyVector3 getNormal() { + if (_dirtyNormal) { + calculateNormal(); + } + return _normal; + } + + /** + * Obtains the center point of this triangle... Will create and recalculate this point if this is the first request, + * or if one of the points on the triangle has changed since the last request. + */ + @Override + public ReadOnlyVector3 getCenter() { + if (_dirtyCenter) { + calculateCenter(); + } + return _center; + } + + /** + * Sets the index value of this triangle to the given int value. + * + * @param index + */ + public void setIndex(final int index) { + _index = index; + } + + /** + * Sets the first point of this triangle to the values of the given vector. + * + * @param pointA + */ + public void setA(final ReadOnlyVector3 pointA) { + _pointA.set(pointA); + _dirtyCenter = _dirtyNormal = true; + } + + /** + * Sets the second point of this triangle to the values of the given vector. + * + * @param pointB + */ + public void setB(final ReadOnlyVector3 pointB) { + _pointB.set(pointB); + _dirtyCenter = _dirtyNormal = true; + } + + /** + * Sets the third point of this triangle to the values of the given vector. + * + * @param pointC + */ + public void setC(final ReadOnlyVector3 pointC) { + _pointC.set(pointC); + _dirtyCenter = _dirtyNormal = true; + } + + /** + * Sets a point to a new value. + * + * @param index + * the index of the point to set (0-2, corresponding to A-C) + * @param point + * the new value + * @throws IllegalArgumentException + * if index is not in [0, 2] + */ + public void set(final int index, final ReadOnlyVector3 point) { + switch (index) { + case 0: + setA(point); + return; + case 1: + setB(point); + return; + case 2: + setC(point); + return; + } + throw new IllegalArgumentException("index must be 0, 1 or 2 (corresponding to A, B or C.)"); + } + + /** + * Recalculates the center point of this triangle by averaging the triangle's three points. + */ + protected void calculateCenter() { + if (_center == null) { + _center = _pointA.clone(); + } else { + _center.set(_pointA); + } + _center.addLocal(_pointB).addLocal(_pointC).multiplyLocal(MathUtils.ONE_THIRD); + _dirtyCenter = false; + } + + /** + * Recalculates the surface normal of the triangle by crossing the vectors formed by BA and CA. + */ + protected void calculateNormal() { + if (_normal == null) { + _normal = _pointB.clone(); + } else { + _normal.set(_pointB); + } + _normal.subtractLocal(_pointA).crossLocal(_pointC.getX() - _pointA.getX(), _pointC.getY() - _pointA.getY(), + _pointC.getZ() - _pointA.getZ()); + _normal.normalizeLocal(); + _dirtyNormal = false; + } + + /** + * Check a triangle... if it is null or its points are invalid, return false. Else return true. + * + * @param triangle + * the triangle to check + * @return true or false as stated above. + */ + public static boolean isValid(final Triangle triangle) { + if (triangle == null) { + return false; + } + if (!Vector3.isValid(triangle._pointA) || !Vector3.isValid(triangle._pointB) + || !Vector3.isValid(triangle._pointC)) { + return false; + } + + return true; + } + + /** + * @return the string representation of this triangle. + */ + @Override + public String toString() { + return "com.ardor3d.math.Triangle [A: " + _pointA + " - B: " + _pointB + " - C: " + _pointC + " - Index: " + + _index + "]"; + } + + /** + * @return returns a unique code for this triangle object based on its values. If two triangles have the same points + * and index, they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + _pointA.hashCode(); + result += 31 * result + _pointB.hashCode(); + result += 31 * result + _pointC.hashCode(); + result += 31 * result + _index; + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this triangle and the provided triangle have the same index and point values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyTriangle)) { + return false; + } + final ReadOnlyTriangle comp = (ReadOnlyTriangle) o; + return _index == comp.getIndex() && _pointA.equals(comp.getA()) && _pointB.equals(comp.getB()) + && _pointC.equals(comp.getC()); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Triangle clone() { + return new Triangle(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Triangle> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(_pointA, "a", new Vector3(Vector3.ZERO)); + capsule.write(_pointB, "b", new Vector3(Vector3.ZERO)); + capsule.write(_pointC, "c", new Vector3(Vector3.ZERO)); + capsule.write(_index, "index", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + _pointA.set((Vector3) capsule.readSavable("a", new Vector3(Vector3.ZERO))); + _pointB.set((Vector3) capsule.readSavable("b", new Vector3(Vector3.ZERO))); + _pointC.set((Vector3) capsule.readSavable("c", new Vector3(Vector3.ZERO))); + _index = capsule.readInt("index", 0); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setA((Vector3) in.readObject()); + setB((Vector3) in.readObject()); + setC((Vector3) in.readObject()); + setIndex(in.readInt()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeObject(_pointA); + out.writeObject(_pointB); + out.writeObject(_pointC); + out.writeInt(getIndex()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Triangle that is intended for temporary use in calculations and so forth. Multiple calls + * to the method should return instances of this class that are not currently in use. + */ + public final static Triangle fetchTempInstance() { + if (MathConstants.useMathPools) { + return Triangle.TRI_POOL.fetch(); + } else { + return new Triangle(); + } + } + + /** + * Releases a Triangle back to be used by a future call to fetchTempInstance. TAKE CARE: this Triangle object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param tri + * the Triangle to release. + */ + public final static void releaseTempInstance(final Triangle tri) { + if (MathConstants.useMathPools) { + Triangle.TRI_POOL.release(tri); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/ValidatingTransform.java b/ardor3d-math/src/main/java/com/ardor3d/math/ValidatingTransform.java new file mode 100644 index 0000000..09b43d4 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/ValidatingTransform.java @@ -0,0 +1,147 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import com.ardor3d.math.type.ReadOnlyMatrix3; +import com.ardor3d.math.type.ReadOnlyMatrix4; +import com.ardor3d.math.type.ReadOnlyQuaternion; +import com.ardor3d.math.type.ReadOnlyTransform; +import com.ardor3d.math.type.ReadOnlyVector3; + +/** + * A Transform that checks if any of it's member values are null, NaN or Infinity, and throws an + * InvalidTransformException if so. + * + */ +public class ValidatingTransform extends Transform { + public ValidatingTransform() {} + + /** + * Copy constructor + * + * @param source + */ + public ValidatingTransform(final ReadOnlyTransform source) { + super(source); + validate(); + } + + private void validate() { + if (!Transform.isValid(this)) { + throw new InvalidTransformException("Transform is invalid: " + this); + } + } + + @Override + public Transform fromHomogeneousMatrix(final ReadOnlyMatrix4 matrix) { + super.fromHomogeneousMatrix(matrix); + validate(); + return this; + } + + @Override + public ValidatingTransform setRotation(final ReadOnlyMatrix3 rotation) { + super.setRotation(rotation); + validate(); + return this; + } + + @Override + public ValidatingTransform setRotation(final ReadOnlyQuaternion rotation) { + super.setRotation(rotation); + validate(); + return this; + } + + @Override + public ValidatingTransform setScale(final double x, final double y, final double z) { + super.setScale(x, y, z); + validate(); + return this; + } + + @Override + public ValidatingTransform setScale(final double uniformScale) { + super.setScale(uniformScale); + validate(); + return this; + } + + @Override + public ValidatingTransform setScale(final ReadOnlyVector3 scale) { + super.setScale(scale); + validate(); + return this; + } + + @Override + public ValidatingTransform setTranslation(final double x, final double y, final double z) { + super.setTranslation(x, y, z); + validate(); + return this; + } + + @Override + public ValidatingTransform setTranslation(final ReadOnlyVector3 translation) { + super.setTranslation(translation); + validate(); + return this; + } + + @Override + public Transform translate(final double x, final double y, final double z) { + super.translate(x, y, z); + validate(); + return this; + } + + @Override + public Transform translate(final ReadOnlyVector3 vec) { + super.translate(vec); + validate(); + return this; + } + + @Override + public Transform multiply(final ReadOnlyTransform transformBy, final Transform store) { + final Transform transform = super.multiply(transformBy, store); + if (!Transform.isValid(transform)) { + throw new InvalidTransformException("Transform is invalid"); + } + return transform; + } + + @Override + public Transform invert(final Transform store) { + final Transform transform = super.invert(store); + if (!Transform.isValid(transform)) { + throw new InvalidTransformException("Transform is invalid"); + } + return transform; + } + + @Override + public Transform set(final ReadOnlyTransform source) { + super.set(source); + validate(); + return this; + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public ValidatingTransform clone() { + return new ValidatingTransform(this); + } + +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Vector2.java b/ardor3d-math/src/main/java/com/ardor3d/math/Vector2.java new file mode 100644 index 0000000..c6f1d46 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Vector2.java @@ -0,0 +1,1024 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyVector2; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Vector2 represents a point or vector in a two dimensional system. This implementation stores its data in + * double-precision. + */ +public class Vector2 implements Cloneable, Savable, Externalizable, ReadOnlyVector2, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Vector2> VEC_POOL = ObjectPool.create(Vector2.class, MathConstants.maxMathPoolSize); + + /** + * 0, 0 + */ + public final static ReadOnlyVector2 ZERO = new Vector2(0, 0); + + /** + * 1, 1 + */ + public final static ReadOnlyVector2 ONE = new Vector2(1, 1); + + /** + * -1, -1 + */ + public final static ReadOnlyVector2 NEG_ONE = new Vector2(-1, -1); + + /** + * 1, 0 + */ + public final static ReadOnlyVector2 UNIT_X = new Vector2(1, 0); + + /** + * -1, 0 + */ + public final static ReadOnlyVector2 NEG_UNIT_X = new Vector2(-1, 0); + + /** + * 0, 1 + */ + public final static ReadOnlyVector2 UNIT_Y = new Vector2(0, 1); + + /** + * 0, -1 + */ + public final static ReadOnlyVector2 NEG_UNIT_Y = new Vector2(0, -1); + + protected double _x = 0; + protected double _y = 0; + + /** + * Constructs a new vector set to (0, 0). + */ + public Vector2() { + this(0, 0); + } + + /** + * Constructs a new vector set to the (x, y) values of the given source vector. + * + * @param src + */ + public Vector2(final ReadOnlyVector2 src) { + this(src.getX(), src.getY()); + } + + /** + * Constructs a new vector set to (x, y). + * + * @param x + * @param y + */ + public Vector2(final double x, final double y) { + _x = x; + _y = y; + } + + @Override + public double getX() { + return _x; + } + + @Override + public double getY() { + return _y; + } + + /** + * @return x as a float, to decrease need for explicit casts. + */ + @Override + public float getXf() { + return (float) _x; + } + + /** + * @return y as a float, to decrease need for explicit casts. + */ + @Override + public float getYf() { + return (float) _y; + } + + /** + * @param index + * @return x value if index == 0 or y value if index == 1 + * @throws IllegalArgumentException + * if index is not one of 0, 1. + */ + @Override + public double getValue(final int index) { + switch (index) { + case 0: + return getX(); + case 1: + return getY(); + } + throw new IllegalArgumentException("index must be either 0 or 1"); + } + + /** + * @param index + * which field index in this vector to set. + * @param value + * to set to one of x or y. + * @throws IllegalArgumentException + * if index is not one of 0, 1. + */ + public void setValue(final int index, final double value) { + switch (index) { + case 0: + setX(value); + return; + case 1: + setY(value); + return; + } + throw new IllegalArgumentException("index must be either 0 or 1"); + } + + /** + * Stores the double values of this vector in the given double array. + * + * @param store + * if null, a new double[2] array is created. + * @return the double array + * @throws ArrayIndexOutOfBoundsException + * if store is not at least length 2. + */ + @Override + public double[] toArray(double[] store) { + if (store == null) { + store = new double[2]; + } + // do last first to ensure size is correct before any edits occur. + store[1] = getY(); + store[0] = getX(); + return store; + } + + /** + * Sets the first component of this vector to the given double value. + * + * @param x + */ + public void setX(final double x) { + _x = x; + } + + /** + * Sets the second component of this vector to the given double value. + * + * @param y + */ + public void setY(final double y) { + _y = y; + } + + /** + * Sets the value of this vector to (x, y) + * + * @param x + * @param y + * @return this vector for chaining + */ + public Vector2 set(final double x, final double y) { + setX(x); + setY(y); + return this; + } + + /** + * Sets the value of this vector to the (x, y) values of the provided source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector2 set(final ReadOnlyVector2 source) { + setX(source.getX()); + setY(source.getY()); + return this; + } + + /** + * Sets the value of this vector to (0, 0) + * + * @return this vector for chaining + */ + public Vector2 zero() { + return set(0, 0); + } + + /** + * Adds the given values to those of this vector and returns them in store * @param store the vector to store the + * result in for return. If null, a new vector object is created and returned. . + * + * @param x + * @param y + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + x, this.y + y) + */ + @Override + public Vector2 add(final double x, final double y, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() + x, getY() + y); + } + + /** + * Increments the values of this vector with the given x and y values. + * + * @param x + * @param y + * @return this vector for chaining + */ + public Vector2 addLocal(final double x, final double y) { + return set(getX() + x, getY() + y); + } + + /** + * Adds the values of the given source vector to those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + source.x, this.y + source.y) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector2 add(final ReadOnlyVector2 source, final Vector2 store) { + return add(source.getX(), source.getY(), store); + } + + /** + * Increments the values of this vector with the x and y values of the given vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector2 addLocal(final ReadOnlyVector2 source) { + return addLocal(source.getX(), source.getY()); + } + + /** + * Subtracts the given values from those of this vector and returns them in store. + * + * @param x + * @param y + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - x, this.y - y) + */ + @Override + public Vector2 subtract(final double x, final double y, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() - x, getY() - y); + } + + /** + * Decrements the values of this vector by the given x and y values. + * + * @param x + * @param y + * @return this vector for chaining + */ + public Vector2 subtractLocal(final double x, final double y) { + return set(getX() - x, getY() - y); + } + + /** + * Subtracts the values of the given source vector from those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - source.x, this.y - source.y) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector2 subtract(final ReadOnlyVector2 source, final Vector2 store) { + return subtract(source.getX(), source.getY(), store); + } + + /** + * Decrements the values of this vector by the x and y values from the given source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector2 subtractLocal(final ReadOnlyVector2 source) { + return subtractLocal(source.getX(), source.getY()); + } + + /** + * Multiplies the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scalar, this.y * scalar) + */ + @Override + public Vector2 multiply(final double scalar, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() * scalar, getY() * scalar); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + */ + public Vector2 multiplyLocal(final double scalar) { + return set(getX() * scalar, getY() * scalar); + } + + /** + * Multiplies the values of this vector by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y) + */ + @Override + public Vector2 multiply(final ReadOnlyVector2 scale, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() * scale.getX(), getY() * scale.getY()); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the values of the given scale. + * + * @param scale + * @return this vector for chaining + */ + public Vector2 multiplyLocal(final ReadOnlyVector2 scale) { + return set(getX() * scale.getX(), getY() * scale.getY()); + } + + /** + * Multiplies the values of this vector by the given scale values and returns the result in store. + * + * @param x + * @param y + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y) + */ + @Override + public Vector2 multiply(final double x, final double y, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() * x, getY() * y); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the values of the given scale. + * + * @param x + * @param y + * @return this vector for chaining + */ + public Vector2 multiplyLocal(final double x, final double y) { + return set(getX() * x, getY() * y); + } + + /** + * Divides the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scalar, this.y / scalar) + */ + @Override + public Vector2 divide(final double scalar, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() / scalar, getY() / scalar); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + * @throws ArithmeticException + * if scalar is 0 + */ + public Vector2 divideLocal(final double scalar) { + final double invScalar = 1.0 / scalar; + + return set(getX() * invScalar, getY() * invScalar); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y) + */ + @Override + public Vector2 divide(final ReadOnlyVector2 scale, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() / scale.getX(), getY() / scale.getY()); + } + + /** + * Internally modifies the values of this vector by dividing them each by the values of the given scale. + * + * @param scale + * @return this vector for chaining + */ + public Vector2 divideLocal(final ReadOnlyVector2 scale) { + return set(getX() / scale.getX(), getY() / scale.getY()); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param x + * @param y + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y) + */ + @Override + public Vector2 divide(final double x, final double y, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + return result.set(getX() / x, getY() / y); + } + + /** + * Internally modifies the values of this vector by dividing them each by the values of the given scale. + * + * @param x + * @param y + * @return this vector for chaining + */ + public Vector2 divideLocal(final double x, final double y) { + return set(getX() / x, getY() / y); + } + + /** + * + * Internally modifies this vector by multiplying its values with a given scale value, then adding a given "add" + * value. + * + * @param scale + * the value to multiply this vector by. + * @param add + * the value to add to the result + * @return this vector for chaining + */ + public Vector2 scaleAddLocal(final double scale, final ReadOnlyVector2 add) { + _x = _x * scale + add.getX(); + _y = _y * scale + add.getY(); + return this; + } + + /** + * Scales this vector by multiplying its values with a given scale value, then adding a given "add" value. The + * result is store in the given store parameter. + * + * @param scale + * the value to multiply by. + * @param add + * the value to add + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the store variable + */ + @Override + public Vector2 scaleAdd(final double scale, final ReadOnlyVector2 add, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + result.setX(_x * scale + add.getX()); + result.setY(_y * scale + add.getY()); + return result; + } + + /** + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return same as multiply(-1, store) + */ + @Override + public Vector2 negate(final Vector2 store) { + return multiply(-1, store); + } + + /** + * @return same as multiplyLocal(-1) + */ + public Vector2 negateLocal() { + return multiplyLocal(-1); + } + + /** + * Creates a new unit length vector from this one by dividing by length. If the length is 0, (ie, if the vector is + * 0, 0) then a new vector (0, 0) is returned. + * + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new unit vector (or 0, 0 if this unit is 0 length) + */ + @Override + public Vector2 normalize(final Vector2 store) { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiply(MathUtils.inverseSqrt(lengthSq), store); + } + + return store != null ? store.set(Vector2.ZERO) : new Vector2(Vector2.ZERO); + } + + /** + * Converts this vector into a unit vector by dividing it internally by its length. If the length is 0, (ie, if the + * vector is 0, 0) then no action is taken. + * + * @return this vector for chaining + */ + public Vector2 normalizeLocal() { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiplyLocal(MathUtils.inverseSqrt(lengthSq)); + } + + return this; + } + + /** + * Creates a new vector representing this vector rotated around 0,0 by a specified angle in a given direction. + * + * @param angle + * in radians + * @param clockwise + * true to rotate in a clockwise direction + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the new rotated vector + */ + @Override + public Vector2 rotateAroundOrigin(double angle, final boolean clockwise, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + if (clockwise) { + angle = -angle; + } + final double newX = MathUtils.cos(angle) * getX() - MathUtils.sin(angle) * getY(); + final double newY = MathUtils.sin(angle) * getX() + MathUtils.cos(angle) * getY(); + return result.set(newX, newY); + } + + /** + * Internally rotates this vector around 0,0 by a specified angle in a given direction. + * + * @param angle + * in radians + * @param clockwise + * true to rotate in a clockwise direction + * @return this vector for chaining + */ + public Vector2 rotateAroundOriginLocal(double angle, final boolean clockwise) { + if (clockwise) { + angle = -angle; + } + final double newX = MathUtils.cos(angle) * getX() - MathUtils.sin(angle) * getY(); + final double newY = MathUtils.sin(angle) * getX() + MathUtils.cos(angle) * getY(); + return set(newX, newY); + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is returned as a new vector object. + * + * @param endVec + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector as described above. + * @throws NullPointerException + * if endVec is null. + */ + @Override + public Vector2 lerp(final ReadOnlyVector2 endVec, final double scalar, final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + final double x = (1.0 - scalar) * getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * getY() + scalar * endVec.getY(); + return result.set(x, y); + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is stored back in this vector. + * + * @param endVec + * @param scalar + * @return this vector for chaining + * @throws NullPointerException + * if endVec is null. + */ + public Vector2 lerpLocal(final ReadOnlyVector2 endVec, final double scalar) { + setX((1.0 - scalar) * getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * getY() + scalar * endVec.getY()); + return this; + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is returned as a new vector object. + * + * @param beginVec + * @param endVec + * @param scalar + * the scalar as a percent. + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector as described above. + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public static Vector2 lerp(final ReadOnlyVector2 beginVec, final ReadOnlyVector2 endVec, final double scalar, + final Vector2 store) { + Vector2 result = store; + if (result == null) { + result = new Vector2(); + } + + final double x = (1.0 - scalar) * beginVec.getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * beginVec.getY() + scalar * endVec.getY(); + return result.set(x, y); + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is stored back in this vector. + * + * @param beginVec + * @param endVec + * @param changeAmnt + * the scalar as a percent. + * @return this vector for chaining + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public Vector2 lerpLocal(final ReadOnlyVector2 beginVec, final ReadOnlyVector2 endVec, final double scalar) { + setX((1.0 - scalar) * beginVec.getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * beginVec.getY() + scalar * endVec.getY()); + return this; + } + + /** + * @return the magnitude of this vector, or the distance between the origin (0, 0) and the point described by (x, + * y). Basically sqrt(x^2 + y^2) + */ + @Override + public double length() { + return MathUtils.sqrt(lengthSquared()); + } + + /** + * @return the squared magnitude of this vector. (x^2 + y^2) + */ + @Override + public double lengthSquared() { + return getX() * getX() + getY() * getY(); + } + + /** + * @param x + * @param y + * @return the squared distance between the point described by this vector and the given x, y point. When comparing + * the relative distance between two points it is usually sufficient to compare the squared distances, thus + * avoiding an expensive square root operation. + */ + @Override + public double distanceSquared(final double x, final double y) { + final double dx = getX() - x; + final double dy = getY() - y; + return dx * dx + dy * dy; + } + + /** + * @param destination + * @return the squared distance between the point described by this vector and the given destination point. When + * comparing the relative distance between two points it is usually sufficient to compare the squared + * distances, thus avoiding an expensive square root operation. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distanceSquared(final ReadOnlyVector2 destination) { + return distanceSquared(destination.getX(), destination.getY()); + } + + /** + * @param x + * @param y + * @return the distance between the point described by this vector and the given x, y point. + */ + @Override + public double distance(final double x, final double y) { + return MathUtils.sqrt(distanceSquared(x, y)); + } + + /** + * @param destination + * @return the distance between the point described by this vector and the given destination point. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distance(final ReadOnlyVector2 destination) { + return MathUtils.sqrt(distanceSquared(destination)); + } + + /** + * @param x + * @param y + * @return the dot product of this vector with the given x, y values. + */ + @Override + public double dot(final double x, final double y) { + return getX() * x + getY() * y; + } + + /** + * @param vec + * @return the dot product of this vector with the x, y values of the given vector. + * @throws NullPointerException + * if vec is null. + */ + @Override + public double dot(final ReadOnlyVector2 vec) { + return dot(vec.getX(), vec.getY()); + } + + /** + * @return the angle - in radians [-pi, pi) - represented by this Vector2 as expressed by a conversion from + * rectangular coordinates (<code>x</code>, <code>y</code>) to polar coordinates + * (r, <i>theta</i>). + */ + @Override + public double getPolarAngle() { + return -Math.atan2(getY(), getX()); + } + + /** + * @param otherVector + * the "destination" unit vector + * @return the angle (in radians) required to rotate a ray represented by this vector to lie co-linear to a ray + * described by the given vector. It is assumed that both this vector and the given vector are unit vectors + * (normalized). + * @throws NullPointerException + * if otherVector is null. + */ + @Override + public double angleBetween(final ReadOnlyVector2 otherVector) { + return Math.atan2(otherVector.getY(), otherVector.getX()) - Math.atan2(getY(), getX()); + } + + /** + * @param otherVector + * a unit vector to find the angle against + * @return the minimum angle (in radians) between two vectors. It is assumed that both this vector and the given + * vector are unit vectors (normalized). + * @throws NullPointerException + * if otherVector is null. + */ + @Override + public double smallestAngleBetween(final ReadOnlyVector2 otherVector) { + final double dotProduct = dot(otherVector); + return MathUtils.acos(dotProduct); + } + + /** + * Check a vector... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param vector + * the vector to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyVector2 vector) { + if (vector == null) { + return false; + } + if (Double.isNaN(vector.getX()) || Double.isNaN(vector.getY())) { + return false; + } + if (Double.isInfinite(vector.getX()) || Double.isInfinite(vector.getY())) { + return false; + } + return true; + } + + /** + * @return the string representation of this vector. + */ + @Override + public String toString() { + return "com.ardor3d.math.Vector2 [X=" + getX() + ", Y=" + getY() + "]"; + } + + /** + * @return returns a unique code for this vector object based on its values. If two vectors are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + final long x = Double.doubleToLongBits(getX()); + result += 31 * result + (int) (x ^ x >>> 32); + + final long y = Double.doubleToLongBits(getY()); + result += 31 * result + (int) (y ^ y >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this vector and the provided vector have the same x and y values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyVector2)) { + return false; + } + final ReadOnlyVector2 comp = (ReadOnlyVector2) o; + return getX() == comp.getX() && getY() == comp.getY(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Vector2 clone() { + return new Vector2(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Vector2> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(getX(), "x", 0); + capsule.write(getY(), "y", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + setX(capsule.readDouble("x", 0)); + setY(capsule.readDouble("y", 0)); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setX(in.readDouble()); + setY(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(getX()); + out.writeDouble(getY()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Vector2 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Vector2 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Vector2.VEC_POOL.fetch(); + } else { + return new Vector2(); + } + } + + /** + * Releases a Vector2 back to be used by a future call to fetchTempInstance. TAKE CARE: this Vector2 object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param vec + * the Vector2 to release. + */ + public final static void releaseTempInstance(final Vector2 vec) { + if (MathConstants.useMathPools) { + Vector2.VEC_POOL.release(vec); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Vector3.java b/ardor3d-math/src/main/java/com/ardor3d/math/Vector3.java new file mode 100644 index 0000000..f8754b2 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Vector3.java @@ -0,0 +1,1135 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyVector3; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Vector3 represents a point or vector in a three dimensional system. This implementation stores its data in + * double-precision. + */ +public class Vector3 implements Cloneable, Savable, Externalizable, ReadOnlyVector3, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Vector3> VEC_POOL = ObjectPool.create(Vector3.class, MathConstants.maxMathPoolSize); + + /** + * 0, 0, 0 + */ + public final static ReadOnlyVector3 ZERO = new Vector3(0, 0, 0); + + /** + * 1, 1, 1 + */ + public final static ReadOnlyVector3 ONE = new Vector3(1, 1, 1); + + /** + * -1, -1, -1 + */ + public final static ReadOnlyVector3 NEG_ONE = new Vector3(-1, -1, -1); + + /** + * 1, 0, 0 + */ + public final static ReadOnlyVector3 UNIT_X = new Vector3(1, 0, 0); + + /** + * -1, 0, 0 + */ + public final static ReadOnlyVector3 NEG_UNIT_X = new Vector3(-1, 0, 0); + + /** + * 0, 1, 0 + */ + public final static ReadOnlyVector3 UNIT_Y = new Vector3(0, 1, 0); + + /** + * 0, -1, 0 + */ + public final static ReadOnlyVector3 NEG_UNIT_Y = new Vector3(0, -1, 0); + + /** + * 0, 0, 1 + */ + public final static ReadOnlyVector3 UNIT_Z = new Vector3(0, 0, 1); + + /** + * 0, 0, -1 + */ + public final static ReadOnlyVector3 NEG_UNIT_Z = new Vector3(0, 0, -1); + + protected double _x = 0; + protected double _y = 0; + protected double _z = 0; + + /** + * Constructs a new vector set to (0, 0, 0). + */ + public Vector3() { + this(0, 0, 0); + } + + /** + * Constructs a new vector set to the (x, y, z) values of the given source vector. + * + * @param src + */ + public Vector3(final ReadOnlyVector3 src) { + this(src.getX(), src.getY(), src.getZ()); + } + + /** + * Constructs a new vector set to (x, y, z). + * + * @param x + * @param y + * @param z + */ + public Vector3(final double x, final double y, final double z) { + _x = x; + _y = y; + _z = z; + } + + @Override + public double getX() { + return _x; + } + + @Override + public double getY() { + return _y; + } + + @Override + public double getZ() { + return _z; + } + + /** + * @return x as a float, to decrease need for explicit casts. + */ + @Override + public float getXf() { + return (float) _x; + } + + /** + * @return y as a float, to decrease need for explicit casts. + */ + @Override + public float getYf() { + return (float) _y; + } + + /** + * @return z as a float, to decrease need for explicit casts. + */ + @Override + public float getZf() { + return (float) _z; + } + + /** + * @param index + * @return x value if index == 0, y value if index == 1 or z value if index == 2 + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2. + */ + @Override + public double getValue(final int index) { + switch (index) { + case 0: + return getX(); + case 1: + return getY(); + case 2: + return getZ(); + } + throw new IllegalArgumentException("index must be either 0, 1 or 2"); + } + + /** + * @param index + * which field index in this vector to set. + * @param value + * to set to one of x, y or z. + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2. + */ + public void setValue(final int index, final double value) { + switch (index) { + case 0: + setX(value); + return; + case 1: + setY(value); + return; + case 2: + setZ(value); + return; + } + throw new IllegalArgumentException("index must be either 0, 1 or 2"); + } + + /** + * Stores the double values of this vector in the given double array. + * + * @param store + * if null, a new double[3] array is created. + * @return the double array + * @throws ArrayIndexOutOfBoundsException + * if store is not at least length 3. + */ + @Override + public double[] toArray(double[] store) { + if (store == null) { + store = new double[3]; + } + + // do last first to ensure size is correct before any edits occur. + store[2] = getZ(); + store[1] = getY(); + store[0] = getX(); + return store; + } + + /** + * Stores the double values of this vector in the given float array. + * + * @param store + * if null, a new float[3] array is created. + * @return the float array + * @throws NullPointerException + * if store is null. + * @throws ArrayIndexOutOfBoundsException + * if store is not at least length 3. + */ + public float[] toFloatArray(float[] store) { + if (store == null) { + store = new float[3]; + } + + // do last first to ensure size is correct before any edits occur. + store[2] = (float) getZ(); + store[1] = (float) getY(); + store[0] = (float) getX(); + return store; + } + + /** + * Sets the first component of this vector to the given double value. + * + * @param x + */ + public void setX(final double x) { + _x = x; + } + + /** + * Sets the second component of this vector to the given double value. + * + * @param y + */ + public void setY(final double y) { + _y = y; + } + + /** + * Sets the third component of this vector to the given double value. + * + * @param z + */ + public void setZ(final double z) { + _z = z; + } + + /** + * Sets the value of this vector to (x, y, z) + * + * @param x + * @param y + * @param z + * @return this vector for chaining + */ + public Vector3 set(final double x, final double y, final double z) { + setX(x); + setY(y); + setZ(z); + return this; + } + + /** + * Sets the value of this vector to the (x, y, z) values of the provided source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector3 set(final ReadOnlyVector3 source) { + setX(source.getX()); + setY(source.getY()); + setZ(source.getZ()); + return this; + } + + /** + * Sets the value of this vector to (0, 0, 0) + * + * @return this vector for chaining + */ + public Vector3 zero() { + return set(0, 0, 0); + } + + /** + * Adds the given values to those of this vector and returns them in store * @param store the vector to store the + * result in for return. If null, a new vector object is created and returned. . + * + * @param x + * @param y + * @param z + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + x, this.y + y, this.z + z) + */ + @Override + public Vector3 add(final double x, final double y, final double z, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() + x, getY() + y, getZ() + z); + } + + /** + * Increments the values of this vector with the given x, y and z values. + * + * @param x + * @param y + * @param z + * @return this vector for chaining + */ + public Vector3 addLocal(final double x, final double y, final double z) { + return set(getX() + x, getY() + y, getZ() + z); + } + + /** + * Adds the values of the given source vector to those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + source.x, this.y + source.y, this.z + source.z) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector3 add(final ReadOnlyVector3 source, final Vector3 store) { + return add(source.getX(), source.getY(), source.getZ(), store); + } + + /** + * Increments the values of this vector with the x, y and z values of the given vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector3 addLocal(final ReadOnlyVector3 source) { + return addLocal(source.getX(), source.getY(), source.getZ()); + } + + /** + * Subtracts the given values from those of this vector and returns them in store. + * + * @param x + * @param y + * @param z + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - x, this.y - y, this.z - z) + */ + @Override + public Vector3 subtract(final double x, final double y, final double z, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() - x, getY() - y, getZ() - z); + } + + /** + * Decrements the values of this vector by the given x, y and z values. + * + * @param x + * @param y + * @param z + * @return this vector for chaining + */ + public Vector3 subtractLocal(final double x, final double y, final double z) { + return set(getX() - x, getY() - y, getZ() - z); + } + + /** + * Subtracts the values of the given source vector from those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - source.x, this.y - source.y, this.z - source.z) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector3 subtract(final ReadOnlyVector3 source, final Vector3 store) { + return subtract(source.getX(), source.getY(), source.getZ(), store); + } + + /** + * Decrements the values of this vector by the x, y and z values from the given source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector3 subtractLocal(final ReadOnlyVector3 source) { + return subtractLocal(source.getX(), source.getY(), source.getZ()); + } + + /** + * Multiplies the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scalar, this.y * scalar, this.z * scalar) + */ + @Override + public Vector3 multiply(final double scalar, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() * scalar, getY() * scalar, getZ() * scalar); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + */ + public Vector3 multiplyLocal(final double scalar) { + return set(getX() * scalar, getY() * scalar, getZ() * scalar); + } + + /** + * Multiplies the values of this vector by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y, this.z * scale.z) + */ + @Override + public Vector3 multiply(final ReadOnlyVector3 scale, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() * scale.getX(), getY() * scale.getY(), getZ() * scale.getZ()); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scale values. + * + * @param scalar + * @return this vector for chaining + */ + public Vector3 multiplyLocal(final ReadOnlyVector3 scale) { + return set(getX() * scale.getX(), getY() * scale.getY(), getZ() * scale.getZ()); + } + + /** + * Multiplies the values of this vector by the given scale values and returns the result in store. + * + * @param x + * @param y + * @param z + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y, this.z * scale.z) + */ + @Override + public Vector3 multiply(final double x, final double y, final double z, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() * x, getY() * y, getZ() * z); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scale values. + * + * @param x + * @param y + * @param z + * @return this vector for chaining + */ + public Vector3 multiplyLocal(final double x, final double y, final double z) { + return set(getX() * x, getY() * y, getZ() * z); + } + + /** + * Divides the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scalar, this.y / scalar, this.z / scalar) + */ + @Override + public Vector3 divide(final double scalar, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() / scalar, getY() / scalar, getZ() / scalar); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + * @throws ArithmeticException + * if scalar is 0 + */ + public Vector3 divideLocal(final double scalar) { + final double invScalar = 1.0 / scalar; + + return set(getX() * invScalar, getY() * invScalar, getZ() * invScalar); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y, this.z / scale.z) + */ + @Override + public Vector3 divide(final ReadOnlyVector3 scale, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() / scale.getX(), getY() / scale.getY(), getZ() / scale.getZ()); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scale values. + * + * @param scale + * @return this vector for chaining + */ + public Vector3 divideLocal(final ReadOnlyVector3 scale) { + return set(getX() / scale.getX(), getY() / scale.getY(), getZ() / scale.getZ()); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param x + * @param y + * @param z + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y, this.z / scale.z) + */ + @Override + public Vector3 divide(final double x, final double y, final double z, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + return result.set(getX() / x, getY() / y, getZ() / z); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scale values. + * + * @param x + * @param y + * @param z + * @return this vector for chaining + */ + public Vector3 divideLocal(final double x, final double y, final double z) { + return set(getX() / x, getY() / y, getZ() / z); + } + + /** + * + * Internally modifies this vector by multiplying its values with a given scale value, then adding a given "add" + * value. + * + * @param scale + * the value to multiply this vector by. + * @param add + * the value to add to the result + * @return this vector for chaining + */ + public Vector3 scaleAddLocal(final double scale, final ReadOnlyVector3 add) { + _x = _x * scale + add.getX(); + _y = _y * scale + add.getY(); + _z = _z * scale + add.getZ(); + return this; + } + + /** + * Scales this vector by multiplying its values with a given scale value, then adding a given "add" value. The + * result is store in the given store parameter. + * + * @param scale + * the value to multiply by. + * @param add + * the value to add + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the store variable + */ + @Override + public Vector3 scaleAdd(final double scale, final ReadOnlyVector3 add, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + result.setX(_x * scale + add.getX()); + result.setY(_y * scale + add.getY()); + result.setZ(_z * scale + add.getZ()); + return result; + } + + /** + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return same as multiply(-1, store) + */ + @Override + public Vector3 negate(final Vector3 store) { + return multiply(-1, store); + } + + /** + * @return same as multiplyLocal(-1) + */ + public Vector3 negateLocal() { + return multiplyLocal(-1); + } + + /** + * Creates a new unit length vector from this one by dividing by length. If the length is 0, (ie, if the vector is + * 0, 0, 0) then a new vector (0, 0, 0) is returned. + * + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new unit vector (or 0, 0, 0 if this unit is 0 length) + */ + @Override + public Vector3 normalize(final Vector3 store) { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiply(MathUtils.inverseSqrt(lengthSq), store); + } + + return store != null ? store.set(Vector3.ZERO) : new Vector3(Vector3.ZERO); + } + + /** + * Converts this vector into a unit vector by dividing it internally by its length. If the length is 0, (ie, if the + * vector is 0, 0, 0) then no action is taken. + * + * @return this vector for chaining + */ + public Vector3 normalizeLocal() { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiplyLocal(MathUtils.inverseSqrt(lengthSq)); + } + + return this; + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is returned as a new vector object. + * + * @param endVec + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector as described above. + * @throws NullPointerException + * if endVec is null. + */ + @Override + public Vector3 lerp(final ReadOnlyVector3 endVec, final double scalar, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + final double x = (1.0 - scalar) * getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * getY() + scalar * endVec.getY(); + final double z = (1.0 - scalar) * getZ() + scalar * endVec.getZ(); + return result.set(x, y, z); + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is stored back in this vector. + * + * @param endVec + * @param scalar + * @return this vector for chaining + * @throws NullPointerException + * if endVec is null. + */ + public Vector3 lerpLocal(final ReadOnlyVector3 endVec, final double scalar) { + setX((1.0 - scalar) * getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * getY() + scalar * endVec.getY()); + setZ((1.0 - scalar) * getZ() + scalar * endVec.getZ()); + return this; + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is returned as a new vector object. + * + * @param beginVec + * @param endVec + * @param scalar + * the scalar as a percent. + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. It + * IS safe for store to be the same as the begin or end vector. + * @return a new vector as described above. + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public static Vector3 lerp(final ReadOnlyVector3 beginVec, final ReadOnlyVector3 endVec, final double scalar, + final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + + // Check for equality and skip operation if possible. + if (!beginVec.equals(endVec)) { + final double x = (1.0 - scalar) * beginVec.getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * beginVec.getY() + scalar * endVec.getY(); + final double z = (1.0 - scalar) * beginVec.getZ() + scalar * endVec.getZ(); + return result.set(x, y, z); + } else { + return result.set(beginVec); + } + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is stored back in this vector. + * + * @param beginVec + * @param endVec + * @param changeAmnt + * the scalar as a percent. + * @return this vector for chaining + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public Vector3 lerpLocal(final ReadOnlyVector3 beginVec, final ReadOnlyVector3 endVec, final double scalar) { + // Check for equality and skip operation if possible. + if (!beginVec.equals(endVec)) { + setX((1.0 - scalar) * beginVec.getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * beginVec.getY() + scalar * endVec.getY()); + setZ((1.0 - scalar) * beginVec.getZ() + scalar * endVec.getZ()); + } else { + set(beginVec); + } + return this; + } + + /** + * @return the magnitude or distance between the origin (0, 0, 0) and the point described by this vector (x, y, z). + * Effectively the square root of the value returned by {@link #lengthSquared()}. + */ + @Override + public double length() { + return MathUtils.sqrt(lengthSquared()); + } + + /** + * @return the squared magnitude or squared distance between the origin (0, 0, 0) and the point described by this + * vector (x, y, z) + */ + @Override + public double lengthSquared() { + return getX() * getX() + getY() * getY() + getZ() * getZ(); + } + + /** + * @param x + * @param y + * @param z + * @return the squared distance between the point described by this vector and the given x, y, z point. When + * comparing the relative distance between two points it is usually sufficient to compare the squared + * distances, thus avoiding an expensive square root operation. + */ + @Override + public double distanceSquared(final double x, final double y, final double z) { + final double dx = getX() - x; + final double dy = getY() - y; + final double dz = getZ() - z; + return dx * dx + dy * dy + dz * dz; + } + + /** + * @param destination + * @return the squared distance between the point described by this vector and the given destination point. When + * comparing the relative distance between two points it is usually sufficient to compare the squared + * distances, thus avoiding an expensive square root operation. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distanceSquared(final ReadOnlyVector3 destination) { + return distanceSquared(destination.getX(), destination.getY(), destination.getZ()); + } + + /** + * @param x + * @param y + * @param z + * @return the distance between the point described by this vector and the given x, y, z point. + */ + @Override + public double distance(final double x, final double y, final double z) { + return MathUtils.sqrt(distanceSquared(x, y, z)); + } + + /** + * @param destination + * @return the distance between the point described by this vector and the given destination point. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distance(final ReadOnlyVector3 destination) { + return MathUtils.sqrt(distanceSquared(destination)); + } + + /** + * @param x + * @param y + * @param z + * @return the dot product of this vector with the given x, y, z values. + */ + @Override + public double dot(final double x, final double y, final double z) { + return getX() * x + getY() * y + getZ() * z; + } + + /** + * @param vec + * @return the dot product of this vector with the x, y, z values of the given vector. + * @throws NullPointerException + * if vec is null. + */ + @Override + public double dot(final ReadOnlyVector3 vec) { + return dot(vec.getX(), vec.getY(), vec.getZ()); + } + + /** + * @param x + * @param y + * @param z + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the cross product of this vector with the given x, y, z values. + */ + @Override + public Vector3 cross(final double x, final double y, final double z, final Vector3 store) { + Vector3 result = store; + if (result == null) { + result = new Vector3(); + } + final double newX = getY() * z - getZ() * y; + final double newY = getZ() * x - getX() * z; + final double newZ = getX() * y - getY() * x; + result.set(newX, newY, newZ); + return result; + } + + /** + * @param vec + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the cross product of this vector with the given vector's x, y, z values + * @throws NullPointerException + * if vec is null. + */ + @Override + public Vector3 cross(final ReadOnlyVector3 vec, final Vector3 store) { + return cross(vec.getX(), vec.getY(), vec.getZ(), store); + } + + /** + * @param x + * @param y + * @param z + * @return this vector, set to the cross product of this vector with the given x, y, z values. + */ + public Vector3 crossLocal(final double x, final double y, final double z) { + final double newX = getY() * z - getZ() * y; + final double newY = getZ() * x - getX() * z; + final double newZ = getX() * y - getY() * x; + set(newX, newY, newZ); + return this; + } + + /** + * @param vec + * @return this vector, set to the cross product of this vector with the given vector's x, y, z values + * @throws NullPointerException + * if vec is null. + */ + public Vector3 crossLocal(final ReadOnlyVector3 vec) { + return crossLocal(vec.getX(), vec.getY(), vec.getZ()); + } + + /** + * @param otherVector + * a unit vector to find the angle against + * @return the minimum angle (in radians) between two vectors. It is assumed that both this vector and the given + * vector are unit vectors (normalized). + * @throws NullPointerException + * if otherVector is null. + */ + @Override + public double smallestAngleBetween(final ReadOnlyVector3 otherVector) { + return MathUtils.acos(dot(otherVector)); + } + + /** + * Check a vector... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param vector + * the vector to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyVector3 vector) { + if (vector == null) { + return false; + } + if (Double.isNaN(vector.getX()) || Double.isNaN(vector.getY()) || Double.isNaN(vector.getZ())) { + return false; + } + if (Double.isInfinite(vector.getX()) || Double.isInfinite(vector.getY()) || Double.isInfinite(vector.getZ())) { + return false; + } + return true; + } + + /** + * Check if a vector is non-null and has infinite values. + * + * @param vector + * the vector to check + * @return true or false as stated above. + */ + public static boolean isInfinite(final ReadOnlyVector3 vector) { + if (vector == null) { + return false; + } + if (Double.isInfinite(vector.getX()) || Double.isInfinite(vector.getY()) || Double.isInfinite(vector.getZ())) { + return true; + } + return false; + } + + /** + * @return the string representation of this vector. + */ + @Override + public String toString() { + return "com.ardor3d.math.Vector3 [X=" + getX() + ", Y=" + getY() + ", Z=" + getZ() + "]"; + } + + /** + * @return returns a unique code for this vector object based on its values. If two vectors are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + final long x = Double.doubleToLongBits(getX()); + result += 31 * result + (int) (x ^ x >>> 32); + + final long y = Double.doubleToLongBits(getY()); + result += 31 * result + (int) (y ^ y >>> 32); + + final long z = Double.doubleToLongBits(getZ()); + result += 31 * result + (int) (z ^ z >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this vector and the provided vector have the same x, y and z values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyVector3)) { + return false; + } + final ReadOnlyVector3 comp = (ReadOnlyVector3) o; + return getX() == comp.getX() && getY() == comp.getY() && getZ() == comp.getZ(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Vector3 clone() { + return new Vector3(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Vector3> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(getX(), "x", 0); + capsule.write(getY(), "y", 0); + capsule.write(getZ(), "z", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + setX(capsule.readDouble("x", 0)); + setY(capsule.readDouble("y", 0)); + setZ(capsule.readDouble("z", 0)); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setX(in.readDouble()); + setY(in.readDouble()); + setZ(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(getX()); + out.writeDouble(getY()); + out.writeDouble(getZ()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Vector3 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Vector3 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Vector3.VEC_POOL.fetch(); + } else { + return new Vector3(); + } + } + + /** + * Releases a Vector3 back to be used by a future call to fetchTempInstance. TAKE CARE: this Vector3 object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param vec + * the Vector3 to release. + */ + public final static void releaseTempInstance(final Vector3 vec) { + if (MathConstants.useMathPools) { + Vector3.VEC_POOL.release(vec); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/Vector4.java b/ardor3d-math/src/main/java/com/ardor3d/math/Vector4.java new file mode 100644 index 0000000..74927d6 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/Vector4.java @@ -0,0 +1,1090 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +import com.ardor3d.math.type.ReadOnlyVector4; +import com.ardor3d.util.export.InputCapsule; +import com.ardor3d.util.export.OutputCapsule; +import com.ardor3d.util.export.Savable; + +/** + * Vector4 represents a point or vector in a four dimensional system. This implementation stores its data in + * double-precision. + */ +public class Vector4 implements Cloneable, Savable, Externalizable, ReadOnlyVector4, Poolable { + + private static final long serialVersionUID = 1L; + + private static final ObjectPool<Vector4> VEC_POOL = ObjectPool.create(Vector4.class, MathConstants.maxMathPoolSize); + + /** + * 0, 0, 0, 0 + */ + public final static ReadOnlyVector4 ZERO = new Vector4(0, 0, 0, 0); + + /** + * 1, 1, 1, 1 + */ + public final static ReadOnlyVector4 ONE = new Vector4(1, 1, 1, 1); + + /** + * -1, -1, -1, -1 + */ + public final static ReadOnlyVector4 NEG_ONE = new Vector4(-1, -1, -1, -1); + + /** + * 1, 0, 0, 0 + */ + public final static ReadOnlyVector4 UNIT_X = new Vector4(1, 0, 0, 0); + + /** + * -1, 0, 0, 0 + */ + public final static ReadOnlyVector4 NEG_UNIT_X = new Vector4(-1, 0, 0, 0); + + /** + * 0, 1, 0, 0 + */ + public final static ReadOnlyVector4 UNIT_Y = new Vector4(0, 1, 0, 0); + + /** + * 0, -1, 0, 0 + */ + public final static ReadOnlyVector4 NEG_UNIT_Y = new Vector4(0, -1, 0, 0); + + /** + * 0, 0, 1, 0 + */ + public final static ReadOnlyVector4 UNIT_Z = new Vector4(0, 0, 1, 0); + + /** + * 0, 0, -1, 0 + */ + public final static ReadOnlyVector4 NEG_UNIT_Z = new Vector4(0, 0, -1, 0); + + /** + * 0, 0, 0, 1 + */ + public final static ReadOnlyVector4 UNIT_W = new Vector4(0, 0, 0, 1); + + /** + * 0, 0, 0, -1 + */ + public final static ReadOnlyVector4 NEG_UNIT_W = new Vector4(0, 0, 0, -1); + + protected double _x = 0; + protected double _y = 0; + protected double _z = 0; + protected double _w = 0; + + /** + * Constructs a new vector set to (0, 0, 0, 0). + */ + public Vector4() { + this(0, 0, 0, 0); + } + + /** + * Constructs a new vector set to the (x, y, z, w) values of the given source vector. + * + * @param src + */ + public Vector4(final ReadOnlyVector4 src) { + this(src.getX(), src.getY(), src.getZ(), src.getW()); + } + + /** + * Constructs a new vector set to (x, y, z, w). + * + * @param x + * @param y + * @param z + * @param w + */ + public Vector4(final double x, final double y, final double z, final double w) { + _x = x; + _y = y; + _z = z; + _w = w; + } + + @Override + public double getX() { + return _x; + } + + @Override + public double getY() { + return _y; + } + + @Override + public double getZ() { + return _z; + } + + @Override + public double getW() { + return _w; + } + + /** + * @return x as a float, to decrease need for explicit casts. + */ + @Override + public float getXf() { + return (float) _x; + } + + /** + * @return y as a float, to decrease need for explicit casts. + */ + @Override + public float getYf() { + return (float) _y; + } + + /** + * @return z as a float, to decrease need for explicit casts. + */ + @Override + public float getZf() { + return (float) _z; + } + + /** + * @return w as a float, to decrease need for explicit casts. + */ + @Override + public float getWf() { + return (float) _w; + } + + /** + * @param index + * @return x value if index == 0, y value if index == 1, z value if index == 2 or w value if index == 3 + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2, 3. + */ + @Override + public double getValue(final int index) { + switch (index) { + case 0: + return getX(); + case 1: + return getY(); + case 2: + return getZ(); + case 3: + return getW(); + } + throw new IllegalArgumentException("index must be either 0, 1, 2 or 3"); + } + + /** + * @param index + * which field index in this vector to set. + * @param value + * to set to one of x, y, z or w. + * @throws IllegalArgumentException + * if index is not one of 0, 1, 2, 3. + * + * if this vector is read only + */ + public void setValue(final int index, final double value) { + switch (index) { + case 0: + setX(value); + return; + case 1: + setY(value); + return; + case 2: + setZ(value); + return; + case 3: + setW(value); + return; + } + throw new IllegalArgumentException("index must be either 0, 1, 2 or 3"); + } + + /** + * Stores the double values of this vector in the given double array. + * + * @param store + * if null, a new double[4] array is created. + * @return the double array + * @throws ArrayIndexOutOfBoundsException + * if store is not at least length 4. + */ + @Override + public double[] toArray(double[] store) { + if (store == null) { + store = new double[4]; + } + // do last first to ensure size is correct before any edits occur. + store[3] = getW(); + store[2] = getZ(); + store[1] = getY(); + store[0] = getX(); + return store; + } + + /** + * Sets the first component of this vector to the given double value. + * + * @param x + */ + public void setX(final double x) { + _x = x; + } + + /** + * Sets the second component of this vector to the given double value. + * + * @param y + */ + public void setY(final double y) { + _y = y; + } + + /** + * Sets the third component of this vector to the given double value. + * + * @param z + */ + public void setZ(final double z) { + _z = z; + } + + /** + * Sets the fourth component of this vector to the given double value. + * + * @param w + */ + public void setW(final double w) { + _w = w; + } + + /** + * Sets the value of this vector to (x, y, z, w) + * + * @param x + * @param y + * @param z + * @param w + * @return this vector for chaining + */ + public Vector4 set(final double x, final double y, final double z, final double w) { + setX(x); + setY(y); + setZ(z); + setW(w); + return this; + } + + /** + * Sets the value of this vector to the (x, y, z, w) values of the provided source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector4 set(final ReadOnlyVector4 source) { + setX(source.getX()); + setY(source.getY()); + setZ(source.getZ()); + setW(source.getW()); + return this; + } + + /** + * Sets the value of this vector to (0, 0, 0, 0) + * + * @return this vector for chaining + */ + public Vector4 zero() { + return set(0, 0, 0, 0); + } + + /** + * Adds the given values to those of this vector and returns them in store. + * + * @param x + * @param y + * @param z + * @param w + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + x, this.y + y, this.z + z, this.w + w) + */ + @Override + public Vector4 add(final double x, final double y, final double z, final double w, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() + x, getY() + y, getZ() + z, getW() + w); + } + + /** + * Increments the values of this vector with the given x, y, z and w values. + * + * @param x + * @param y + * @param z + * @param w + * @return this vector for chaining + */ + public Vector4 addLocal(final double x, final double y, final double z, final double w) { + return set(getX() + x, getY() + y, getZ() + z, getW() + w); + } + + /** + * Adds the values of the given source vector to those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x + source.x, this.y + source.y, this.z + source.z, this.w + source.w) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector4 add(final ReadOnlyVector4 source, final Vector4 store) { + return add(source.getX(), source.getY(), source.getZ(), source.getW(), store); + } + + /** + * Increments the values of this vector with the x, y, z and w values of the given vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector4 addLocal(final ReadOnlyVector4 source) { + return addLocal(source.getX(), source.getY(), source.getZ(), source.getW()); + } + + /** + * Subtracts the given values from those of this vector and returns them in store. + * + * @param x + * @param y + * @param z + * @param w + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - x, this.y - y, this.z - z, this.w - w) + */ + @Override + public Vector4 subtract(final double x, final double y, final double z, final double w, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() - x, getY() - y, getZ() - z, getW() - w); + } + + /** + * Decrements the values of this vector by the given x, y, z and w values. + * + * @param x + * @param y + * @param z + * @param w + * @return this vector for chaining + */ + public Vector4 subtractLocal(final double x, final double y, final double z, final double w) { + return set(getX() - x, getY() - y, getZ() - z, getW() - w); + } + + /** + * Subtracts the values of the given source vector from those of this vector and returns them in store. + * + * @param source + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return (this.x - source.x, this.y - source.y, this.z - source.z, this.w - source.w) + * @throws NullPointerException + * if source is null. + */ + @Override + public Vector4 subtract(final ReadOnlyVector4 source, final Vector4 store) { + return subtract(source.getX(), source.getY(), source.getZ(), source.getW(), store); + } + + /** + * Decrements the values of this vector by the x, y, z and w values from the given source vector. + * + * @param source + * @return this vector for chaining + * @throws NullPointerException + * if source is null. + */ + public Vector4 subtractLocal(final ReadOnlyVector4 source) { + return subtractLocal(source.getX(), source.getY(), source.getZ(), source.getW()); + } + + /** + * Multiplies the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scalar, this.y * scalar, this.z * scalar, this.w * scalar) + */ + @Override + public Vector4 multiply(final double scalar, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() * scalar, getY() * scalar, getZ() * scalar, getW() * scalar); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + */ + public Vector4 multiplyLocal(final double scalar) { + return set(getX() * scalar, getY() * scalar, getZ() * scalar, getW() * scalar); + } + + /** + * Multiplies the values of this vector by the given scalar value and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y, this.z * scale.z, this.w * scale.w) + */ + @Override + public Vector4 multiply(final ReadOnlyVector4 scale, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() * scale.getX(), getY() * scale.getY(), getZ() * scale.getZ(), getW() * scale.getW()); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scale values. + * + * @param scale + * @return this vector for chaining + */ + public Vector4 multiplyLocal(final ReadOnlyVector4 scale) { + return set(getX() * scale.getX(), getY() * scale.getY(), getZ() * scale.getZ(), getW() * scale.getW()); + } + + /** + * Multiplies the values of this vector by the given scalar value and returns the result in store. + * + * @param x + * @param y + * @param z + * @param w + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x * scale.x, this.y * scale.y, this.z * scale.z, this.w * scale.w) + */ + @Override + public Vector4 multiply(final double x, final double y, final double z, final double w, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() * x, getY() * y, getZ() * z, getW() * w); + } + + /** + * Internally modifies the values of this vector by multiplying them each by the given scale values. + * + * @param x + * @param y + * @param z + * @param w + * @return this vector for chaining + */ + public Vector4 multiplyLocal(final double x, final double y, final double z, final double w) { + return set(getX() * x, getY() * y, getZ() * z, getW() * w); + } + + /** + * Divides the values of this vector by the given scalar value and returns the result in store. + * + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scalar, this.y / scalar, this.z / scalar, this.w / scalar) + */ + @Override + public Vector4 divide(final double scalar, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() / scalar, getY() / scalar, getZ() / scalar, getW() / scalar); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scalar value. + * + * @param scalar + * @return this vector for chaining + * + * + * @throws ArithmeticException + * if scalar is 0 + */ + public Vector4 divideLocal(final double scalar) { + final double invScalar = 1.0 / scalar; + + return set(getX() * invScalar, getY() * invScalar, getZ() * invScalar, getW() * invScalar); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param scale + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y, this.z / scale.z, this.w / scale.w) + */ + @Override + public Vector4 divide(final ReadOnlyVector4 scale, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() / scale.getX(), getY() / scale.getY(), getZ() / scale.getZ(), getW() / scale.getW()); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scale values. + * + * @param scale + * @return this vector for chaining + */ + public Vector4 divideLocal(final ReadOnlyVector4 scale) { + return set(getX() / scale.getX(), getY() / scale.getY(), getZ() / scale.getZ(), getW() / scale.getW()); + } + + /** + * Divides the values of this vector by the given scale values and returns the result in store. + * + * @param x + * @param y + * @param z + * @param w + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector (this.x / scale.x, this.y / scale.y, this.z / scale.z, this.w / scale.w) + */ + @Override + public Vector4 divide(final double x, final double y, final double z, final double w, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + return result.set(getX() / x, getY() / y, getZ() / z, getW() / w); + } + + /** + * Internally modifies the values of this vector by dividing them each by the given scale values. + * + * @param x + * @param y + * @param z + * @param w + * @return this vector for chaining + */ + public Vector4 divideLocal(final double x, final double y, final double z, final double w) { + return set(getX() / x, getY() / y, getZ() / z, getW() / w); + } + + /** + * + * Internally modifies this vector by multiplying its values with a given scale value, then adding a given "add" + * value. + * + * @param scale + * the value to multiply this vector by. + * @param add + * the value to add to the result + * @return this vector for chaining + */ + public Vector4 scaleAddLocal(final double scale, final Vector4 add) { + _x = _x * scale + add.getX(); + _y = _y * scale + add.getY(); + _z = _z * scale + add.getZ(); + _w = _w * scale + add.getW(); + return this; + } + + /** + * Scales this vector by multiplying its values with a given scale value, then adding a given "add" value. The + * result is store in the given store parameter. + * + * @param scale + * the value to multiply by. + * @param add + * the value to add + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return the store variable + */ + @Override + public Vector4 scaleAdd(final double scale, final ReadOnlyVector4 add, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + result.setX(_x * scale + add.getX()); + result.setY(_y * scale + add.getY()); + result.setZ(_z * scale + add.getZ()); + result.setW(_w * scale + add.getW()); + return result; + } + + /** + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return same as multiply(-1, store) + */ + @Override + public Vector4 negate(final Vector4 store) { + return multiply(-1, store); + } + + /** + * @return same as multiplyLocal(-1) + */ + public Vector4 negateLocal() { + return multiplyLocal(-1); + } + + /** + * Creates a new unit length vector from this one by dividing by length. If the length is 0, (ie, if the vector is + * 0, 0, 0, 0) then a new vector (0, 0, 0, 0) is returned. + * + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new unit vector (or 0, 0, 0, 0 if this unit is 0 length) + */ + @Override + public Vector4 normalize(final Vector4 store) { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiply(MathUtils.inverseSqrt(lengthSq), store); + } + + return store != null ? store.set(Vector4.ZERO) : new Vector4(Vector4.ZERO); + } + + /** + * Converts this vector into a unit vector by dividing it internally by its length. If the length is 0, (ie, if the + * vector is 0, 0, 0, 0) then no action is taken. + * + * @return this vector for chaining + */ + public Vector4 normalizeLocal() { + final double lengthSq = lengthSquared(); + if (Math.abs(lengthSq) > MathUtils.EPSILON) { + return multiplyLocal(MathUtils.inverseSqrt(lengthSq)); + } + + return this; + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is returned as a new vector object. + * + * @param endVec + * @param scalar + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector as described above. + * @throws NullPointerException + * if endVec is null. + */ + @Override + public Vector4 lerp(final ReadOnlyVector4 endVec, final double scalar, final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + final double x = (1.0 - scalar) * getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * getY() + scalar * endVec.getY(); + final double z = (1.0 - scalar) * getZ() + scalar * endVec.getZ(); + final double w = (1.0 - scalar) * getW() + scalar * endVec.getW(); + return result.set(x, y, z, w); + } + + /** + * Performs a linear interpolation between this vector and the given end vector, using the given scalar as a + * percent. iow, if changeAmnt is closer to 0, the result will be closer to the current value of this vector and if + * it is closer to 1, the result will be closer to the end value. The result is stored back in this vector. + * + * @param endVec + * @param scalar + * @return this vector for chaining + * + * + * @throws NullPointerException + * if endVec is null. + */ + public Vector4 lerpLocal(final ReadOnlyVector4 endVec, final double scalar) { + setX((1.0 - scalar) * getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * getY() + scalar * endVec.getY()); + setZ((1.0 - scalar) * getZ() + scalar * endVec.getZ()); + setW((1.0 - scalar) * getW() + scalar * endVec.getW()); + return this; + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is returned as a new vector object. + * + * @param beginVec + * @param endVec + * @param scalar + * the scalar as a percent. + * @param store + * the vector to store the result in for return. If null, a new vector object is created and returned. + * @return a new vector as described above. + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public static Vector4 lerp(final ReadOnlyVector4 beginVec, final ReadOnlyVector4 endVec, final double scalar, + final Vector4 store) { + Vector4 result = store; + if (result == null) { + result = new Vector4(); + } + + final double x = (1.0 - scalar) * beginVec.getX() + scalar * endVec.getX(); + final double y = (1.0 - scalar) * beginVec.getY() + scalar * endVec.getY(); + final double z = (1.0 - scalar) * beginVec.getZ() + scalar * endVec.getZ(); + final double w = (1.0 - scalar) * beginVec.getW() + scalar * endVec.getW(); + return result.set(x, y, z, w); + } + + /** + * Performs a linear interpolation between the given begin and end vectors, using the given scalar as a percent. + * iow, if changeAmnt is closer to 0, the result will be closer to the begin value and if it is closer to 1, the + * result will be closer to the end value. The result is stored back in this vector. + * + * @param beginVec + * @param endVec + * @param changeAmnt + * the scalar as a percent. + * @return this vector for chaining + * + * + * @throws NullPointerException + * if beginVec or endVec are null. + */ + public Vector4 lerpLocal(final ReadOnlyVector4 beginVec, final ReadOnlyVector4 endVec, final double scalar) { + setX((1.0 - scalar) * beginVec.getX() + scalar * endVec.getX()); + setY((1.0 - scalar) * beginVec.getY() + scalar * endVec.getY()); + setZ((1.0 - scalar) * beginVec.getZ() + scalar * endVec.getZ()); + setW((1.0 - scalar) * beginVec.getW() + scalar * endVec.getW()); + return this; + } + + /** + * @return the magnitude or distance between the origin (0, 0, 0, 0) and the point described by this vector (x, y, + * z, w). Effectively the square root of the value returned by {@link #lengthSquared()}. + */ + @Override + public double length() { + return MathUtils.sqrt(lengthSquared()); + } + + /** + * @return the squared magnitude or squared distance between the origin (0, 0, 0, 0) and the point described by this + * vector (x, y, z, w) + */ + @Override + public double lengthSquared() { + return getX() * getX() + getY() * getY() + getZ() * getZ() + getW() * getW(); + } + + /** + * @param x + * @param y + * @param z + * @param w + * @return the squared distance between the point described by this vector and the given x, y, z, w point. When + * comparing the relative distance between two points it is usually sufficient to compare the squared + * distances, thus avoiding an expensive square root operation. + */ + @Override + public double distanceSquared(final double x, final double y, final double z, final double w) { + final double dx = getX() - x; + final double dy = getY() - y; + final double dz = getZ() - z; + final double dw = getW() - w; + return dx * dx + dy * dy + dz * dz + dw * dw; + } + + /** + * @param destination + * @return the squared distance between the point described by this vector and the given destination point. When + * comparing the relative distance between two points it is usually sufficient to compare the squared + * distances, thus avoiding an expensive square root operation. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distanceSquared(final ReadOnlyVector4 destination) { + return distanceSquared(destination.getX(), destination.getY(), destination.getZ(), destination.getW()); + } + + /** + * @param x + * @param y + * @param z + * @param w + * @return the distance between the point described by this vector and the given x, y, z, w point. + */ + @Override + public double distance(final double x, final double y, final double z, final double w) { + return MathUtils.sqrt(distanceSquared(x, y, z, w)); + } + + /** + * @param destination + * @return the distance between the point described by this vector and the given destination point. + * @throws NullPointerException + * if destination is null. + */ + @Override + public double distance(final ReadOnlyVector4 destination) { + return MathUtils.sqrt(distanceSquared(destination)); + } + + /** + * @param x + * @param y + * @param z + * @param w + * @return the dot product of this vector with the given x, y, z, w values. + */ + @Override + public double dot(final double x, final double y, final double z, final double w) { + return getX() * x + getY() * y + getZ() * z + getW() * w; + } + + /** + * @param vec + * @return the dot product of this vector with the x, y, z, w values of the given vector. + * @throws NullPointerException + * if vec is null. + */ + @Override + public double dot(final ReadOnlyVector4 vec) { + return dot(vec.getX(), vec.getY(), vec.getZ(), vec.getW()); + } + + /** + * Check a vector... if it is null or its doubles are NaN or infinite, return false. Else return true. + * + * @param vector + * the vector to check + * @return true or false as stated above. + */ + public static boolean isValid(final ReadOnlyVector4 vector) { + if (vector == null) { + return false; + } + if (Double.isNaN(vector.getX()) || Double.isNaN(vector.getY()) || Double.isNaN(vector.getZ()) + || Double.isNaN(vector.getW())) { + return false; + } + if (Double.isInfinite(vector.getX()) || Double.isInfinite(vector.getY()) || Double.isInfinite(vector.getZ()) + || Double.isInfinite(vector.getW())) { + return false; + } + return true; + } + + /** + * @return the string representation of this vector. + */ + @Override + public String toString() { + return "com.ardor3d.math.Vector4 [X=" + getX() + ", Y=" + getY() + ", Z=" + getZ() + ", W=" + getW() + "]"; + } + + /** + * @return returns a unique code for this vector object based on its values. If two vectors are numerically equal, + * they will return the same hash code value. + */ + @Override + public int hashCode() { + int result = 17; + + final long x = Double.doubleToLongBits(getX()); + result += 31 * result + (int) (x ^ x >>> 32); + + final long y = Double.doubleToLongBits(getY()); + result += 31 * result + (int) (y ^ y >>> 32); + + final long z = Double.doubleToLongBits(getZ()); + result += 31 * result + (int) (z ^ z >>> 32); + + final long w = Double.doubleToLongBits(getW()); + result += 31 * result + (int) (w ^ w >>> 32); + + return result; + } + + /** + * @param o + * the object to compare for equality + * @return true if this vector and the provided vector have the same x, y, z and w values. + */ + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReadOnlyVector4)) { + return false; + } + final ReadOnlyVector4 comp = (ReadOnlyVector4) o; + return getX() == comp.getX() && getY() == comp.getY() && getZ() == comp.getZ() && getW() == comp.getW(); + } + + // ///////////////// + // Method for Cloneable + // ///////////////// + + @Override + public Vector4 clone() { + return new Vector4(this); + } + + // ///////////////// + // Methods for Savable + // ///////////////// + + @Override + public Class<? extends Vector4> getClassTag() { + return this.getClass(); + } + + @Override + public void write(final OutputCapsule capsule) throws IOException { + capsule.write(getX(), "x", 0); + capsule.write(getY(), "y", 0); + capsule.write(getZ(), "z", 0); + capsule.write(getW(), "w", 0); + } + + @Override + public void read(final InputCapsule capsule) throws IOException { + setX(capsule.readDouble("x", 0)); + setY(capsule.readDouble("y", 0)); + setZ(capsule.readDouble("z", 0)); + setW(capsule.readDouble("w", 0)); + } + + // ///////////////// + // Methods for Externalizable + // ///////////////// + + /** + * Used with serialization. Not to be called manually. + * + * @param in + * ObjectInput + * @throws IOException + * @throws ClassNotFoundException + */ + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + setX(in.readDouble()); + setY(in.readDouble()); + setZ(in.readDouble()); + setW(in.readDouble()); + } + + /** + * Used with serialization. Not to be called manually. + * + * @param out + * ObjectOutput + * @throws IOException + */ + @Override + public void writeExternal(final ObjectOutput out) throws IOException { + out.writeDouble(getX()); + out.writeDouble(getY()); + out.writeDouble(getZ()); + out.writeDouble(getW()); + } + + // ///////////////// + // Methods for creating temp variables (pooling) + // ///////////////// + + /** + * @return An instance of Vector4 that is intended for temporary use in calculations and so forth. Multiple calls to + * the method should return instances of this class that are not currently in use. + */ + public final static Vector4 fetchTempInstance() { + if (MathConstants.useMathPools) { + return Vector4.VEC_POOL.fetch(); + } else { + return new Vector4(); + } + } + + /** + * Releases a Vector4 back to be used by a future call to fetchTempInstance. TAKE CARE: this Vector4 object should + * no longer have other classes referencing it or "Bad Things" will happen. + * + * @param vec + * the Vector4 to release. + */ + public final static void releaseTempInstance(final Vector4 vec) { + if (MathConstants.useMathPools) { + Vector4.VEC_POOL.release(vec); + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/ArchimedeanSpiralFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/ArchimedeanSpiralFunction3D.java new file mode 100644 index 0000000..47c783a --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/ArchimedeanSpiralFunction3D.java @@ -0,0 +1,83 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.functions;
+
+import com.ardor3d.math.MathUtils;
+
+/**
+ * An implementation of an Archimedean spiral which supports any number of spiral arms and optional turbulence.
+ *
+ * @see <a href="http://en.wikipedia.org/wiki/Archimedean_spiral">wikipedia entry</a>
+ */
+public class ArchimedeanSpiralFunction3D implements Function3D {
+
+ private static final int DEFAULT_ROUGHNESS = 1;
+ private static final double DEFAULT_FREQUENCY = 0.2;
+ private static final Function3D DEFAULT_TURBULENCE = new FbmFunction3D(Functions.simplexNoise(), DEFAULT_ROUGHNESS,
+ DEFAULT_FREQUENCY, 0.5, 2.0);
+
+ private final int _numArms;
+ private final Function3D _turbulenceFunction;
+
+ /**
+ * Create the function for the specified number of arms, and optionally use the default turbulence.
+ *
+ * @param numArms
+ * The number of arms of the spiral (1 or more).
+ * @param useDefaultTurbulence
+ * True if the default turbulence should be used; false for no turbulence.
+ */
+ public ArchimedeanSpiralFunction3D(final int numArms, final boolean useDefaultTurbulence) {
+ this(numArms, useDefaultTurbulence ? DEFAULT_TURBULENCE : null);
+ }
+
+ /**
+ * Create the function for the specified number of arms, with the specified turbulence.
+ *
+ * @param numArms
+ * The number of arms of the spiral (1 or more).
+ * @param turbulenceFunction
+ * The turbulence function to use (can be null).
+ */
+ public ArchimedeanSpiralFunction3D(final int numArms, final Function3D turbulenceFunction) {
+ _numArms = numArms;
+ _turbulenceFunction = turbulenceFunction;
+ }
+
+ /**
+ * Evaluate the function.
+ *
+ * @return A result which is generally, but not always, in the -1 to 1 range.
+ */
+ public double eval(final double x, final double y, final double z) {
+ final double radius = Math.sqrt(x * x + y * y);
+
+ double phi;
+ if (radius == 0.0) {
+ phi = 0.0;
+ } else {
+ if (x < 0.0) {
+ phi = 3.0 * MathUtils.HALF_PI - Math.asin(y / radius);
+ } else {
+ phi = MathUtils.HALF_PI + Math.asin(y / radius);
+ }
+ }
+
+ final double turbulence = (_turbulenceFunction != null) ? _turbulenceFunction.eval(x, y, z) : 0.0;
+
+ double value = z + radius + ((_numArms * phi) / MathUtils.TWO_PI) + turbulence;
+
+ value = value % 1.0;
+ value = (value * 2.0) - 1.0;
+
+ return value;
+ }
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/BrickGridFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/BrickGridFunction3D.java new file mode 100644 index 0000000..d66c133 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/BrickGridFunction3D.java @@ -0,0 +1,113 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.functions;
+
+import com.ardor3d.math.MathUtils;
+
+/**
+ * Creates a brick-like pattern in the XY plane. This is not really 3D, since it ignores the z factor.
+ *
+ * The brick and mortar values returned by this function can (and do by default) have some amount of variation for
+ * visual interest. The specified variation represents a maximum -- actual variation is determined randomly within this
+ * maximum variation. Since actual variation is determined randomly, the brick and mortar values are likely to change a
+ * bit for each instance of this class. In other words, if you do not want the variation to change at all, you should
+ * instantiate this class once and use the same object each time.
+ */
+public class BrickGridFunction3D extends GridPatternFunction3D {
+
+ private static final int DEFAULT_BRICK_LENGTH = 12;
+ private static final int DEFAULT_BRICK_HEIGHT = 6;
+ private static final int DEFAULT_MORTAR_THICKNESS = 1;
+ private static final double DEFAULT_BRICK_VALUE = 0.0;
+ private static final double DEFAULT_MORTAR_VALUE = 0.9;
+ private static final double DEFAULT_BRICK_VARIATION = 0.1;
+ private static final double DEFAULT_MORTAR_VARIATION = 0.05;
+
+ /**
+ * Create a brick pattern using all default values.
+ */
+ public BrickGridFunction3D() {
+ this(DEFAULT_BRICK_LENGTH, DEFAULT_BRICK_HEIGHT, DEFAULT_MORTAR_THICKNESS, DEFAULT_BRICK_VALUE,
+ DEFAULT_MORTAR_VALUE, DEFAULT_BRICK_VARIATION, DEFAULT_MORTAR_VARIATION);
+ }
+
+ /**
+ * Create a brick pattern with values specified by the caller.
+ *
+ * @param brickLength
+ * The number of grid cells used for the length of a brick (default 12).
+ * @param brickHeight
+ * The number of grid cells used for the height of a brick (default 6).
+ * @param mortarThickness
+ * The number of grid cells used for the thickness of mortar (default 1).
+ * @param brickValue
+ * The value returned from the function for a brick coordinate (default 0.0).
+ * @param mortarValue
+ * The value returned from the function for a mortar coordinate (default 0.9).
+ * @param brickVariationAmount
+ * The amount by which the brick value can vary (default 0.1). Use 0.0 for no variation.
+ * @param mortarVariationAmount
+ * The amount by which the mortar value can vary (default 0.05). Use 0.0 for no variation.
+ */
+ public BrickGridFunction3D(final int brickLength, final int brickHeight, final int mortarThickness,
+ final double brickValue, final double mortarValue, final double brickVariationAmount,
+ final double mortarVariationAmount) {
+ super(createBrickGrid(brickLength, brickHeight, mortarThickness, brickValue, mortarValue, brickVariationAmount,
+ mortarVariationAmount));
+ }
+
+ /**
+ * A private utility method to build the grid used to represent the bricks.
+ */
+ private static double[][] createBrickGrid(final int brickLength, final int brickHeight, final int mortarThickness,
+ final double brickValue, final double mortarValue, final double brickVariationAmount,
+ final double mortarVariationAmount) {
+ final int xTotal = brickLength + mortarThickness;
+ final int yTotal = (brickHeight * 2) + (mortarThickness * 2);
+ final double[][] grid = new double[xTotal][yTotal];
+
+ // for simplicity, initialize all cells to the brick-value since that is by far the most
+ // common value.
+ for (int x = 0; x < xTotal; x++) {
+ for (int y = 0; y < yTotal; y++) {
+ grid[x][y] = createGridValue(brickValue, brickVariationAmount);
+ }
+ }
+
+ // now put the mortar value into those cells that need it.
+ // first, create the horizontal mortar lines...
+ for (int x = 0; x < xTotal; x++) {
+ for (int y = brickHeight; y < (brickHeight + mortarThickness); y++) {
+ grid[x][y] = createGridValue(mortarValue, mortarVariationAmount);
+ grid[x][y + brickHeight + 1] = createGridValue(mortarValue, mortarVariationAmount);
+ }
+ }
+
+ // ... then create the vertical mortar lines.
+ for (int y = 0; y < brickHeight; y++) {
+ grid[xTotal / 2][y + brickHeight + 1] = createGridValue(mortarValue, mortarVariationAmount);
+ grid[xTotal - 1][y] = createGridValue(mortarValue, mortarVariationAmount);
+ }
+
+ return grid;
+ }
+
+ private static double createGridValue(final double baseValue, final double variationAmount) {
+ double gridValue = baseValue;
+
+ if (variationAmount > 0.0) {
+ final double variation = (MathUtils.nextRandomDouble() * (variationAmount * 2.0)) - variationAmount;
+ gridValue += variation;
+ }
+
+ return gridValue;
+ }
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/CheckerFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CheckerFunction3D.java new file mode 100644 index 0000000..b782051 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CheckerFunction3D.java @@ -0,0 +1,27 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import com.ardor3d.math.MathUtils; + +/** + * A simple checker board pattern, with each unit cube alternating between -1 and 1 in value. + */ +public class CheckerFunction3D implements Function3D { + + public double eval(final double x, final double y, final double z) { + if ((MathUtils.floor(x) + MathUtils.floor(y) + MathUtils.floor(z)) % 2 == 0) { + return -1; + } else { + return 1; + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/CloudsFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CloudsFunction3D.java new file mode 100644 index 0000000..10dcb39 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CloudsFunction3D.java @@ -0,0 +1,32 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +/** + * A variation of fBm that uses absolute value to recast the extreme ends to the upper range and values near 0 to the + * lower range. This bunches together values into clusters that can resemble clouds or cotton balls. + */ +public class CloudsFunction3D extends FbmFunction3D { + + public static final int MAX_OCTAVES = 32; + + public CloudsFunction3D(final Function3D source, final int octaves, final double frequency, + final double persistence, final double lacunarity) { + super(source, octaves, frequency, persistence, lacunarity); + } + + @Override + protected double getValue(final double dx, final double dy, final double dz) { + // Basically the "cloudy" |f(x)| you can find in perlin's docs and elsewhere, but rescaled to [-1, 1] to keep it + // in the range used by most of our function. + return 2.0 * Math.abs(getSource().eval(dx, dy, dz)) - 1.0; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/CylinderFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CylinderFunction3D.java new file mode 100644 index 0000000..6ec23b0 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/CylinderFunction3D.java @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import com.ardor3d.math.MathUtils; + +/** + * Function describing a set of concentric rings, centered around the origin on the x/z plane, each ring stretching + * infinitely along the Y axis. The spacing between rings is controlled by the frequency. A higher frequency gives more + * rings in the same amount of space. + */ +public class CylinderFunction3D implements Function3D { + private double _frequency; + + /** + * Construct a new CylinderFunction3D with the given frequency + * + * @param frequency + * the number of rings per unit + */ + public CylinderFunction3D(final double frequency) { + setFrequency(frequency); + } + + public double eval(final double x, final double y, final double z) { + final double dx = x * _frequency; + final double dz = z * _frequency; + + // get the radius to our point -- see the equation of a circle + double radius = MathUtils.sqrt(dx * dx + dz * dz); + + // get fractional part + radius = radius - MathUtils.floor(radius); + + // now get the distance to the closest integer, radius is now [0, .5] + radius = Math.min(radius, 1 - radius); + + // return a value between -1 and 1, where 1 means the radius length was on an integer value and -1 means it was + // halfway between two integers. + return 1.0 - radius * 4; // [-1, 1] + } + + public void setFrequency(final double frequency) { + _frequency = frequency; + } + + public double getFrequency() { + return _frequency; + } + +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/FbmFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/FbmFunction3D.java new file mode 100644 index 0000000..7aa48b4 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/FbmFunction3D.java @@ -0,0 +1,117 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +/** + * An implementation of Fractional Brownian Motion (fBm), with configurable persistence and lacunarity (or tightness of + * the fractal). This function basically recursively adds the given source function (often a noise function) onto + * itself, shifting and scaling the sample point and value on each iteration (or octave). + * + * @see <a href="http://en.wikipedia.org/wiki/Fractional_Brownian_motion">wikipedia entry</a> + */ +public class FbmFunction3D implements Function3D { + + private Function3D _source; + private int _octaves; + private double _frequency; + private double _persistence; + private double _lacunarity; + + /** + * Construct a new FbmFunction with the given params. + * + * @param source + * the source function we will operate on. + * @param octaves + * the number of iterations we will perform. Called octaves because the default for each octave is double + * the frequency of the previous octave, a property shared by music tones. Generally a value between 4 + * and 8 is good. + * @param frequency + * a scale value applied to the incoming tuple before we apply fBm. It is the number of cycles per unit + * for the function. Default would be 1. + * @param persistence + * a scale value that determines how fast the amplitude decreases for each octave. Generally should be in + * the range [0, 1]. A lower persistence value will decrease the effect of each octave. A traditional + * value is 0.5 + * @param lacunarity + * a scale value that determines how fast the frequency increases for each octave (freq = prevFreq * + * lac.) A traditional value is 2. + */ + public FbmFunction3D(final Function3D source, final int octaves, final double frequency, final double persistence, + final double lacunarity) { + _source = source; + _octaves = octaves; + _frequency = frequency; + _persistence = persistence; + _lacunarity = lacunarity; + } + + public double eval(final double x, final double y, final double z) { + double sum = 0; + double dx = x * _frequency, dy = y * _frequency, dz = z * _frequency; + double dPersistence = 1; + for (int i = 0; i < _octaves; i++) { + final double value = getValue(dx, dy, dz); + + sum += dPersistence * value; + + dPersistence *= _persistence; + dx *= _lacunarity; + dy *= _lacunarity; + dz *= _lacunarity; + } + return sum; + } + + protected double getValue(final double dx, final double dy, final double dz) { + return _source.eval(dx, dy, dz); + } + + public Function3D getSource() { + return _source; + } + + public void setSource(final Function3D source) { + _source = source; + } + + public int getOctaves() { + return _octaves; + } + + public void setOctaves(final int octaves) { + _octaves = octaves; + } + + public double getFrequency() { + return _frequency; + } + + public void setFrequency(final double frequency) { + _frequency = frequency; + } + + public double getPersistence() { + return _persistence; + } + + public void setPersistence(final double persistence) { + _persistence = persistence; + } + + public double getLacunarity() { + return _lacunarity; + } + + public void setLacunarity(final double lacunarity) { + _lacunarity = lacunarity; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/Function3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/Function3D.java new file mode 100644 index 0000000..143d858 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/Function3D.java @@ -0,0 +1,29 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +/** + * Simple interface describing a function that receives a 3 value tuple and returns a value. + */ +public interface Function3D { + + /** + * @param x + * the 1st value in our tuple + * @param y + * the 2nd value in our tuple + * @param z + * the 3rd value in our tuple + * @return some value, generally (but not necessarily) in [-1, 1] + */ + double eval(double x, double y, double z); + +}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/Functions.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/Functions.java new file mode 100644 index 0000000..b0ba25d --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/Functions.java @@ -0,0 +1,241 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import com.ardor3d.math.MathUtils; +import com.ardor3d.math.Vector3; +import com.ardor3d.math.type.ReadOnlyMatrix3; + +/** + * Utility class containing a set of easy to use functions. + */ +public class Functions { + + /** + * @param constant + * @return a function that will always return the given constant value regardless of input + */ + public static Function3D constant(final double constant) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return constant; + } + }; + } + + /** + * @param source + * @param scale + * @param bias + * @return a function that returns (src.eval * scale) + bias. + */ + public static Function3D scaleBias(final Function3D source, final double scale, final double bias) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return source.eval(x, y, z) * scale + bias; + } + }; + } + + /** + * @param source + * @return a function that returns |src.eval| + */ + public static Function3D abs(final Function3D source) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return Math.abs(source.eval(x, y, z)); + } + }; + } + + /** + * @param source + * @param min + * @param max + * @return a function that returns src.eval clamped to [min, max] + */ + public static Function3D clamp(final Function3D source, final double min, final double max) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return MathUtils.clamp(source.eval(x, y, z), min, max); + } + }; + } + + /** + * @param source + * @return a function that returns -(src.eval) + */ + public static Function3D invert(final Function3D source) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return -source.eval(x, y, z); + } + }; + } + + /** + * @param sourceA + * @param sourceB + * @return a function the returns srcA.eval + srcB.eval + */ + public static Function3D add(final Function3D sourceA, final Function3D sourceB) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return sourceA.eval(x, y, z) + sourceB.eval(x, y, z); + } + }; + } + + /** + * @param sourceA + * @param sourceB + * @return a function the returns srcA.eval * srcB.eval + */ + public static Function3D multiply(final Function3D sourceA, final Function3D sourceB) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return sourceA.eval(x, y, z) * sourceB.eval(x, y, z); + } + }; + } + + /** + * @param sourceA + * @param sourceB + * @return a function the returns min(srcA.eval, srcB.eval) + */ + public static Function3D min(final Function3D sourceA, final Function3D sourceB) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return Math.min(sourceA.eval(x, y, z), sourceB.eval(x, y, z)); + } + }; + } + + /** + * @param sourceA + * @param sourceB + * @return a function the returns max(srcA.eval, srcB.eval) + */ + public static Function3D max(final Function3D sourceA, final Function3D sourceB) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return Math.max(sourceA.eval(x, y, z), sourceB.eval(x, y, z)); + } + }; + } + + /** + * (1-amount) * srcA.eval + (amount) * srcB.eval + * + * @param sourceA + * @param sourceB + * @param amount + * @return a function the linear interpolation of srcA.eval and srcB.eval using the given amount. + */ + public static Function3D lerp(final Function3D sourceA, final Function3D sourceB, final double amount) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return MathUtils.lerp(amount, sourceA.eval(x, y, z), sourceB.eval(x, y, z)); + } + }; + } + + /** + * @param source + * @param rotation + * @return a function that rotates the 3 value tuple as a vector using the given matrix before feeding it to + * src.eval. + */ + public static Function3D rotateInput(final Function3D source, final ReadOnlyMatrix3 rotation) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + final Vector3 temp = Vector3.fetchTempInstance(); + temp.set(x, y, z); + rotation.applyPost(temp, temp); + final double val = source.eval(temp.getX(), temp.getY(), temp.getZ()); + Vector3.releaseTempInstance(temp); + return val; + } + }; + } + + /** + * @param source + * @param scaleX + * @param scaleY + * @param scaleZ + * @return a function that scales the 3 value tuple using the given values before feeding it to src.eval. + */ + public static Function3D scaleInput(final Function3D source, final double scaleX, final double scaleY, + final double scaleZ) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return source.eval(x * scaleX, y * scaleY, z * scaleZ); + } + }; + } + + /** + * @param source + * @param transX + * @param transY + * @param transZ + * @return a function that translates the 3 value tuple using the given values before feeding it to src.eval. + */ + public static Function3D translateInput(final Function3D source, final double transX, final double transY, + final double transZ) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + return source.eval(x + transX, y + transY, z + transZ); + } + }; + } + + /** + * @param source + * @param oldLow + * @param oldHigh + * @param newLow + * @param newHigh + * @return a function that maps src.eval from a given range onto a new range. + */ + public static Function3D remap(final Function3D source, final double oldLow, final double oldHigh, + final double newLow, final double newHigh) { + return new Function3D() { + public double eval(final double x, final double y, final double z) { + double val = source.eval(x, y, z); + // Zero out old domain + val -= oldLow; + val /= (oldHigh - oldLow); + // Shift to new domain + val *= (newHigh - newLow); + val += newLow; + return val; + } + }; + } + + /** + * @return a function that returns simplex noise. + */ + public static Function3D simplexNoise() { + return new Function3D() { + SimplexNoise noiseGenerator = new SimplexNoise(); + + public double eval(final double x, final double y, final double z) { + return noiseGenerator.noise(x, y, z); + } + }; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/GridPatternFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/GridPatternFunction3D.java new file mode 100644 index 0000000..b47d85f --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/GridPatternFunction3D.java @@ -0,0 +1,80 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.functions;
+
+/**
+ * Creates a pattern in the XY plane that is defined by a user-provided grid of values. This is not really 3D, since it
+ * ignores the z factor.
+ */
+public class GridPatternFunction3D implements Function3D {
+
+ private final double[][] _grid;
+ private final double _xScaleFactor;
+ private final double _yScaleFactor;
+
+ /**
+ * Create the grid pattern function. The x-scale and y-scale will both default to 1.0.
+ *
+ * @param grid
+ * A grid of values in the range of -1 to 1.
+ */
+ public GridPatternFunction3D(final double[][] grid) {
+ this(grid, 1.0, 1.0);
+ }
+
+ /**
+ * Create the grid pattern function.
+ *
+ * @param grid
+ * A grid of values in the range of -1 to 1.
+ * @param xScaleFactor
+ * The amount by which to scale grid cells along their x axis.
+ * @param yScaleFactor
+ * The amount by which to scale grid cells along their y axis.
+ */
+ public GridPatternFunction3D(final double[][] grid, final double xScaleFactor, final double yScaleFactor) {
+ _grid = grid;
+ _xScaleFactor = xScaleFactor;
+ _yScaleFactor = yScaleFactor;
+ }
+
+ /**
+ * Evaluate the x and y valus (ignores z) to determine the value to return.
+ *
+ * @return
+ */
+ public double eval(double x, double y, final double z) {
+ x = Math.abs(x);
+ y = Math.abs(y);
+
+ double scaledX = x / _xScaleFactor;
+ double scaledY = y / _yScaleFactor;
+
+ final int numXCells = _grid.length;
+ final int numYCells = _grid[0].length;
+ scaledX -= Math.floor(scaledX / numXCells) * numXCells;
+ scaledY -= Math.floor(scaledY / numYCells) * numYCells;
+
+ final int gridX = (int) (Math.floor(scaledX) % numXCells);
+ final int gridY = (int) (Math.floor(scaledY) % numYCells);
+
+ return getCellValue(gridX, gridY, scaledX, scaledY);
+ }
+
+ /**
+ * Gets a value from the user-defined grid. This is an extension point for subclasses which may need to perform a
+ * calculation of some type on that value before returning it. The default implementation simply returns the value
+ * from the grid at gridX/gridY.
+ */
+ protected double getCellValue(final int gridX, final int gridY, final double scaledX, final double scaledY) {
+ return _grid[gridX][gridY];
+ }
+}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/HexGridFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/HexGridFunction3D.java new file mode 100644 index 0000000..2aa2ce3 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/HexGridFunction3D.java @@ -0,0 +1,89 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.functions;
+
+import com.ardor3d.math.MathUtils;
+
+/**
+ * Creates a hexagon pattern in the XY plane. This is not really 3D, since it ignores the z factor.
+ */
+public class HexGridFunction3D extends GridPatternFunction3D {
+
+ private static final double EQUILATERAL_TRIANGLE_HEIGHT = Math.sqrt(3.0) / 2.0;
+
+ private static final double[][] FIXED_VALUES = new double[6][6];
+
+ static {
+ FIXED_VALUES[0][0] = FIXED_VALUES[5][0] = -1;
+ FIXED_VALUES[0][1] = FIXED_VALUES[5][1] = 0;
+ FIXED_VALUES[0][2] = FIXED_VALUES[5][2] = 0;
+ FIXED_VALUES[0][3] = FIXED_VALUES[5][3] = 1;
+ FIXED_VALUES[0][4] = FIXED_VALUES[5][4] = 1;
+ FIXED_VALUES[0][5] = FIXED_VALUES[5][5] = -1;
+
+ FIXED_VALUES[2][0] = FIXED_VALUES[3][0] = 1;
+ FIXED_VALUES[2][1] = FIXED_VALUES[3][1] = 1;
+ FIXED_VALUES[2][2] = FIXED_VALUES[3][2] = -1;
+ FIXED_VALUES[2][3] = FIXED_VALUES[3][3] = -1;
+ FIXED_VALUES[2][4] = FIXED_VALUES[3][4] = 0;
+ FIXED_VALUES[2][5] = FIXED_VALUES[3][5] = 0;
+
+ FIXED_VALUES[1][0] = FIXED_VALUES[4][0] = -1;
+ FIXED_VALUES[1][1] = FIXED_VALUES[4][1] = 1;
+ FIXED_VALUES[1][2] = FIXED_VALUES[4][2] = 0;
+ FIXED_VALUES[1][3] = FIXED_VALUES[4][3] = -1;
+ FIXED_VALUES[1][4] = FIXED_VALUES[4][4] = 1;
+ FIXED_VALUES[1][5] = FIXED_VALUES[4][5] = 0;
+ }
+
+ private static final double[] ALTERNATE_VALUES = { 1, 0, -1, 1, 0, -1 };
+
+ public HexGridFunction3D() {
+ super(FIXED_VALUES, 0.5, EQUILATERAL_TRIANGLE_HEIGHT);
+ }
+
+ @Override
+ protected double getCellValue(final int gridX, final int gridY, final double scaledX, final double scaledY) {
+ double value = 0.0;
+
+ switch (gridX) {
+ case 0:
+ case 2:
+ case 3:
+ case 5:
+ value = super.getCellValue(gridX, gridY, scaledX, scaledY);
+ break;
+ case 1:
+ case 4:
+ double x = scaledX - gridX;
+ final double y = scaledY - gridY;
+
+ // If a grid block has a negative slope, flip it.
+ if (((gridX + gridY) % 2) == 1) {
+ x = 1.0 - x;
+ }
+
+ if (x == 0.0) {
+ x = MathUtils.ZERO_TOLERANCE;
+ }
+
+ final boolean lowAngle = ((y / x) < 1.0);
+ if (lowAngle) {
+ value = super.getCellValue(gridX, gridY, scaledX, scaledY);
+ } else {
+ value = ALTERNATE_VALUES[gridY];
+ }
+ break;
+ }
+
+ return value;
+ }
+}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/MandelbrotFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MandelbrotFunction3D.java new file mode 100644 index 0000000..d81c105 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MandelbrotFunction3D.java @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +/** + * A function that returns the famous Mandelbrot set. This is not really 3d... The z factor is ignored. + * + * @see <a href="http://en.wikipedia.org/wiki/Mandelbrot_set">wikipedia entry</a> + */ +public class MandelbrotFunction3D implements Function3D { + + private int _iterations; + + public MandelbrotFunction3D(final int iterations) { + setIterations(iterations); + } + + public double eval(final double x, final double y, final double z) { + double dx = 0; + double dy = 0; + + int iteration = 0; + + while (dx * dx + dy * dy <= (2 * 2) && iteration < _iterations) { + final double xtemp = dx * dx - dy * dy + x; + dy = 2 * dx * dy + y; + dx = xtemp; + iteration++; + } + + if (iteration == _iterations) { + return 1; + } else { + // returns a value in [-1, 1] + return 2 * (iteration / (double) _iterations) - 1; + } + } + + public void setIterations(final int iterations) { + _iterations = iterations; + } + + public int getIterations() { + return _iterations; + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/MapperFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MapperFunction3D.java new file mode 100644 index 0000000..5502f7f --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MapperFunction3D.java @@ -0,0 +1,145 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import java.util.ArrayList; +import java.util.List; + +import com.ardor3d.math.MathUtils; + +/** + * This function takes a "map" function and uses the value it returns at a certain point to look up and evaluate another + * function from a set of ranged functions. + */ +public class MapperFunction3D implements Function3D { + + private Function3D _mapFunction; + private final List<Entry> _entries = new ArrayList<Entry>(); + private double _domainStart, _domainEnd; + + /** + * Construct a mapper function using the given map function and a start and end for the domain we'll use. + * + * @param mapFunction + * @param domainStart + * @param domainEnd + */ + public MapperFunction3D(final Function3D mapFunction, final double domainStart, final double domainEnd) { + _mapFunction = mapFunction; + _domainStart = domainStart; + _domainEnd = domainEnd; + } + + public double eval(final double x, final double y, final double z) { + // grab a value from our map function. + final double mappingValue = MathUtils.clamp(_mapFunction.eval(x, y, z), _domainStart, _domainEnd); + + // Walk through our entries until we get which entries we are working with (1 or 2 if we are blending between + // entries) + Entry prev = null, current = null, next = _entries.get(0); + double start, end = _domainStart + next.offsetStart; + for (int i = 1; i <= _entries.size(); i++) { + prev = current; + current = next; + next = i < _entries.size() ? _entries.get(i) : null; + start = end; + end = next != null ? end + next.offsetStart : _domainEnd; + + // check if we are in the right main interval + if (mappingValue <= end) { + // check if we are in the ease-in region and have a prev function. + if (prev != null && mappingValue < start + current.easeIn) { + // ...interpolate with a quintic S-curve. + final double ratio = (mappingValue - start) / current.easeIn; + final double amount = MathUtils.scurve5(ratio); + return MathUtils.lerp(amount, prev.source.eval(x, y, z), current.source.eval(x, y, z)); + } + // check if we are in the ease-out region and have a next function. + else if (next != null && mappingValue > end - current.easeOut) { + // ...interpolate with a quintic S-curve. + final double ratio = ((mappingValue - end) / current.easeOut) + 1; + final double amount = MathUtils.scurve5(ratio); + return MathUtils.lerp(amount, current.source.eval(x, y, z), next.source.eval(x, y, z)); + } + // else we are in the no-ease region (or did not have a next/prev to blend with)... + else { + // ...so just return source func + return current.source.eval(x, y, z); + } + } + } + // outside of range... just return an eval of the very last function + return current.source.eval(x, y, z); + } + + public Function3D getMapFunction() { + return _mapFunction; + } + + public void setMapFunction(final Function3D mapFunction) { + _mapFunction = mapFunction; + } + + public double getDomainStart() { + return _domainStart; + } + + public void setDomainStart(final double start) { + _domainStart = start; + } + + public double getDomainEnd() { + return _domainEnd; + } + + public void setDomainEnd(final double end) { + _domainEnd = end; + } + + /** + * Add a new source function to the end of our set of ranged functions. Our place in the range is based on the place + * of the previous source function and the offsetStart provided. + * + * @param source + * the new function to add + * @param offsetStart + * our offset from the previous entry + * @param easeIn + * a "fade in" range between the previous function and this function, starting at offsetState. Over this + * range we'll lerp between the two functions. + * @param easeOut + * a "fade out" range between this function and the next function, starting at the next function's + * offsetStart - easeOut. Over this range we'll lerp between the two functions. + */ + public void addFunction(final Function3D source, final double offsetStart, final double easeIn, final double easeOut) { + final Entry e = new Entry(); + e.source = source; + e.offsetStart = offsetStart; + e.easeIn = easeIn; + e.easeOut = easeOut; + _entries.add(e); + } + + public void removeFunction(final int index) { + _entries.remove(index); + } + + public void clearFunctions() { + _entries.clear(); + } + + private static class Entry { + double offsetStart; + double easeIn, easeOut; + Function3D source; + } + +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/MeshFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MeshFunction3D.java new file mode 100644 index 0000000..c314c4c --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/MeshFunction3D.java @@ -0,0 +1,45 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.functions;
+
+/**
+ * Function which creates a diagonal grid of rounded 'holes'. The term "Mesh" is used here in its common form, and does
+ * not refer to 3D geometry... the resulting pattern simply resembles a screen or sieve.
+ */
+public class MeshFunction3D implements Function3D {
+
+ private final double _lineSize;
+
+ /**
+ * Create a MeshFunction3D with a default lineSize of 0.5.
+ */
+ public MeshFunction3D() {
+ this(0.5);
+ }
+
+ /**
+ * Create a MeshFunction3D with the specified lineSize. Lower lineSize values will result in thinner lines.
+ *
+ * @param lineSize
+ * The line size, which should be greater than zero.
+ */
+ public MeshFunction3D(final double lineSize) {
+ _lineSize = lineSize;
+ }
+
+ /**
+ * Evaluate the function.
+ */
+ public double eval(final double x, final double y, final double z) {
+ final double value = (Math.sin(x) + Math.sin(y) + Math.sin(z)) / _lineSize;
+ return ((value * value) * 2.0) - 1.0;
+ }
+}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/RidgeFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/RidgeFunction3D.java new file mode 100644 index 0000000..669c09b --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/RidgeFunction3D.java @@ -0,0 +1,145 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import com.ardor3d.math.MathUtils; + +/** + * Based on Multifractal code originally written by F. Kenton "Doc Mojo" Musgrave, 1998. Modified by jas for use with + * libnoise, then modified for use in Ardor3D in 2009. + */ +public class RidgeFunction3D implements Function3D { + + public static final int MAX_OCTAVES = 32; + + private Function3D _source; + private double _octaves = 6; + private double _frequency = 1; + private double _lacunarity = 2; + private double _gain = 2; + private double _offset = 1; + private double _h = 1; + private final double[] _spectralWeights = new double[MAX_OCTAVES]; + + public RidgeFunction3D() { + setSource(Functions.simplexNoise()); + updateWeights(); + } + + public RidgeFunction3D(final Function3D source, final double octaves, final double frequency, + final double lacunarity) { + setSource(source); + setOctaves(octaves); + setFrequency(frequency); + // to not trigger weight calc + _lacunarity = lacunarity; + updateWeights(); + } + + public double eval(final double x, final double y, final double z) { + double value = 0, signal = 0, weight = 1; + double dx = x * _frequency, dy = y * _frequency, dz = z * _frequency; + for (int i = 0; i < _octaves; i++) { + signal = _source.eval(dx, dy, dz); + + signal = Math.abs(signal); + signal = _offset - signal; + + // Square the signal to increase the sharpness of the ridges. + signal *= signal; + + // The weighting from the previous octave is applied to the signal. + // Larger values have higher weights, producing sharp points along the + // ridges. + signal *= weight; + + // Weight successive contributions by the previous signal. (clamp to [0, 1]) + weight = MathUtils.clamp(signal * _gain, 0, 1); + + // Add the signal to the output value. + value += signal * _spectralWeights[i]; + + // Next! + dx *= _lacunarity; + dy *= _lacunarity; + dz *= _lacunarity; + } + + return (value * 1.25) - 1.0; + } + + public Function3D getSource() { + return _source; + } + + public void setSource(final Function3D source) { + _source = source; + } + + public double getOctaves() { + return _octaves; + } + + public void setOctaves(final double octaves) { + _octaves = octaves; + } + + public double getFrequency() { + return _frequency; + } + + public void setFrequency(final double frequency) { + _frequency = frequency; + } + + public double getLacunarity() { + return _lacunarity; + } + + public void setLacunarity(final double lacunarity) { + _lacunarity = lacunarity; + updateWeights(); + } + + public double getGain() { + return _gain; + } + + public void setGain(final double gain) { + _gain = gain; + } + + public double getOffset() { + return _offset; + } + + public void setOffset(final double offset) { + _offset = offset; + } + + public double getH() { + return _h; + } + + public void setH(final double h) { + _h = h; + updateWeights(); + } + + private void updateWeights() { + double dFreq = 1; + for (int i = 0; i < MAX_OCTAVES; i++) { + // Compute weight for each frequency. + _spectralWeights[i] = Math.pow(dFreq, -_h); + dFreq *= _lacunarity; + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/SimplexNoise.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/SimplexNoise.java new file mode 100644 index 0000000..ee0ec96 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/SimplexNoise.java @@ -0,0 +1,423 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import java.util.BitSet; + +import com.ardor3d.math.MathUtils; + +/** + * Simplex noise in 2D, 3D and 4D + * <p> + * Based on the implementation of Ken Perlin's Simplex Noise done by Stefan Gustavson in 2005. See the paper at + * http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf + * </p> + */ +public class SimplexNoise { + + private static int grad3[][] = { { 1, 1, 0 }, { -1, 1, 0 }, { 1, -1, 0 }, { -1, -1, 0 }, { 1, 0, 1 }, { -1, 0, 1 }, + { 1, 0, -1 }, { -1, 0, -1 }, { 0, 1, 1 }, { 0, -1, 1 }, { 0, 1, -1 }, { 0, -1, -1 } }; + + private static int grad4[][] = { { 0, 1, 1, 1 }, { 0, 1, 1, -1 }, { 0, 1, -1, 1 }, { 0, 1, -1, -1 }, + { 0, -1, 1, 1 }, { 0, -1, 1, -1 }, { 0, -1, -1, 1 }, { 0, -1, -1, -1 }, { 1, 0, 1, 1 }, { 1, 0, 1, -1 }, + { 1, 0, -1, 1 }, { 1, 0, -1, -1 }, { -1, 0, 1, 1 }, { -1, 0, 1, -1 }, { -1, 0, -1, 1 }, { -1, 0, -1, -1 }, + { 1, 1, 0, 1 }, { 1, 1, 0, -1 }, { 1, -1, 0, 1 }, { 1, -1, 0, -1 }, { -1, 1, 0, 1 }, { -1, 1, 0, -1 }, + { -1, -1, 0, 1 }, { -1, -1, 0, -1 }, { 1, 1, 1, 0 }, { 1, 1, -1, 0 }, { 1, -1, 1, 0 }, { 1, -1, -1, 0 }, + { -1, 1, 1, 0 }, { -1, 1, -1, 0 }, { -1, -1, 1, 0 }, { -1, -1, -1, 0 } }; + + // A lookup table to traverse the simplex around a given point in 4D. + // Details can be found where this table is used, in the 4D noise method. + private static int simplex[][] = { { 0, 1, 2, 3 }, { 0, 1, 3, 2 }, { 0, 0, 0, 0 }, { 0, 2, 3, 1 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 2, 3, 0 }, { 0, 2, 1, 3 }, { 0, 0, 0, 0 }, { 0, 3, 1, 2 }, + { 0, 3, 2, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 3, 2, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 1, 2, 0, 3 }, { 0, 0, 0, 0 }, { 1, 3, 0, 2 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 2, 3, 0, 1 }, { 2, 3, 1, 0 }, { 1, 0, 2, 3 }, { 1, 0, 3, 2 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 2, 0, 3, 1 }, { 0, 0, 0, 0 }, { 2, 1, 3, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 2, 0, 1, 3 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 3, 0, 1, 2 }, + { 3, 0, 2, 1 }, { 0, 0, 0, 0 }, { 3, 1, 2, 0 }, { 2, 1, 0, 3 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, { 3, 1, 0, 2 }, { 0, 0, 0, 0 }, { 3, 2, 0, 1 }, { 3, 2, 1, 0 } }; + + private static double dot(final int g[], final double x, final double y) { + return g[0] * x + g[1] * y; + } + + private static double dot(final int g[], final double x, final double y, final double z) { + return g[0] * x + g[1] * y + g[2] * z; + } + + private static double dot(final int g[], final double x, final double y, final double z, final double w) { + return g[0] * x + g[1] * y + g[2] * z + g[3] * w; + } + + // To remove the need for index wrapping, double the permutation table length + private final int perm[] = new int[512]; + + public SimplexNoise() { + final int p[] = { 151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, + 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, + 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, + 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, + 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, + 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, + 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, + 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, + 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, + 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, + 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, + 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180 }; + + setPermutations(p); + } + + public void setPermutations(final int[] permutations) { + if (permutations.length != 256) { + throw new IllegalArgumentException( + "not enough data, permutations should contain 0 thru 255 each exactly once"); + } + + final BitSet set = new BitSet(256); + for (final int i : permutations) { + set.set(i); + } + + if (set.cardinality() != 256) { + throw new IllegalArgumentException("permutations should contain 0 thru 255 each exactly once"); + } + + resetPerm(permutations); + } + + private void resetPerm(final int[] p) { + for (int i = 0; i < 512; i++) { + perm[i] = p[i & 255]; + } + } + + // 2D simplex noise + public double noise(final double xin, final double yin) { + double n0, n1, n2; // Noise contributions from the three corners + // Skew the input space to determine which simplex cell we're in + final double F2 = 0.5 * (Math.sqrt(3.0) - 1.0); + final double s = (xin + yin) * F2; // Hairy factor for 2D + final int i = (int) MathUtils.floor(xin + s); + final int j = (int) MathUtils.floor(yin + s); + final double G2 = (3.0 - Math.sqrt(3.0)) / 6.0; + final double t = (i + j) * G2; + final double X0 = i - t; // Unskew the cell origin back to (x,y) space + final double Y0 = j - t; + final double x0 = xin - X0; // The x,y distances from the cell origin + final double y0 = yin - Y0; + // For the 2D case, the simplex shape is an equilateral triangle. + // Determine which simplex we are in. + int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords + if (x0 > y0) { + i1 = 1; + j1 = 0; + } // lower triangle, XY order: (0,0)->(1,0)->(1,1) + else { + i1 = 0; + j1 = 1; + } // upper triangle, YX order: (0,0)->(0,1)->(1,1) + // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and + // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where + // c = (3-sqrt(3))/6 + final double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords + final double y1 = y0 - j1 + G2; + final double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords + final double y2 = y0 - 1.0 + 2.0 * G2; + // Work out the hashed gradient indices of the three simplex corners + final int ii = i & 255; + final int jj = j & 255; + final int gi0 = perm[ii + perm[jj]] % 12; + final int gi1 = perm[ii + i1 + perm[jj + j1]] % 12; + final int gi2 = perm[ii + 1 + perm[jj + 1]] % 12; + // Calculate the contribution from the three corners + double t0 = 0.5 - x0 * x0 - y0 * y0; + if (t0 < 0) { + n0 = 0.0; + } else { + t0 *= t0; + n0 = t0 * t0 * dot(grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient + } + double t1 = 0.5 - x1 * x1 - y1 * y1; + if (t1 < 0) { + n1 = 0.0; + } else { + t1 *= t1; + n1 = t1 * t1 * dot(grad3[gi1], x1, y1); + } + double t2 = 0.5 - x2 * x2 - y2 * y2; + if (t2 < 0) { + n2 = 0.0; + } else { + t2 *= t2; + n2 = t2 * t2 * dot(grad3[gi2], x2, y2); + } + // Add contributions from each corner to get the final noise value. + // The result is scaled to return values in the interval [-1,1]. + return 70.0 * (n0 + n1 + n2); + } + + // 3D simplex noise + public double noise(final double xin, final double yin, final double zin) { + double n0, n1, n2, n3; // Noise contributions from the four corners + // Skew the input space to determine which simplex cell we're in + final double F3 = 1.0 / 3.0; + final double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D + final int i = (int) MathUtils.floor(xin + s); + final int j = (int) MathUtils.floor(yin + s); + final int k = (int) MathUtils.floor(zin + s); + final double G3 = 1.0 / 6.0; // Very nice and simple unskew factor, too + final double t = (i + j + k) * G3; + final double X0 = i - t; // Unskew the cell origin back to (x,y,z) space + final double Y0 = j - t; + final double Z0 = k - t; + final double x0 = xin - X0; // The x,y,z distances from the cell origin + final double y0 = yin - Y0; + final double z0 = zin - Z0; + // For the 3D case, the simplex shape is a slightly irregular tetrahedron. + // Determine which simplex we are in. + int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords + int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords + if (x0 >= y0) { + if (y0 >= z0) { + i1 = 1; + j1 = 0; + k1 = 0; + i2 = 1; + j2 = 1; + k2 = 0; + } // X Y Z order + else if (x0 >= z0) { + i1 = 1; + j1 = 0; + k1 = 0; + i2 = 1; + j2 = 0; + k2 = 1; + } // X Z Y order + else { + i1 = 0; + j1 = 0; + k1 = 1; + i2 = 1; + j2 = 0; + k2 = 1; + } // Z X Y order + } else { // x0<y0 + if (y0 < z0) { + i1 = 0; + j1 = 0; + k1 = 1; + i2 = 0; + j2 = 1; + k2 = 1; + } // Z Y X order + else if (x0 < z0) { + i1 = 0; + j1 = 1; + k1 = 0; + i2 = 0; + j2 = 1; + k2 = 1; + } // Y Z X order + else { + i1 = 0; + j1 = 1; + k1 = 0; + i2 = 1; + j2 = 1; + k2 = 0; + } // Y X Z order + } + // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), + // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and + // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where + // c = 1/6. + final double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords + final double y1 = y0 - j1 + G3; + final double z1 = z0 - k1 + G3; + final double x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords + final double y2 = y0 - j2 + 2.0 * G3; + final double z2 = z0 - k2 + 2.0 * G3; + final double x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords + final double y3 = y0 - 1.0 + 3.0 * G3; + final double z3 = z0 - 1.0 + 3.0 * G3; + // Work out the hashed gradient indices of the four simplex corners + final int ii = i & 255; + final int jj = j & 255; + final int kk = k & 255; + final int gi0 = perm[ii + perm[jj + perm[kk]]] % 12; + final int gi1 = perm[ii + i1 + perm[jj + j1 + perm[kk + k1]]] % 12; + final int gi2 = perm[ii + i2 + perm[jj + j2 + perm[kk + k2]]] % 12; + final int gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] % 12; + // Calculate the contribution from the four corners + double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0; + if (t0 < 0) { + n0 = 0.0; + } else { + t0 *= t0; + n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0); + } + double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1; + if (t1 < 0) { + n1 = 0.0; + } else { + t1 *= t1; + n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1); + } + double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2; + if (t2 < 0) { + n2 = 0.0; + } else { + t2 *= t2; + n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2); + } + double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3; + if (t3 < 0) { + n3 = 0.0; + } else { + t3 *= t3; + n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3); + } + // Add contributions from each corner to get the final noise value. + // The result is scaled to stay just inside [-1,1] + return 32.0 * (n0 + n1 + n2 + n3); + } + + // 4D simplex noise + double noise(final double x, final double y, final double z, final double w) { + + // The skewing and unskewing factors are hairy again for the 4D case + final double F4 = (Math.sqrt(5.0) - 1.0) / 4.0; + final double G4 = (5.0 - Math.sqrt(5.0)) / 20.0; + double n0, n1, n2, n3, n4; // Noise contributions from the five corners + // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in + final double s = (x + y + z + w) * F4; // Factor for 4D skewing + final int i = (int) MathUtils.floor(x + s); + final int j = (int) MathUtils.floor(y + s); + final int k = (int) MathUtils.floor(z + s); + final int l = (int) MathUtils.floor(w + s); + final double t = (i + j + k + l) * G4; // Factor for 4D unskewing + final double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space + final double Y0 = j - t; + final double Z0 = k - t; + final double W0 = l - t; + final double x0 = x - X0; // The x,y,z,w distances from the cell origin + final double y0 = y - Y0; + final double z0 = z - Z0; + final double w0 = w - W0; + // For the 4D case, the simplex is a 4D shape I won't even try to describe. + // To find out which of the 24 possible simplices we're in, we need to + // determine the magnitude ordering of x0, y0, z0 and w0. + // The method below is a good way of finding the ordering of x,y,z,w and + // then find the correct traversal order for the simplex we’re in. + // First, six pair-wise comparisons are performed between each possible pair + // of the four coordinates, and the results are used to add up binary bits + // for an integer index. + final int c1 = (x0 > y0) ? 32 : 0; + final int c2 = (x0 > z0) ? 16 : 0; + final int c3 = (y0 > z0) ? 8 : 0; + final int c4 = (x0 > w0) ? 4 : 0; + final int c5 = (y0 > w0) ? 2 : 0; + final int c6 = (z0 > w0) ? 1 : 0; + final int c = c1 + c2 + c3 + c4 + c5 + c6; + int i1, j1, k1, l1; // The integer offsets for the second simplex corner + int i2, j2, k2, l2; // The integer offsets for the third simplex corner + int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner + // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order. + // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w + // impossible. Only the 24 indices which have non-zero entries make any sense. + // We use a thresholding to set the coordinates in turn from the largest magnitude. + // The number 3 in the "simplex" array is at the position of the largest coordinate. + i1 = simplex[c][0] >= 3 ? 1 : 0; + j1 = simplex[c][1] >= 3 ? 1 : 0; + k1 = simplex[c][2] >= 3 ? 1 : 0; + l1 = simplex[c][3] >= 3 ? 1 : 0; + // The number 2 in the "simplex" array is at the second largest coordinate. + i2 = simplex[c][0] >= 2 ? 1 : 0; + j2 = simplex[c][1] >= 2 ? 1 : 0; + k2 = simplex[c][2] >= 2 ? 1 : 0; + l2 = simplex[c][3] >= 2 ? 1 : 0; + // The number 1 in the "simplex" array is at the second smallest coordinate. + i3 = simplex[c][0] >= 1 ? 1 : 0; + j3 = simplex[c][1] >= 1 ? 1 : 0; + k3 = simplex[c][2] >= 1 ? 1 : 0; + l3 = simplex[c][3] >= 1 ? 1 : 0; + // The fifth corner has all coordinate offsets = 1, so no need to look that up. + final double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords + final double y1 = y0 - j1 + G4; + final double z1 = z0 - k1 + G4; + final double w1 = w0 - l1 + G4; + final double x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords + final double y2 = y0 - j2 + 2.0 * G4; + final double z2 = z0 - k2 + 2.0 * G4; + final double w2 = w0 - l2 + 2.0 * G4; + final double x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords + final double y3 = y0 - j3 + 3.0 * G4; + final double z3 = z0 - k3 + 3.0 * G4; + final double w3 = w0 - l3 + 3.0 * G4; + final double x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords + final double y4 = y0 - 1.0 + 4.0 * G4; + final double z4 = z0 - 1.0 + 4.0 * G4; + final double w4 = w0 - 1.0 + 4.0 * G4; + // Work out the hashed gradient indices of the five simplex corners + final int ii = i & 255; + final int jj = j & 255; + final int kk = k & 255; + final int ll = l & 255; + final int gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32; + final int gi1 = perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32; + final int gi2 = perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32; + final int gi3 = perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32; + final int gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; + // Calculate the contribution from the five corners + double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0; + if (t0 < 0) { + n0 = 0.0; + } else { + t0 *= t0; + n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0); + } + double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1; + if (t1 < 0) { + n1 = 0.0; + } else { + t1 *= t1; + n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1); + } + double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2; + if (t2 < 0) { + n2 = 0.0; + } else { + t2 *= t2; + n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2); + } + double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3; + if (t3 < 0) { + n3 = 0.0; + } else { + t3 *= t3; + n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3); + } + double t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4; + if (t4 < 0) { + n4 = 0.0; + } else { + t4 *= t4; + n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4); + } + // Sum up and scale the result to cover the range [-1,1] + return 27.0 * (n0 + n1 + n2 + n3 + n4); + } +}
\ No newline at end of file diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/TurbulenceFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/TurbulenceFunction3D.java new file mode 100644 index 0000000..be32008 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/TurbulenceFunction3D.java @@ -0,0 +1,90 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +/** + * Function that uses a fBm function to distort incoming coordinates on each of the 3 axis before feeding them to a + * source function for evaluation. The amount of distortion depends on the given power, roughness and frequency. + */ +public class TurbulenceFunction3D implements Function3D { + + private double _power; + private Function3D _source; + private final FbmFunction3D _distortModule; + + /** + * Construct a new turbulence function with the given values. + * + * @param source + * the source function to send our distorted coordinates to. + * @param power + * a scalar that controls how much the distortion is applied to the input coordinates. 0 == no + * distortion. + * @param roughness + * how "choppy" the distortion is. Lower values produce more gradual shifts in distortion whereas higher + * values produce more choppy transitions. + * @param frequency + * how rapidly the distortion value changes. + */ + public TurbulenceFunction3D(final Function3D source, final double power, final int roughness, final double frequency) { + _power = power; + _source = source; + _distortModule = new FbmFunction3D(Functions.simplexNoise(), roughness, frequency, 0.5, 2.0); + } + + public double eval(final double x, final double y, final double z) { + // tweak the incoming x, y, and z with some magic numbers to prevent singularities as integer boundaries. + final double x0 = x + .1985; + final double y0 = y + .9958; + final double z0 = z + .5284; + + final double x1 = x + .4106; + final double y1 = y + .2672; + final double z1 = z + .9529; + + final double x2 = x + .8297; + final double y2 = y + .1921; + final double z2 = z + .7123; + + // Use tweaked values to feed our distortion module. Use our power field to scale the amount of distortion and + // add it to the original values. + final double xDistort = x + (_distortModule.eval(x0, y0, z0) * _power); + final double yDistort = y + (_distortModule.eval(x1, y1, z1) * _power); + final double zDistort = z + (_distortModule.eval(x2, y2, z2) * _power); + + // Get the output value at the distorted location + return _source.eval(xDistort, yDistort, zDistort); + } + + public double getPower() { + return _power; + } + + public void setPower(final double power) { + _power = power; + } + + public Function3D getSource() { + return _source; + } + + public void setSource(final Function3D source) { + _source = source; + } + + public void setRoughness(final int roughness) { + _distortModule.setOctaves(roughness); + } + + public void setFrequency(final double frequency) { + _distortModule.setFrequency(frequency); + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/functions/VoroniFunction3D.java b/ardor3d-math/src/main/java/com/ardor3d/math/functions/VoroniFunction3D.java new file mode 100644 index 0000000..f17ba34 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/functions/VoroniFunction3D.java @@ -0,0 +1,189 @@ +/** + * Copyright (c) 2008-2012 Ardor Labs, Inc. + * + * This file is part of Ardor3D. + * + * Ardor3D is free software: you can redistribute it and/or modify it + * under the terms of its license which may be found in the accompanying + * LICENSE file or at <http://www.ardor3d.com/LICENSE>. + */ + +package com.ardor3d.math.functions; + +import java.util.HashMap; +import java.util.Map; + +import com.ardor3d.math.MathUtils; +import com.ardor3d.math.Vector3; + +/** + * Function that produces a <a href="http://en.wikipedia.org/wiki/Voronoi_diagram">Voronoi graph</a> by placing a random + * point in every 1x1x1 unit cube in space and then finding the closest of these points at each eval location. + * + */ +public class VoroniFunction3D implements Function3D { + + private static final int SEARCH_RADIUS = 2; // can miss corner cases with only a radius of 1 + + private double _frequency = 1; + private boolean _useDistance = false; + private double _displacement = 1; + private int _seed = 0; + + // A cache for cube values + private final Map<Key, Vector3> _points = new HashMap<Key, Vector3>(); + + /** + * Construct with default values. + */ + public VoroniFunction3D() {} + + /** + * Construct a new Voronoi graph function. + * + * @param frequency + * used to modulate input coordinates + * @param displacement + * use to modulate the contribution of the random points in each unit cube. + * @param useDistance + * if true, we will add the distance from the closest point to our output, giving us variation across the + * cell. + * @param seed + * the random seed value to give to our integer random function. + */ + public VoroniFunction3D(final double frequency, final double displacement, final boolean useDistance, final int seed) { + _frequency = frequency; + _displacement = displacement; + _useDistance = useDistance; + _seed = seed; + } + + public double eval(final double x, final double y, final double z) { + final double dx = x * _frequency, dy = y * _frequency, dz = z * _frequency; + + // find which integer based unit cube we're in + final int ix = (int) MathUtils.floor(dx), iy = (int) MathUtils.floor(dy), iz = (int) MathUtils.floor(dz); + + final Key k = new Key(); + final Vector3 minPoint = new Vector3(); + double nearestSq = Double.MAX_VALUE; + // Each cube has a point... Walk through all nearby cubes and see where our closest point lies. + for (int a = ix - SEARCH_RADIUS; a <= ix + SEARCH_RADIUS; a++) { + k.x = a; + for (int b = iy - SEARCH_RADIUS; b <= iy + SEARCH_RADIUS; b++) { + k.y = b; + for (int c = iz - SEARCH_RADIUS; c <= iz + SEARCH_RADIUS; c++) { + k.z = c; + Vector3 point = _points.get(k); + if (point == null) { + final double pX = a + point(a, b, c, _seed); + final double pY = b + point(a, b, c, _seed + 1); + final double pZ = c + point(a, b, c, _seed + 2); + point = new Vector3(pX, pY, pZ); + // cache for future lookups + _points.put(new Key(k), point); + } + final double xDist = point.getX() - dx; + final double yDist = point.getY() - dy; + final double zDist = point.getZ() - dz; + final double distSq = xDist * xDist + yDist * yDist + zDist * zDist; + + // check distance + if (distSq < nearestSq) { + nearestSq = distSq; + minPoint.set(point); + } + } + } + } + + double value; + if (_useDistance) { + // Determine the distance to the nearest point. + value = MathUtils.sqrt(nearestSq); + } else { + value = 0.0; + } + + // Return the calculated distance + with the displacement value applied using the value of our cube. + return value + + (_displacement * point(MathUtils.floor(minPoint.getXf()), MathUtils.floor(minPoint.getYf()), + MathUtils.floor(minPoint.getZf()), 0)); + } + + /** + * Calc the "random" point in unit cube that starts at the given coords. + */ + private double point(final int unitX, final int unitY, final int unitZ, final int seed) { + int n = (4241 * unitX + 7817 * unitY + 38261 * unitZ + 1979 * seed) & 0x7fffffff; + n = (n >> 13) ^ n; + return 1.0 - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / (double) 0x40000000; + } + + public double getFrequency() { + return _frequency; + } + + public void setFrequency(final double frequency) { + _frequency = frequency; + } + + public boolean isUseDistance() { + return _useDistance; + } + + public void setUseDistance(final boolean useDistance) { + _useDistance = useDistance; + } + + public double getDisplacement() { + return _displacement; + } + + public void setDisplacement(final double displacement) { + _displacement = displacement; + } + + public int getSeed() { + return _seed; + } + + public void setSeed(final int seed) { + _seed = seed; + } + + private static class Key { + int x, y, z; + + public Key() {} + + public Key(final Key k) { + x = k.x; + y = k.y; + z = k.z; + } + + @Override + public int hashCode() { + int result = 17; + + result += 31 * result + x; + result += 31 * result + y; + result += 31 * result + z; + + return result; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof Key)) { + return false; + } + final Key comp = (Key) o; + return x == comp.x && y == comp.y && z == comp.z; + } + } +} diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyColorRGBA.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyColorRGBA.java new file mode 100644 index 0000000..fda4c4e --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyColorRGBA.java @@ -0,0 +1,56 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.ColorRGBA;
+
+public interface ReadOnlyColorRGBA {
+
+ float getRed();
+
+ float getGreen();
+
+ float getBlue();
+
+ float getAlpha();
+
+ float getValue(int index);
+
+ float[] toArray(float[] store);
+
+ ColorRGBA clamp(ColorRGBA store);
+
+ int asIntARGB();
+
+ int asIntRGBA();
+
+ ColorRGBA add(float r, float g, float b, float a, ColorRGBA store);
+
+ ColorRGBA add(ReadOnlyColorRGBA source, ColorRGBA store);
+
+ ColorRGBA subtract(float r, float g, float b, float a, ColorRGBA store);
+
+ ColorRGBA subtract(ReadOnlyColorRGBA source, ColorRGBA store);
+
+ ColorRGBA multiply(float scalar, ColorRGBA store);
+
+ ColorRGBA multiply(ReadOnlyColorRGBA scale, ColorRGBA store);
+
+ ColorRGBA divide(float scalar, ColorRGBA store);
+
+ ColorRGBA divide(ReadOnlyColorRGBA scale, ColorRGBA store);
+
+ ColorRGBA lerp(ReadOnlyColorRGBA endColor, float scalar, ColorRGBA store);
+
+ String asHexRRGGBBAA();
+
+ ColorRGBA clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3.java new file mode 100644 index 0000000..c2bd892 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3.java @@ -0,0 +1,19 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Line3;
+
+public interface ReadOnlyLine3 extends ReadOnlyLine3Base {
+
+ Line3 clone();
+
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3Base.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3Base.java new file mode 100644 index 0000000..4a0d544 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLine3Base.java @@ -0,0 +1,23 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyLine3Base {
+
+ ReadOnlyVector3 getOrigin();
+
+ ReadOnlyVector3 getDirection();
+
+ double distanceSquared(ReadOnlyVector3 point, Vector3 store);
+
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLineSegment3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLineSegment3.java new file mode 100644 index 0000000..961e0a1 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyLineSegment3.java @@ -0,0 +1,20 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.LineSegment3;
+
+public interface ReadOnlyLineSegment3 extends ReadOnlyLine3Base {
+
+ double getExtent();
+
+ LineSegment3 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix3.java new file mode 100644 index 0000000..e000e7a --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix3.java @@ -0,0 +1,90 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+
+import com.ardor3d.math.Matrix3;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyMatrix3 {
+
+ double getValue(int row, int column);
+
+ float getValuef(int row, int column);
+
+ boolean isIdentity();
+
+ Vector3 getColumn(int index, Vector3 store);
+
+ Vector3 getRow(int index, Vector3 store);
+
+ DoubleBuffer toDoubleBuffer(DoubleBuffer store);
+
+ DoubleBuffer toDoubleBuffer(DoubleBuffer store, boolean rowMajor);
+
+ FloatBuffer toFloatBuffer(FloatBuffer store);
+
+ FloatBuffer toFloatBuffer(FloatBuffer store, boolean rowMajor);
+
+ double[] toArray(double[] store);
+
+ double[] toArray(double[] store, boolean rowMajor);
+
+ double[] toAngles(double[] store);
+
+ Matrix3 multiply(ReadOnlyMatrix3 matrix, Matrix3 store);
+
+ Vector3 applyPre(ReadOnlyVector3 vec, Vector3 store);
+
+ Vector3 applyPost(ReadOnlyVector3 vec, Vector3 store);
+
+ Matrix3 multiplyDiagonalPre(ReadOnlyVector3 vec, Matrix3 store);
+
+ Matrix3 multiplyDiagonalPost(ReadOnlyVector3 vec, Matrix3 store);
+
+ Matrix3 add(ReadOnlyMatrix3 matrix, Matrix3 store);
+
+ Matrix3 subtract(ReadOnlyMatrix3 matrix, Matrix3 store);
+
+ Matrix3 scale(ReadOnlyVector3 scale, Matrix3 store);
+
+ Matrix3 transpose(Matrix3 store);
+
+ Matrix3 invert(Matrix3 store);
+
+ Matrix3 adjugate(Matrix3 store);
+
+ double determinant();
+
+ boolean isOrthonormal();
+
+ Matrix3 clone();
+
+ double getM00();
+
+ double getM01();
+
+ double getM02();
+
+ double getM10();
+
+ double getM11();
+
+ double getM12();
+
+ double getM20();
+
+ double getM21();
+
+ double getM22();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix4.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix4.java new file mode 100644 index 0000000..860d168 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyMatrix4.java @@ -0,0 +1,105 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+
+import com.ardor3d.math.Matrix4;
+import com.ardor3d.math.Vector3;
+import com.ardor3d.math.Vector4;
+
+public interface ReadOnlyMatrix4 {
+
+ double getValue(int row, int column);
+
+ float getValuef(int row, int column);
+
+ boolean isIdentity();
+
+ Vector4 getColumn(int index, Vector4 store);
+
+ Vector4 getRow(int index, Vector4 store);
+
+ DoubleBuffer toDoubleBuffer(DoubleBuffer store);
+
+ DoubleBuffer toDoubleBuffer(DoubleBuffer store, boolean rowMajor);
+
+ FloatBuffer toFloatBuffer(FloatBuffer store);
+
+ FloatBuffer toFloatBuffer(FloatBuffer store, boolean rowMajor);
+
+ double[] toArray(double[] store);
+
+ double[] toArray(double[] store, boolean rowMajor);
+
+ Matrix4 multiply(ReadOnlyMatrix4 matrix, Matrix4 store);
+
+ Vector4 applyPre(ReadOnlyVector4 vec, Vector4 store);
+
+ Vector4 applyPost(ReadOnlyVector4 vec, Vector4 store);
+
+ Vector3 applyPostPoint(ReadOnlyVector3 point, Vector3 store);
+
+ Vector3 applyPostVector(ReadOnlyVector3 vector, Vector3 store);
+
+ Matrix4 multiplyDiagonalPre(ReadOnlyVector4 vec, Matrix4 store);
+
+ Matrix4 multiplyDiagonalPost(ReadOnlyVector4 vec, Matrix4 store);
+
+ Matrix4 add(ReadOnlyMatrix4 matrix, Matrix4 store);
+
+ Matrix4 subtract(ReadOnlyMatrix4 matrix, Matrix4 store);
+
+ Matrix4 scale(ReadOnlyVector4 scale, Matrix4 store);
+
+ Matrix4 transpose(Matrix4 store);
+
+ Matrix4 invert(Matrix4 store);
+
+ Matrix4 adjugate(Matrix4 store);
+
+ double determinant();
+
+ Matrix4 clone();
+
+ double getM00();
+
+ double getM01();
+
+ double getM02();
+
+ double getM03();
+
+ double getM10();
+
+ double getM11();
+
+ double getM12();
+
+ double getM13();
+
+ double getM20();
+
+ double getM21();
+
+ double getM22();
+
+ double getM23();
+
+ double getM30();
+
+ double getM31();
+
+ double getM32();
+
+ double getM33();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyPlane.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyPlane.java new file mode 100644 index 0000000..297fe3b --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyPlane.java @@ -0,0 +1,46 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Plane;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyPlane {
+
+ public enum Side {
+ /**
+ * On the side of the plane opposite of the plane's normal vector.
+ */
+ Inside,
+
+ /**
+ * On the same side of the plane as the plane's normal vector.
+ */
+ Outside,
+
+ /**
+ * Not on either side - in other words, on the plane itself.
+ */
+ Neither;
+ }
+
+ double getConstant();
+
+ ReadOnlyVector3 getNormal();
+
+ double pseudoDistance(ReadOnlyVector3 point);
+
+ Side whichSide(ReadOnlyVector3 point);
+
+ Vector3 reflectVector(ReadOnlyVector3 unitVector, Vector3 store);
+
+ Plane clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyQuaternion.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyQuaternion.java new file mode 100644 index 0000000..44c7897 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyQuaternion.java @@ -0,0 +1,79 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Matrix3;
+import com.ardor3d.math.Matrix4;
+import com.ardor3d.math.Quaternion;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyQuaternion {
+
+ double getX();
+
+ double getY();
+
+ double getZ();
+
+ double getW();
+
+ float getXf();
+
+ float getYf();
+
+ float getZf();
+
+ float getWf();
+
+ double[] toArray(double[] store);
+
+ double[] toEulerAngles(double[] store);
+
+ Matrix3 toRotationMatrix(Matrix3 store);
+
+ Matrix4 toRotationMatrix(Matrix4 store);
+
+ Vector3 getRotationColumn(int index, Vector3 store);
+
+ double toAngleAxis(Vector3 axisStore);
+
+ Quaternion normalize(Quaternion store);
+
+ Quaternion conjugate(Quaternion store);
+
+ Quaternion add(ReadOnlyQuaternion quat, Quaternion store);
+
+ Quaternion subtract(ReadOnlyQuaternion quat, Quaternion store);
+
+ Quaternion multiply(double scalar, Quaternion store);
+
+ Quaternion multiply(ReadOnlyQuaternion quat, Quaternion store);
+
+ Vector3 apply(ReadOnlyVector3 vec, Vector3 store);
+
+ Vector3[] toAxes(Vector3 axes[]);
+
+ Quaternion slerp(ReadOnlyQuaternion endQuat, double changeAmnt, Quaternion store);
+
+ double magnitudeSquared();
+
+ double magnitude();
+
+ double dot(double x, double y, double z, double w);
+
+ double dot(ReadOnlyQuaternion quat);
+
+ boolean isIdentity();
+
+ Quaternion clone();
+
+ boolean strictEquals(Object o);
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRay3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRay3.java new file mode 100644 index 0000000..78391cf --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRay3.java @@ -0,0 +1,37 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Ray3;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyRay3 extends ReadOnlyLine3Base {
+
+ double getDistanceToPrimitive(Vector3[] worldVertices);
+
+ boolean intersects(final Vector3[] polygonVertices, final Vector3 locationStore);
+
+ boolean intersectsTriangle(ReadOnlyVector3 pointA, ReadOnlyVector3 pointB, ReadOnlyVector3 pointC,
+ Vector3 locationStore);
+
+ boolean intersectsTrianglePlanar(ReadOnlyVector3 pointA, ReadOnlyVector3 pointB, ReadOnlyVector3 pointC,
+ Vector3 locationStore);
+
+ boolean intersectsQuad(ReadOnlyVector3 pointA, ReadOnlyVector3 pointB, ReadOnlyVector3 pointC,
+ ReadOnlyVector3 pointD, Vector3 locationStore);
+
+ boolean intersectsQuadPlanar(ReadOnlyVector3 pointA, ReadOnlyVector3 pointB, ReadOnlyVector3 pointC,
+ ReadOnlyVector3 pointD, Vector3 locationStore);
+
+ boolean intersectsPlane(ReadOnlyPlane plane, Vector3 locationStore);
+
+ Ray3 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle2.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle2.java new file mode 100644 index 0000000..1ef21f2 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle2.java @@ -0,0 +1,41 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Rectangle2;
+
+public interface ReadOnlyRectangle2 {
+
+ /**
+ * @return the x coordinate of the origin of this rectangle.
+ */
+ int getX();
+
+ /**
+ * @return the y coordinate of the origin of this rectangle.
+ */
+ int getY();
+
+ /**
+ * @return the width of this rectangle.
+ */
+ int getWidth();
+
+ /**
+ * @return the height of this rectangle.
+ */
+ int getHeight();
+
+ /**
+ * @return a new instance of Rectangle2 with the same value as this object.
+ */
+ Rectangle2 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle3.java new file mode 100644 index 0000000..cc6a603 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRectangle3.java @@ -0,0 +1,27 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Rectangle3;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyRectangle3 {
+
+ ReadOnlyVector3 getA();
+
+ ReadOnlyVector3 getB();
+
+ ReadOnlyVector3 getC();
+
+ Vector3 random(Vector3 result);
+
+ Rectangle3 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRing.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRing.java new file mode 100644 index 0000000..a877fd1 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyRing.java @@ -0,0 +1,29 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Ring;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyRing {
+
+ ReadOnlyVector3 getCenter();
+
+ ReadOnlyVector3 getUp();
+
+ double getInnerRadius();
+
+ double getOuterRadius();
+
+ Vector3 random(Vector3 store);
+
+ Ring clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTransform.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTransform.java new file mode 100644 index 0000000..eb8a922 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTransform.java @@ -0,0 +1,78 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+
+import com.ardor3d.math.Matrix4;
+import com.ardor3d.math.Transform;
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyTransform {
+ ReadOnlyMatrix3 getMatrix();
+
+ ReadOnlyVector3 getTranslation();
+
+ ReadOnlyVector3 getScale();
+
+ boolean isIdentity();
+
+ boolean isRotationMatrix();
+
+ boolean isUniformScale();
+
+ Vector3 applyForward(Vector3 point);
+
+ Vector3 applyForward(ReadOnlyVector3 point, Vector3 store);
+
+ Vector3 applyInverse(Vector3 point);
+
+ Vector3 applyInverse(ReadOnlyVector3 point, Vector3 store);
+
+ Vector3 applyForwardVector(Vector3 vector);
+
+ Vector3 applyForwardVector(ReadOnlyVector3 vector, Vector3 store);
+
+ Vector3 applyInverseVector(Vector3 vector);
+
+ Vector3 applyInverseVector(ReadOnlyVector3 vector, Vector3 store);
+
+ Transform multiply(ReadOnlyTransform transformBy, Transform store);
+
+ Transform invert(Transform store);
+
+ Matrix4 getHomogeneousMatrix(Matrix4 store);
+
+ /**
+ * Populates an nio double buffer with data from this transform to use as a model view matrix in OpenGL. This is
+ * done as efficiently as possible, not touching positions 3, 7, 11 and 15.
+ *
+ * @param store
+ * double buffer to store in. Assumes a size of 16 and that position 3, 7 and 11 are already set as 0.0
+ * and 15 is already 1.0.
+ */
+ void getGLApplyMatrix(DoubleBuffer store);
+
+ /**
+ * Populates an nio float buffer with data from this transform to use as a model view matrix in OpenGL. This is done
+ * as efficiently as possible, not touching positions 3, 7, 11 and 15.
+ *
+ * @param store
+ * float buffer to store in. Assumes a size of 16 and that position 3, 7 and 11 are already set as 0.0f
+ * and 15 is already 1.0f.
+ */
+ void getGLApplyMatrix(FloatBuffer store);
+
+ Transform clone();
+
+ boolean strictEquals(Object o);
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTriangle.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTriangle.java new file mode 100644 index 0000000..0ca359e --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyTriangle.java @@ -0,0 +1,31 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Triangle;
+
+public interface ReadOnlyTriangle {
+ int getIndex();
+
+ ReadOnlyVector3 get(int index);
+
+ ReadOnlyVector3 getA();
+
+ ReadOnlyVector3 getB();
+
+ ReadOnlyVector3 getC();
+
+ ReadOnlyVector3 getNormal();
+
+ ReadOnlyVector3 getCenter();
+
+ Triangle clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector2.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector2.java new file mode 100644 index 0000000..51e3c34 --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector2.java @@ -0,0 +1,82 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Vector2;
+
+public interface ReadOnlyVector2 {
+
+ double getX();
+
+ double getY();
+
+ float getXf();
+
+ float getYf();
+
+ double getValue(int index);
+
+ double[] toArray(double[] store);
+
+ Vector2 add(double x, double y, Vector2 store);
+
+ Vector2 add(ReadOnlyVector2 source, Vector2 store);
+
+ Vector2 subtract(double x, double y, Vector2 store);
+
+ Vector2 subtract(ReadOnlyVector2 source, Vector2 store);
+
+ Vector2 multiply(double scalar, Vector2 store);
+
+ Vector2 multiply(ReadOnlyVector2 scale, Vector2 store);
+
+ Vector2 multiply(double x, double y, Vector2 store);
+
+ Vector2 divide(double scalar, Vector2 store);
+
+ Vector2 divide(ReadOnlyVector2 scale, Vector2 store);
+
+ Vector2 divide(double x, double y, Vector2 store);
+
+ Vector2 scaleAdd(double scale, ReadOnlyVector2 add, Vector2 store);
+
+ Vector2 negate(Vector2 store);
+
+ Vector2 normalize(Vector2 store);
+
+ Vector2 rotateAroundOrigin(double angle, boolean clockwise, Vector2 store);
+
+ Vector2 lerp(ReadOnlyVector2 endVec, double scalar, Vector2 store);
+
+ double length();
+
+ double lengthSquared();
+
+ double distanceSquared(double x, double y);
+
+ double distanceSquared(ReadOnlyVector2 destination);
+
+ double distance(double x, double y);
+
+ double distance(ReadOnlyVector2 destination);
+
+ double dot(double x, double y);
+
+ double dot(ReadOnlyVector2 vec);
+
+ double getPolarAngle();
+
+ double angleBetween(ReadOnlyVector2 otherVector);
+
+ double smallestAngleBetween(ReadOnlyVector2 otherVector);
+
+ Vector2 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector3.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector3.java new file mode 100644 index 0000000..60cb0ed --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector3.java @@ -0,0 +1,84 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Vector3;
+
+public interface ReadOnlyVector3 {
+
+ double getX();
+
+ double getY();
+
+ double getZ();
+
+ float getXf();
+
+ float getYf();
+
+ float getZf();
+
+ double getValue(int index);
+
+ Vector3 add(double x, double y, double z, Vector3 store);
+
+ Vector3 add(ReadOnlyVector3 source, Vector3 store);
+
+ Vector3 subtract(double x, double y, double z, Vector3 store);
+
+ Vector3 subtract(ReadOnlyVector3 source, Vector3 store);
+
+ Vector3 multiply(double scalar, Vector3 store);
+
+ Vector3 multiply(ReadOnlyVector3 scale, Vector3 store);
+
+ Vector3 multiply(double x, double y, double z, Vector3 store);
+
+ Vector3 divide(double scalar, Vector3 store);
+
+ Vector3 divide(ReadOnlyVector3 scale, Vector3 store);
+
+ Vector3 divide(double x, double y, double z, Vector3 store);
+
+ Vector3 scaleAdd(double scale, ReadOnlyVector3 add, Vector3 store);
+
+ Vector3 negate(Vector3 store);
+
+ Vector3 normalize(Vector3 store);
+
+ Vector3 lerp(ReadOnlyVector3 endVec, double scalar, Vector3 store);
+
+ double length();
+
+ double lengthSquared();
+
+ double distanceSquared(double x, double y, double z);
+
+ double distanceSquared(ReadOnlyVector3 destination);
+
+ double distance(double x, double y, double z);
+
+ double distance(ReadOnlyVector3 destination);
+
+ double dot(double x, double y, double z);
+
+ double dot(ReadOnlyVector3 vec);
+
+ Vector3 cross(double x, double y, double z, Vector3 store);
+
+ Vector3 cross(ReadOnlyVector3 vec, Vector3 store);
+
+ double smallestAngleBetween(ReadOnlyVector3 otherVector);
+
+ double[] toArray(double[] store);
+
+ Vector3 clone();
+}
diff --git a/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector4.java b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector4.java new file mode 100644 index 0000000..3d549fe --- /dev/null +++ b/ardor3d-math/src/main/java/com/ardor3d/math/type/ReadOnlyVector4.java @@ -0,0 +1,82 @@ +/**
+ * Copyright (c) 2008-2012 Ardor Labs, Inc.
+ *
+ * This file is part of Ardor3D.
+ *
+ * Ardor3D is free software: you can redistribute it and/or modify it
+ * under the terms of its license which may be found in the accompanying
+ * LICENSE file or at <http://www.ardor3d.com/LICENSE>.
+ */
+
+package com.ardor3d.math.type;
+
+import com.ardor3d.math.Vector4;
+
+public interface ReadOnlyVector4 {
+
+ double getX();
+
+ double getY();
+
+ double getZ();
+
+ double getW();
+
+ float getXf();
+
+ float getYf();
+
+ float getZf();
+
+ float getWf();
+
+ double getValue(int index);
+
+ Vector4 add(double x, double y, double z, double w, Vector4 store);
+
+ Vector4 add(ReadOnlyVector4 source, Vector4 store);
+
+ Vector4 subtract(double x, double y, double z, double w, Vector4 store);
+
+ Vector4 subtract(ReadOnlyVector4 source, Vector4 store);
+
+ Vector4 multiply(double scalar, Vector4 store);
+
+ Vector4 multiply(ReadOnlyVector4 scale, Vector4 store);
+
+ Vector4 multiply(double x, double y, double z, double w, Vector4 store);
+
+ Vector4 divide(double scalar, Vector4 store);
+
+ Vector4 divide(ReadOnlyVector4 scale, Vector4 store);
+
+ Vector4 divide(double x, double y, double z, double w, Vector4 store);
+
+ Vector4 scaleAdd(double scale, ReadOnlyVector4 add, Vector4 store);
+
+ Vector4 negate(Vector4 store);
+
+ Vector4 normalize(Vector4 store);
+
+ Vector4 lerp(ReadOnlyVector4 endVec, double scalar, Vector4 store);
+
+ double length();
+
+ double lengthSquared();
+
+ double distanceSquared(double x, double y, double z, double w);
+
+ double distanceSquared(ReadOnlyVector4 destination);
+
+ double distance(double x, double y, double z, double w);
+
+ double distance(ReadOnlyVector4 destination);
+
+ double dot(double x, double y, double z, double w);
+
+ double dot(ReadOnlyVector4 vec);
+
+ double[] toArray(double[] store);
+
+ Vector4 clone();
+}
|