diff options
Diffstat (limited to 'ardor3d-math/src/test')
20 files changed, 5675 insertions, 5675 deletions
diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestColorRGBA.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestColorRGBA.java index 84e2c7d..6126d67 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestColorRGBA.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestColorRGBA.java @@ -1,387 +1,387 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestColorRGBA {
-
- @Test
- public void test() {
- final ColorRGBA clr1 = new ColorRGBA();
- assertTrue(1f == clr1.getRed());
- assertTrue(1f == clr1.getGreen());
- assertTrue(1f == clr1.getBlue());
- assertTrue(1f == clr1.getAlpha());
- }
-
- @Test
- public void testGetSet() {
- final ColorRGBA clr1 = new ColorRGBA();
- clr1.setRed(0f);
- assertTrue(clr1.getRed() == 0.0f);
- clr1.setRed(Float.POSITIVE_INFINITY);
- assertTrue(clr1.getRed() == Float.POSITIVE_INFINITY);
- clr1.setRed(Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getRed() == Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getValue(0) == Float.NEGATIVE_INFINITY);
-
- clr1.setGreen(0);
- assertTrue(clr1.getGreen() == 0.0);
- clr1.setGreen(Float.POSITIVE_INFINITY);
- assertTrue(clr1.getGreen() == Float.POSITIVE_INFINITY);
- clr1.setGreen(Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getGreen() == Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getValue(1) == Float.NEGATIVE_INFINITY);
-
- clr1.setBlue(0);
- assertTrue(clr1.getBlue() == 0.0);
- clr1.setBlue(Float.POSITIVE_INFINITY);
- assertTrue(clr1.getBlue() == Float.POSITIVE_INFINITY);
- clr1.setBlue(Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getBlue() == Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getValue(2) == Float.NEGATIVE_INFINITY);
-
- clr1.setAlpha(0);
- assertTrue(clr1.getAlpha() == 0.0);
- clr1.setAlpha(Float.POSITIVE_INFINITY);
- assertTrue(clr1.getAlpha() == Float.POSITIVE_INFINITY);
- clr1.setAlpha(Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getAlpha() == Float.NEGATIVE_INFINITY);
- assertTrue(clr1.getValue(3) == Float.NEGATIVE_INFINITY);
-
- clr1.set((float) Math.PI, (float) Math.PI, (float) Math.PI, (float) Math.PI);
- assertTrue(clr1.getRed() == (float) Math.PI);
- assertTrue(clr1.getGreen() == (float) Math.PI);
- assertTrue(clr1.getBlue() == (float) Math.PI);
- assertTrue(clr1.getAlpha() == (float) Math.PI);
-
- final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.BLACK);
- clr2.set(clr1);
- assertEquals(clr1, clr2);
-
- clr1.setValue(0, 1);
- clr1.setValue(1, 1);
- clr1.setValue(2, 1);
- clr1.setValue(3, 1);
- assertEquals(ColorRGBA.WHITE, clr1);
-
- clr1.zero();
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
-
- // catch a few expected exceptions
- try {
- clr2.getValue(4);
- fail("getValue(4) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- clr2.getValue(-1);
- fail("getValue(-1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- clr2.setValue(-1, 0);
- fail("setValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- clr2.setValue(4, 0);
- fail("setValue(4, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered vec2
- assertEquals(new ColorRGBA((float) Math.PI, (float) Math.PI, (float) Math.PI, (float) Math.PI), clr2);
- }
-
- @Test
- public void testToArray() {
- final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.DARK_GRAY);
-
- final float[] farray = clr1.toArray(null);
- final float[] farray2 = clr1.toArray(new float[4]);
- assertNotNull(farray);
- assertNotNull(farray2);
- assertTrue(farray.length == 4);
- assertTrue(farray[0] == .2f);
- assertTrue(farray[1] == .2f);
- assertTrue(farray[2] == .2f);
- assertTrue(farray[3] == 1f);
-
- try {
- clr1.toArray(new float[1]);
- fail("toFloatArray(d[1]) should have thrown ArrayIndexOutOfBoundsException.");
- } catch (final ArrayIndexOutOfBoundsException e) {
- }
- }
-
- @Test
- public void testClamp() {
- final ColorRGBA clr1 = new ColorRGBA(-1, -1, -1, -1);
- final ColorRGBA clr2 = clr1.clamp(new ColorRGBA());
- final ColorRGBA clr3 = clr1.clamp(null);
- assertNotNull(clr2);
- assertNotNull(clr3);
- assertTrue(clr2.getRed() == 0);
- assertTrue(clr2.getGreen() == 0);
- assertTrue(clr2.getBlue() == 0);
- assertTrue(clr2.getAlpha() == 0);
-
- clr1.set(2, .5f, 1, 0);
- clr1.clamp(clr2);
- assertTrue(clr2.getRed() == 1);
- assertTrue(clr2.getGreen() == .5f);
- assertTrue(clr2.getBlue() == 1);
- assertTrue(clr2.getAlpha() == 0);
-
- clr1.set(2, 2, 2, 2);
- clr1.clampLocal();
- assertTrue(clr1.getRed() == 1);
- assertTrue(clr1.getGreen() == 1);
- assertTrue(clr1.getBlue() == 1);
- assertTrue(clr1.getAlpha() == 1);
-
- clr1.set(0.5f, 0.5f, 0.5f, 0.5f);
- assertEquals(clr1, clr1.clamp(null));
- }
-
- @Test
- public void testRandomColor() {
- final ColorRGBA clr1 = new ColorRGBA(0, 0, 0, 0);
- MathUtils.setRandomSeed(0);
- ColorRGBA.randomColor(clr1);
- assertEquals(new ColorRGBA(0.73096776f, 0.831441f, 0.24053639f, 1.0f), clr1);
- final ColorRGBA clr2 = ColorRGBA.randomColor(null);
- assertEquals(new ColorRGBA(0.6063452f, 0.6374174f, 0.30905056f, 1.0f), clr2);
- }
-
- @Test
- public void testIntColor() {
- assertTrue(ColorRGBA.BLACK.asIntARGB() == -16777216);
- assertTrue(ColorRGBA.BLACK.asIntRGBA() == 255);
- assertTrue(ColorRGBA.RED.asIntARGB() == -65536);
- assertTrue(ColorRGBA.RED.asIntRGBA() == -16776961);
-
- assertEquals(ColorRGBA.BLACK, new ColorRGBA().fromIntARGB(-16777216));
- assertEquals(ColorRGBA.BLACK, new ColorRGBA().fromIntRGBA(255));
- assertEquals(ColorRGBA.RED, new ColorRGBA().fromIntARGB(-65536));
- assertEquals(ColorRGBA.RED, new ColorRGBA().fromIntRGBA(-16776961));
- }
-
- @Test
- public void testHexColor() {
- assertEquals("#00000000", ColorRGBA.BLACK_NO_ALPHA.asHexRRGGBBAA());
- assertEquals("#412819ff", ColorRGBA.BROWN.asHexRRGGBBAA());
- assertEquals("#fb8200ff", ColorRGBA.ORANGE.asHexRRGGBBAA());
-
- assertEquals(ColorRGBA.BROWN, ColorRGBA.parseColor("#412819ff", new ColorRGBA()));
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, ColorRGBA.parseColor("#00", null));
- assertEquals(ColorRGBA.WHITE, ColorRGBA.parseColor("#F", null));
- assertEquals(ColorRGBA.BLACK, ColorRGBA.parseColor("#0F", null));
- assertEquals(ColorRGBA.BLUE, ColorRGBA.parseColor("#00F", null));
- assertEquals(ColorRGBA.YELLOW, ColorRGBA.parseColor("#FF0F", null));
- assertEquals(ColorRGBA.MAGENTA, ColorRGBA.parseColor("#FF00FF", null));
- assertEquals(ColorRGBA.CYAN, ColorRGBA.parseColor("#00FFFFFF", null));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testHexFail1() {
- ColorRGBA.parseColor("000", null);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testHexFail2() {
- ColorRGBA.parseColor("#000000000000000000000", null);
- }
-
- @Test
- public void testClone() {
- final ColorRGBA clr1 = new ColorRGBA();
- final ColorRGBA clr2 = clr1.clone();
- assertEquals(clr1, clr2);
- assertNotSame(clr1, clr2);
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final ColorRGBA clr1 = new ColorRGBA(1, 0, 0, 1);
- final ColorRGBA clr2 = new ColorRGBA(1, 0, 0, 1);
- final ColorRGBA clr3 = new ColorRGBA(1, 1, 1, 1);
-
- assertTrue(clr1.hashCode() == clr2.hashCode());
- assertTrue(clr1.hashCode() != clr3.hashCode());
- }
-
- @Test
- public void testAdd() {
- final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.BLACK_NO_ALPHA);
- final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.WHITE);
-
- clr1.addLocal(1, 2, 3, 4);
- assertEquals(new ColorRGBA(1, 2, 3, 4), clr1);
- clr1.addLocal(-1, -2, -3, -4);
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
-
- clr1.zero();
- clr1.addLocal(clr2);
- assertEquals(ColorRGBA.WHITE, clr1);
-
- clr1.zero();
- final ColorRGBA clr3 = clr1.add(clr2, new ColorRGBA());
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
- assertEquals(ColorRGBA.WHITE, clr3);
-
- final ColorRGBA clr4 = clr1.add(0, 0, 0, 1, null);
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
- assertEquals(ColorRGBA.BLACK, clr4);
- }
-
- @Test
- public void testSubtract() {
- final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.BLACK_NO_ALPHA);
- final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.WHITE);
-
- clr1.subtractLocal(1, 2, 3, 4);
- assertEquals(new ColorRGBA(-1, -2, -3, -4), clr1);
- clr1.subtractLocal(-1, -2, -3, -4);
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
-
- clr1.zero();
- clr1.subtractLocal(clr2);
- assertEquals(new ColorRGBA(-1, -1, -1, -1), clr1);
-
- clr1.zero();
- final ColorRGBA clr3 = clr1.subtract(clr2, new ColorRGBA());
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
- assertEquals(new ColorRGBA(-1, -1, -1, -1), clr3);
-
- final ColorRGBA clr4 = clr1.subtract(0, 0, 0, 1, null);
- assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1);
- assertEquals(new ColorRGBA(0, 0, 0, -1), clr4);
- }
-
- @Test
- public void testMultiply() {
- final ColorRGBA clr1 = new ColorRGBA(1, -1, 2, -2);
- final ColorRGBA clr2 = clr1.multiply(2.0f, null);
- final ColorRGBA clr2B = clr1.multiply(2.0f, new ColorRGBA());
- assertEquals(new ColorRGBA(2.0f, -2.0f, 4.0f, -4.0f), clr2);
- assertEquals(new ColorRGBA(2.0f, -2.0f, 4.0f, -4.0f), clr2B);
-
- clr2.multiplyLocal(0.5f);
- assertEquals(new ColorRGBA(1.0f, -1.0f, 2.0f, -2.0f), clr2);
-
- final ColorRGBA clr3 = clr1.multiply(clr2, null);
- final ColorRGBA clr3B = clr1.multiply(clr2, new ColorRGBA());
- assertEquals(new ColorRGBA(1, 1, 4, 4), clr3);
- assertEquals(new ColorRGBA(1, 1, 4, 4), clr3B);
-
- clr1.multiplyLocal(clr2);
- assertEquals(new ColorRGBA(1, 1, 4, 4), clr1);
- }
-
- @Test
- public void testDivide() {
- final ColorRGBA clr1 = new ColorRGBA(1, -1, 2, -2);
- final ColorRGBA clr2 = clr1.divide(2.0f, null);
- final ColorRGBA clr2B = clr1.divide(2.0f, new ColorRGBA());
- assertEquals(new ColorRGBA(0.5f, -0.5f, 1.0f, -1.0f), clr2);
- assertEquals(new ColorRGBA(0.5f, -0.5f, 1.0f, -1.0f), clr2B);
-
- clr2.divideLocal(0.5f);
- assertEquals(new ColorRGBA(1.0f, -1.0f, 2.0f, -2.0f), clr2);
-
- final ColorRGBA clr3 = clr1.divide(clr2, null);
- final ColorRGBA clr3B = clr1.divide(clr2, new ColorRGBA());
- assertEquals(ColorRGBA.WHITE, clr3);
- assertEquals(ColorRGBA.WHITE, clr3B);
-
- clr1.divideLocal(clr2);
- assertEquals(ColorRGBA.WHITE, clr1);
- }
-
- @Test
- public void testLerp() {
- final ColorRGBA clr1 = new ColorRGBA(8, 3, -2, 2);
- final ColorRGBA clr2 = new ColorRGBA(2, 1, 0, -2);
- assertEquals(new ColorRGBA(5, 2, -1, 0), clr1.lerp(clr2, 0.5f, null));
- assertEquals(new ColorRGBA(5, 2, -1, 0), clr1.lerp(clr2, 0.5f, new ColorRGBA()));
- assertEquals(new ColorRGBA(5, 2, -1, 0), ColorRGBA.lerp(clr1, clr2, 0.5f, null));
- assertEquals(new ColorRGBA(5, 2, -1, 0), ColorRGBA.lerp(clr1, clr2, 0.5f, new ColorRGBA()));
-
- clr1.set(14, 5, 4, 2);
- clr1.lerpLocal(clr2, 0.25f);
- assertEquals(new ColorRGBA(11, 4, 3, 1), clr1);
-
- clr1.set(15, 7, 6, 8);
- final ColorRGBA clr3 = new ColorRGBA(-1, -1, -1, -1);
- clr3.lerpLocal(clr1, clr2, 0.5f);
- assertEquals(new ColorRGBA(8.5f, 4.0f, 3.0f, 3.0f), clr3);
-
- // coverage
- assertEquals(clr1.lerp(clr1, .25f, null), clr1);
- assertEquals(clr2.lerpLocal(clr2, .25f), clr2);
- assertEquals(clr2.lerpLocal(clr2, clr2, .25f), clr2);
- assertEquals(ColorRGBA.lerp(clr1, clr1, .25f, null), clr1);
- }
-
- @Test
- public void testValid() {
- final ColorRGBA clr1 = new ColorRGBA(0, 0, 0, 0);
- final ColorRGBA clr2A = new ColorRGBA(Float.POSITIVE_INFINITY, 0, 0, 0);
- final ColorRGBA clr2B = new ColorRGBA(0, Float.NEGATIVE_INFINITY, 0, 0);
- final ColorRGBA clr2C = new ColorRGBA(0, 0, Float.POSITIVE_INFINITY, 0);
- final ColorRGBA clr2D = new ColorRGBA(0, 0, 0, Float.POSITIVE_INFINITY);
- final ColorRGBA clr3A = new ColorRGBA(Float.NaN, 0, 0, 0);
- final ColorRGBA clr3B = new ColorRGBA(0, Float.NaN, 0, 0);
- final ColorRGBA clr3C = new ColorRGBA(0, 0, Float.NaN, 0);
- final ColorRGBA clr3D = new ColorRGBA(0, 0, 0, Float.NaN);
-
- assertTrue(ColorRGBA.isValid(clr1));
- assertFalse(ColorRGBA.isValid(clr2A));
- assertFalse(ColorRGBA.isValid(clr2B));
- assertFalse(ColorRGBA.isValid(clr2C));
- assertFalse(ColorRGBA.isValid(clr2D));
- assertFalse(ColorRGBA.isValid(clr3A));
- assertFalse(ColorRGBA.isValid(clr3B));
- assertFalse(ColorRGBA.isValid(clr3C));
- assertFalse(ColorRGBA.isValid(clr3D));
-
- clr3C.zero();
- assertTrue(ColorRGBA.isValid(clr3C));
-
- assertFalse(ColorRGBA.isValid(null));
-
- // couple of equals validity tests
- assertEquals(clr1, clr1);
- assertFalse(clr1.equals(null));
- assertFalse(clr1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final ColorRGBA clr6 = ColorRGBA.fetchTempInstance();
- clr6.set(clr1);
- assertEquals(clr1, clr6);
- assertNotSame(clr1, clr6);
- ColorRGBA.releaseTempInstance(clr6);
-
- // cover more of equals
- clr1.set(0, 1, 2, 3);
- assertFalse(clr1.equals(new ColorRGBA(4, 4, 4, 4)));
- assertFalse(clr1.equals(new ColorRGBA(0, 4, 4, 4)));
- assertFalse(clr1.equals(new ColorRGBA(0, 1, 4, 4)));
- assertFalse(clr1.equals(new ColorRGBA(0, 1, 2, 4)));
- assertTrue(clr1.equals(new ColorRGBA(0, 1, 2, 3)));
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestColorRGBA { + + @Test + public void test() { + final ColorRGBA clr1 = new ColorRGBA(); + assertTrue(1f == clr1.getRed()); + assertTrue(1f == clr1.getGreen()); + assertTrue(1f == clr1.getBlue()); + assertTrue(1f == clr1.getAlpha()); + } + + @Test + public void testGetSet() { + final ColorRGBA clr1 = new ColorRGBA(); + clr1.setRed(0f); + assertTrue(clr1.getRed() == 0.0f); + clr1.setRed(Float.POSITIVE_INFINITY); + assertTrue(clr1.getRed() == Float.POSITIVE_INFINITY); + clr1.setRed(Float.NEGATIVE_INFINITY); + assertTrue(clr1.getRed() == Float.NEGATIVE_INFINITY); + assertTrue(clr1.getValue(0) == Float.NEGATIVE_INFINITY); + + clr1.setGreen(0); + assertTrue(clr1.getGreen() == 0.0); + clr1.setGreen(Float.POSITIVE_INFINITY); + assertTrue(clr1.getGreen() == Float.POSITIVE_INFINITY); + clr1.setGreen(Float.NEGATIVE_INFINITY); + assertTrue(clr1.getGreen() == Float.NEGATIVE_INFINITY); + assertTrue(clr1.getValue(1) == Float.NEGATIVE_INFINITY); + + clr1.setBlue(0); + assertTrue(clr1.getBlue() == 0.0); + clr1.setBlue(Float.POSITIVE_INFINITY); + assertTrue(clr1.getBlue() == Float.POSITIVE_INFINITY); + clr1.setBlue(Float.NEGATIVE_INFINITY); + assertTrue(clr1.getBlue() == Float.NEGATIVE_INFINITY); + assertTrue(clr1.getValue(2) == Float.NEGATIVE_INFINITY); + + clr1.setAlpha(0); + assertTrue(clr1.getAlpha() == 0.0); + clr1.setAlpha(Float.POSITIVE_INFINITY); + assertTrue(clr1.getAlpha() == Float.POSITIVE_INFINITY); + clr1.setAlpha(Float.NEGATIVE_INFINITY); + assertTrue(clr1.getAlpha() == Float.NEGATIVE_INFINITY); + assertTrue(clr1.getValue(3) == Float.NEGATIVE_INFINITY); + + clr1.set((float) Math.PI, (float) Math.PI, (float) Math.PI, (float) Math.PI); + assertTrue(clr1.getRed() == (float) Math.PI); + assertTrue(clr1.getGreen() == (float) Math.PI); + assertTrue(clr1.getBlue() == (float) Math.PI); + assertTrue(clr1.getAlpha() == (float) Math.PI); + + final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.BLACK); + clr2.set(clr1); + assertEquals(clr1, clr2); + + clr1.setValue(0, 1); + clr1.setValue(1, 1); + clr1.setValue(2, 1); + clr1.setValue(3, 1); + assertEquals(ColorRGBA.WHITE, clr1); + + clr1.zero(); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + + // catch a few expected exceptions + try { + clr2.getValue(4); + fail("getValue(4) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + clr2.getValue(-1); + fail("getValue(-1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + clr2.setValue(-1, 0); + fail("setValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + clr2.setValue(4, 0); + fail("setValue(4, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered vec2 + assertEquals(new ColorRGBA((float) Math.PI, (float) Math.PI, (float) Math.PI, (float) Math.PI), clr2); + } + + @Test + public void testToArray() { + final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.DARK_GRAY); + + final float[] farray = clr1.toArray(null); + final float[] farray2 = clr1.toArray(new float[4]); + assertNotNull(farray); + assertNotNull(farray2); + assertTrue(farray.length == 4); + assertTrue(farray[0] == .2f); + assertTrue(farray[1] == .2f); + assertTrue(farray[2] == .2f); + assertTrue(farray[3] == 1f); + + try { + clr1.toArray(new float[1]); + fail("toFloatArray(d[1]) should have thrown ArrayIndexOutOfBoundsException."); + } catch (final ArrayIndexOutOfBoundsException e) { + } + } + + @Test + public void testClamp() { + final ColorRGBA clr1 = new ColorRGBA(-1, -1, -1, -1); + final ColorRGBA clr2 = clr1.clamp(new ColorRGBA()); + final ColorRGBA clr3 = clr1.clamp(null); + assertNotNull(clr2); + assertNotNull(clr3); + assertTrue(clr2.getRed() == 0); + assertTrue(clr2.getGreen() == 0); + assertTrue(clr2.getBlue() == 0); + assertTrue(clr2.getAlpha() == 0); + + clr1.set(2, .5f, 1, 0); + clr1.clamp(clr2); + assertTrue(clr2.getRed() == 1); + assertTrue(clr2.getGreen() == .5f); + assertTrue(clr2.getBlue() == 1); + assertTrue(clr2.getAlpha() == 0); + + clr1.set(2, 2, 2, 2); + clr1.clampLocal(); + assertTrue(clr1.getRed() == 1); + assertTrue(clr1.getGreen() == 1); + assertTrue(clr1.getBlue() == 1); + assertTrue(clr1.getAlpha() == 1); + + clr1.set(0.5f, 0.5f, 0.5f, 0.5f); + assertEquals(clr1, clr1.clamp(null)); + } + + @Test + public void testRandomColor() { + final ColorRGBA clr1 = new ColorRGBA(0, 0, 0, 0); + MathUtils.setRandomSeed(0); + ColorRGBA.randomColor(clr1); + assertEquals(new ColorRGBA(0.73096776f, 0.831441f, 0.24053639f, 1.0f), clr1); + final ColorRGBA clr2 = ColorRGBA.randomColor(null); + assertEquals(new ColorRGBA(0.6063452f, 0.6374174f, 0.30905056f, 1.0f), clr2); + } + + @Test + public void testIntColor() { + assertTrue(ColorRGBA.BLACK.asIntARGB() == -16777216); + assertTrue(ColorRGBA.BLACK.asIntRGBA() == 255); + assertTrue(ColorRGBA.RED.asIntARGB() == -65536); + assertTrue(ColorRGBA.RED.asIntRGBA() == -16776961); + + assertEquals(ColorRGBA.BLACK, new ColorRGBA().fromIntARGB(-16777216)); + assertEquals(ColorRGBA.BLACK, new ColorRGBA().fromIntRGBA(255)); + assertEquals(ColorRGBA.RED, new ColorRGBA().fromIntARGB(-65536)); + assertEquals(ColorRGBA.RED, new ColorRGBA().fromIntRGBA(-16776961)); + } + + @Test + public void testHexColor() { + assertEquals("#00000000", ColorRGBA.BLACK_NO_ALPHA.asHexRRGGBBAA()); + assertEquals("#412819ff", ColorRGBA.BROWN.asHexRRGGBBAA()); + assertEquals("#fb8200ff", ColorRGBA.ORANGE.asHexRRGGBBAA()); + + assertEquals(ColorRGBA.BROWN, ColorRGBA.parseColor("#412819ff", new ColorRGBA())); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, ColorRGBA.parseColor("#00", null)); + assertEquals(ColorRGBA.WHITE, ColorRGBA.parseColor("#F", null)); + assertEquals(ColorRGBA.BLACK, ColorRGBA.parseColor("#0F", null)); + assertEquals(ColorRGBA.BLUE, ColorRGBA.parseColor("#00F", null)); + assertEquals(ColorRGBA.YELLOW, ColorRGBA.parseColor("#FF0F", null)); + assertEquals(ColorRGBA.MAGENTA, ColorRGBA.parseColor("#FF00FF", null)); + assertEquals(ColorRGBA.CYAN, ColorRGBA.parseColor("#00FFFFFF", null)); + } + + @Test(expected = IllegalArgumentException.class) + public void testHexFail1() { + ColorRGBA.parseColor("000", null); + } + + @Test(expected = IllegalArgumentException.class) + public void testHexFail2() { + ColorRGBA.parseColor("#000000000000000000000", null); + } + + @Test + public void testClone() { + final ColorRGBA clr1 = new ColorRGBA(); + final ColorRGBA clr2 = clr1.clone(); + assertEquals(clr1, clr2); + assertNotSame(clr1, clr2); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final ColorRGBA clr1 = new ColorRGBA(1, 0, 0, 1); + final ColorRGBA clr2 = new ColorRGBA(1, 0, 0, 1); + final ColorRGBA clr3 = new ColorRGBA(1, 1, 1, 1); + + assertTrue(clr1.hashCode() == clr2.hashCode()); + assertTrue(clr1.hashCode() != clr3.hashCode()); + } + + @Test + public void testAdd() { + final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.BLACK_NO_ALPHA); + final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.WHITE); + + clr1.addLocal(1, 2, 3, 4); + assertEquals(new ColorRGBA(1, 2, 3, 4), clr1); + clr1.addLocal(-1, -2, -3, -4); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + + clr1.zero(); + clr1.addLocal(clr2); + assertEquals(ColorRGBA.WHITE, clr1); + + clr1.zero(); + final ColorRGBA clr3 = clr1.add(clr2, new ColorRGBA()); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + assertEquals(ColorRGBA.WHITE, clr3); + + final ColorRGBA clr4 = clr1.add(0, 0, 0, 1, null); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + assertEquals(ColorRGBA.BLACK, clr4); + } + + @Test + public void testSubtract() { + final ColorRGBA clr1 = new ColorRGBA(ColorRGBA.BLACK_NO_ALPHA); + final ColorRGBA clr2 = new ColorRGBA(ColorRGBA.WHITE); + + clr1.subtractLocal(1, 2, 3, 4); + assertEquals(new ColorRGBA(-1, -2, -3, -4), clr1); + clr1.subtractLocal(-1, -2, -3, -4); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + + clr1.zero(); + clr1.subtractLocal(clr2); + assertEquals(new ColorRGBA(-1, -1, -1, -1), clr1); + + clr1.zero(); + final ColorRGBA clr3 = clr1.subtract(clr2, new ColorRGBA()); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + assertEquals(new ColorRGBA(-1, -1, -1, -1), clr3); + + final ColorRGBA clr4 = clr1.subtract(0, 0, 0, 1, null); + assertEquals(ColorRGBA.BLACK_NO_ALPHA, clr1); + assertEquals(new ColorRGBA(0, 0, 0, -1), clr4); + } + + @Test + public void testMultiply() { + final ColorRGBA clr1 = new ColorRGBA(1, -1, 2, -2); + final ColorRGBA clr2 = clr1.multiply(2.0f, null); + final ColorRGBA clr2B = clr1.multiply(2.0f, new ColorRGBA()); + assertEquals(new ColorRGBA(2.0f, -2.0f, 4.0f, -4.0f), clr2); + assertEquals(new ColorRGBA(2.0f, -2.0f, 4.0f, -4.0f), clr2B); + + clr2.multiplyLocal(0.5f); + assertEquals(new ColorRGBA(1.0f, -1.0f, 2.0f, -2.0f), clr2); + + final ColorRGBA clr3 = clr1.multiply(clr2, null); + final ColorRGBA clr3B = clr1.multiply(clr2, new ColorRGBA()); + assertEquals(new ColorRGBA(1, 1, 4, 4), clr3); + assertEquals(new ColorRGBA(1, 1, 4, 4), clr3B); + + clr1.multiplyLocal(clr2); + assertEquals(new ColorRGBA(1, 1, 4, 4), clr1); + } + + @Test + public void testDivide() { + final ColorRGBA clr1 = new ColorRGBA(1, -1, 2, -2); + final ColorRGBA clr2 = clr1.divide(2.0f, null); + final ColorRGBA clr2B = clr1.divide(2.0f, new ColorRGBA()); + assertEquals(new ColorRGBA(0.5f, -0.5f, 1.0f, -1.0f), clr2); + assertEquals(new ColorRGBA(0.5f, -0.5f, 1.0f, -1.0f), clr2B); + + clr2.divideLocal(0.5f); + assertEquals(new ColorRGBA(1.0f, -1.0f, 2.0f, -2.0f), clr2); + + final ColorRGBA clr3 = clr1.divide(clr2, null); + final ColorRGBA clr3B = clr1.divide(clr2, new ColorRGBA()); + assertEquals(ColorRGBA.WHITE, clr3); + assertEquals(ColorRGBA.WHITE, clr3B); + + clr1.divideLocal(clr2); + assertEquals(ColorRGBA.WHITE, clr1); + } + + @Test + public void testLerp() { + final ColorRGBA clr1 = new ColorRGBA(8, 3, -2, 2); + final ColorRGBA clr2 = new ColorRGBA(2, 1, 0, -2); + assertEquals(new ColorRGBA(5, 2, -1, 0), clr1.lerp(clr2, 0.5f, null)); + assertEquals(new ColorRGBA(5, 2, -1, 0), clr1.lerp(clr2, 0.5f, new ColorRGBA())); + assertEquals(new ColorRGBA(5, 2, -1, 0), ColorRGBA.lerp(clr1, clr2, 0.5f, null)); + assertEquals(new ColorRGBA(5, 2, -1, 0), ColorRGBA.lerp(clr1, clr2, 0.5f, new ColorRGBA())); + + clr1.set(14, 5, 4, 2); + clr1.lerpLocal(clr2, 0.25f); + assertEquals(new ColorRGBA(11, 4, 3, 1), clr1); + + clr1.set(15, 7, 6, 8); + final ColorRGBA clr3 = new ColorRGBA(-1, -1, -1, -1); + clr3.lerpLocal(clr1, clr2, 0.5f); + assertEquals(new ColorRGBA(8.5f, 4.0f, 3.0f, 3.0f), clr3); + + // coverage + assertEquals(clr1.lerp(clr1, .25f, null), clr1); + assertEquals(clr2.lerpLocal(clr2, .25f), clr2); + assertEquals(clr2.lerpLocal(clr2, clr2, .25f), clr2); + assertEquals(ColorRGBA.lerp(clr1, clr1, .25f, null), clr1); + } + + @Test + public void testValid() { + final ColorRGBA clr1 = new ColorRGBA(0, 0, 0, 0); + final ColorRGBA clr2A = new ColorRGBA(Float.POSITIVE_INFINITY, 0, 0, 0); + final ColorRGBA clr2B = new ColorRGBA(0, Float.NEGATIVE_INFINITY, 0, 0); + final ColorRGBA clr2C = new ColorRGBA(0, 0, Float.POSITIVE_INFINITY, 0); + final ColorRGBA clr2D = new ColorRGBA(0, 0, 0, Float.POSITIVE_INFINITY); + final ColorRGBA clr3A = new ColorRGBA(Float.NaN, 0, 0, 0); + final ColorRGBA clr3B = new ColorRGBA(0, Float.NaN, 0, 0); + final ColorRGBA clr3C = new ColorRGBA(0, 0, Float.NaN, 0); + final ColorRGBA clr3D = new ColorRGBA(0, 0, 0, Float.NaN); + + assertTrue(ColorRGBA.isValid(clr1)); + assertFalse(ColorRGBA.isValid(clr2A)); + assertFalse(ColorRGBA.isValid(clr2B)); + assertFalse(ColorRGBA.isValid(clr2C)); + assertFalse(ColorRGBA.isValid(clr2D)); + assertFalse(ColorRGBA.isValid(clr3A)); + assertFalse(ColorRGBA.isValid(clr3B)); + assertFalse(ColorRGBA.isValid(clr3C)); + assertFalse(ColorRGBA.isValid(clr3D)); + + clr3C.zero(); + assertTrue(ColorRGBA.isValid(clr3C)); + + assertFalse(ColorRGBA.isValid(null)); + + // couple of equals validity tests + assertEquals(clr1, clr1); + assertFalse(clr1.equals(null)); + assertFalse(clr1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final ColorRGBA clr6 = ColorRGBA.fetchTempInstance(); + clr6.set(clr1); + assertEquals(clr1, clr6); + assertNotSame(clr1, clr6); + ColorRGBA.releaseTempInstance(clr6); + + // cover more of equals + clr1.set(0, 1, 2, 3); + assertFalse(clr1.equals(new ColorRGBA(4, 4, 4, 4))); + assertFalse(clr1.equals(new ColorRGBA(0, 4, 4, 4))); + assertFalse(clr1.equals(new ColorRGBA(0, 1, 4, 4))); + assertFalse(clr1.equals(new ColorRGBA(0, 1, 2, 4))); + assertTrue(clr1.equals(new ColorRGBA(0, 1, 2, 3))); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestFastMath.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestFastMath.java index 93c4bc1..37cde8b 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestFastMath.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestFastMath.java @@ -1,71 +1,71 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestFastMath {
-
- @Test
- public void testSin() {
- final double angle = MathUtils.DEG_TO_RAD * 45;
- assertTrue(Math.abs(FastMath.sin(angle) - Math.sin(angle)) <= FastMath.EPSILON_SIN);
- }
-
- @Test
- public void testCos() {
- double angle = MathUtils.DEG_TO_RAD * 45;
- assertTrue(Math.abs(FastMath.cos(angle) - Math.cos(angle)) <= FastMath.EPSILON_COS);
- angle = MathUtils.DEG_TO_RAD * 135;
- assertTrue(Math.abs(FastMath.cos(angle) - Math.cos(angle)) <= FastMath.EPSILON_COS);
- }
-
- @Test
- public void testTan() {
- final double angle = MathUtils.DEG_TO_RAD * 45;
- assertTrue(Math.abs(FastMath.tan(angle) - Math.tan(angle)) <= FastMath.EPSILON_SIN2COS2);
- }
-
- @Test
- public void testAsin() {
- final double val = 0.5;
- assertTrue(Math.abs(FastMath.asin(val) - Math.asin(val)) <= FastMath.EPSILON_ASIN);
- }
-
- @Test
- public void testAcos() {
- final double val = 0.5;
- assertTrue(Math.abs(FastMath.acos(val) - Math.acos(val)) <= FastMath.EPSILON_ACOS);
- }
-
- @Test
- public void testAtan() {
- double val = 1;
- assertTrue(Math.abs(FastMath.atan(val) - Math.atan(val)) <= FastMath.EPSILON_ATAN);
- val = 0.5;
- assertTrue(Math.abs(FastMath.atan(val) - Math.atan(val)) <= FastMath.EPSILON_ATAN);
- }
-
- @Test
- public void testInverseSqrt() {
- final double val = 173;
- assertTrue(Math.abs(FastMath.inverseSqrt(val) - 1.0 / Math.sqrt(val)) <= FastMath.EPSILON_SQRT);
- }
-
- @Test
- public void testSqrt() {
- final double val = 173;
- assertTrue(Math.abs(FastMath.sqrt(val) - Math.sqrt(val)) <= FastMath.EPSILON_SQRT);
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestFastMath { + + @Test + public void testSin() { + final double angle = MathUtils.DEG_TO_RAD * 45; + assertTrue(Math.abs(FastMath.sin(angle) - Math.sin(angle)) <= FastMath.EPSILON_SIN); + } + + @Test + public void testCos() { + double angle = MathUtils.DEG_TO_RAD * 45; + assertTrue(Math.abs(FastMath.cos(angle) - Math.cos(angle)) <= FastMath.EPSILON_COS); + angle = MathUtils.DEG_TO_RAD * 135; + assertTrue(Math.abs(FastMath.cos(angle) - Math.cos(angle)) <= FastMath.EPSILON_COS); + } + + @Test + public void testTan() { + final double angle = MathUtils.DEG_TO_RAD * 45; + assertTrue(Math.abs(FastMath.tan(angle) - Math.tan(angle)) <= FastMath.EPSILON_SIN2COS2); + } + + @Test + public void testAsin() { + final double val = 0.5; + assertTrue(Math.abs(FastMath.asin(val) - Math.asin(val)) <= FastMath.EPSILON_ASIN); + } + + @Test + public void testAcos() { + final double val = 0.5; + assertTrue(Math.abs(FastMath.acos(val) - Math.acos(val)) <= FastMath.EPSILON_ACOS); + } + + @Test + public void testAtan() { + double val = 1; + assertTrue(Math.abs(FastMath.atan(val) - Math.atan(val)) <= FastMath.EPSILON_ATAN); + val = 0.5; + assertTrue(Math.abs(FastMath.atan(val) - Math.atan(val)) <= FastMath.EPSILON_ATAN); + } + + @Test + public void testInverseSqrt() { + final double val = 173; + assertTrue(Math.abs(FastMath.inverseSqrt(val) - 1.0 / Math.sqrt(val)) <= FastMath.EPSILON_SQRT); + } + + @Test + public void testSqrt() { + final double val = 173; + assertTrue(Math.abs(FastMath.sqrt(val) - Math.sqrt(val)) <= FastMath.EPSILON_SQRT); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestLine3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestLine3.java index 54fb4de..3a62b6f 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestLine3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestLine3.java @@ -1,105 +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;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestLine3 {
-
- @Test
- public void testGetSet() {
- final Line3 line1 = new Line3();
- assertEquals(Vector3.ZERO, line1.getOrigin());
- assertEquals(Vector3.UNIT_Z, line1.getDirection());
-
- line1.setOrigin(Vector3.NEG_ONE);
- line1.setDirection(Vector3.UNIT_X);
- assertEquals(Vector3.NEG_ONE, line1.getOrigin());
- assertEquals(Vector3.UNIT_X, line1.getDirection());
-
- final Line3 line2 = new Line3(line1);
- assertEquals(Vector3.NEG_ONE, line2.getOrigin());
- assertEquals(Vector3.UNIT_X, line2.getDirection());
-
- final Line3 line3 = new Line3(Vector3.ONE, Vector3.UNIT_Y);
- assertEquals(Vector3.ONE, line3.getOrigin());
- assertEquals(Vector3.UNIT_Y, line3.getDirection());
- }
-
- @Test
- public void testEquals() {
- // couple of equals validity tests
- final Line3 line1 = new Line3();
- assertEquals(line1, line1);
- assertFalse(line1.equals(null));
- assertFalse(line1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Line3 line2 = Line3.fetchTempInstance();
- line2.set(line1);
- assertEquals(line1, line2);
- assertNotSame(line1, line2);
- Line3.releaseTempInstance(line2);
-
- // cover more of equals
- assertFalse(line1.equals(new Line3(Vector3.ZERO, Vector3.UNIT_X)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Line3 line1 = new Line3(Vector3.ZERO, Vector3.UNIT_Y);
- final Line3 line2 = new Line3(Vector3.ZERO, Vector3.UNIT_Y);
- final Line3 line3 = new Line3(Vector3.ZERO, Vector3.UNIT_Z);
-
- assertTrue(line1.hashCode() == line2.hashCode());
- assertTrue(line1.hashCode() != line3.hashCode());
- }
-
- @Test
- public void testClone() {
- final Line3 line1 = new Line3();
- final Line3 line2 = line1.clone();
- assertEquals(line1, line2);
- assertNotSame(line1, line2);
- }
-
- @Test
- public void testValid() {
- final Line3 line1 = new Line3();
- final Line3 line2 = new Line3(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Z);
- final Line3 line3 = new Line3(Vector3.ZERO, new Vector3(Double.NaN, 0, 0));
-
- assertTrue(Line3.isValid(line1));
- assertFalse(Line3.isValid(line2));
- assertFalse(Line3.isValid(line3));
-
- line2.setOrigin(Vector3.ZERO);
- assertTrue(Line3.isValid(line2));
-
- assertFalse(Line3.isValid(null));
- }
-
- @Test
- public void testDistance() {
- final Line3 line1 = new Line3(Vector3.ZERO, Vector3.UNIT_Z);
- final Vector3 store = new Vector3();
- assertTrue(0.0 == line1.distanceSquared(new Vector3(0, 0, 5), store));
- assertTrue(16.0 == line1.distanceSquared(new Vector3(0, 4, 1), store));
- assertEquals(Vector3.UNIT_Z, store);
- assertTrue(9.0 == line1.distanceSquared(new Vector3(0, -3, -1), store));
- assertEquals(Vector3.NEG_UNIT_Z, store);
- assertTrue(1.0 == line1.distanceSquared(Vector3.NEG_UNIT_X, null));
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestLine3 { + + @Test + public void testGetSet() { + final Line3 line1 = new Line3(); + assertEquals(Vector3.ZERO, line1.getOrigin()); + assertEquals(Vector3.UNIT_Z, line1.getDirection()); + + line1.setOrigin(Vector3.NEG_ONE); + line1.setDirection(Vector3.UNIT_X); + assertEquals(Vector3.NEG_ONE, line1.getOrigin()); + assertEquals(Vector3.UNIT_X, line1.getDirection()); + + final Line3 line2 = new Line3(line1); + assertEquals(Vector3.NEG_ONE, line2.getOrigin()); + assertEquals(Vector3.UNIT_X, line2.getDirection()); + + final Line3 line3 = new Line3(Vector3.ONE, Vector3.UNIT_Y); + assertEquals(Vector3.ONE, line3.getOrigin()); + assertEquals(Vector3.UNIT_Y, line3.getDirection()); + } + + @Test + public void testEquals() { + // couple of equals validity tests + final Line3 line1 = new Line3(); + assertEquals(line1, line1); + assertFalse(line1.equals(null)); + assertFalse(line1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Line3 line2 = Line3.fetchTempInstance(); + line2.set(line1); + assertEquals(line1, line2); + assertNotSame(line1, line2); + Line3.releaseTempInstance(line2); + + // cover more of equals + assertFalse(line1.equals(new Line3(Vector3.ZERO, Vector3.UNIT_X))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Line3 line1 = new Line3(Vector3.ZERO, Vector3.UNIT_Y); + final Line3 line2 = new Line3(Vector3.ZERO, Vector3.UNIT_Y); + final Line3 line3 = new Line3(Vector3.ZERO, Vector3.UNIT_Z); + + assertTrue(line1.hashCode() == line2.hashCode()); + assertTrue(line1.hashCode() != line3.hashCode()); + } + + @Test + public void testClone() { + final Line3 line1 = new Line3(); + final Line3 line2 = line1.clone(); + assertEquals(line1, line2); + assertNotSame(line1, line2); + } + + @Test + public void testValid() { + final Line3 line1 = new Line3(); + final Line3 line2 = new Line3(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Z); + final Line3 line3 = new Line3(Vector3.ZERO, new Vector3(Double.NaN, 0, 0)); + + assertTrue(Line3.isValid(line1)); + assertFalse(Line3.isValid(line2)); + assertFalse(Line3.isValid(line3)); + + line2.setOrigin(Vector3.ZERO); + assertTrue(Line3.isValid(line2)); + + assertFalse(Line3.isValid(null)); + } + + @Test + public void testDistance() { + final Line3 line1 = new Line3(Vector3.ZERO, Vector3.UNIT_Z); + final Vector3 store = new Vector3(); + assertTrue(0.0 == line1.distanceSquared(new Vector3(0, 0, 5), store)); + assertTrue(16.0 == line1.distanceSquared(new Vector3(0, 4, 1), store)); + assertEquals(Vector3.UNIT_Z, store); + assertTrue(9.0 == line1.distanceSquared(new Vector3(0, -3, -1), store)); + assertEquals(Vector3.NEG_UNIT_Z, store); + assertTrue(1.0 == line1.distanceSquared(Vector3.NEG_UNIT_X, null)); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestLineSegment3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestLineSegment3.java index 9b3d9c8..eb5167a 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestLineSegment3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestLineSegment3.java @@ -1,140 +1,140 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestLineSegment3 {
-
- @Test
- public void testGetSet() {
- final LineSegment3 seg1 = new LineSegment3();
- assertEquals(Vector3.ZERO, seg1.getOrigin());
- assertEquals(Vector3.UNIT_Z, seg1.getDirection());
- assertTrue(seg1.getExtent() == 0.5);
-
- seg1.setOrigin(Vector3.NEG_ONE);
- seg1.setDirection(Vector3.UNIT_X);
- seg1.setExtent(42.0);
- assertEquals(Vector3.NEG_ONE, seg1.getOrigin());
- assertEquals(Vector3.UNIT_X, seg1.getDirection());
- assertTrue(seg1.getExtent() == 42.0);
-
- final LineSegment3 seg2 = new LineSegment3(seg1);
- assertEquals(Vector3.NEG_ONE, seg2.getOrigin());
- assertEquals(Vector3.UNIT_X, seg2.getDirection());
- assertTrue(seg2.getExtent() == 42.0);
-
- final LineSegment3 seg3 = new LineSegment3(Vector3.ONE, Vector3.UNIT_Y, 2.5);
- assertEquals(Vector3.ONE, seg3.getOrigin());
- assertEquals(Vector3.UNIT_Y, seg3.getDirection());
- assertTrue(seg3.getExtent() == 2.5);
-
- final LineSegment3 seg4 = new LineSegment3(new Vector3(9, 2, 2), new Vector3(5, 2, 2));
- assertEquals(new Vector3(7, 2, 2), seg4.getOrigin());
- assertEquals(Vector3.NEG_UNIT_X, seg4.getDirection());
- assertTrue(seg4.getExtent() == 2);
-
- assertEquals(new Vector3(9, 2, 2), seg4.getNegativeEnd(null));
- assertEquals(new Vector3(1, -1.5, 1), seg3.getNegativeEnd(new Vector3()));
- assertEquals(new Vector3(5, 2, 2), seg4.getPositiveEnd(null));
- assertEquals(new Vector3(1, 3.5, 1), seg3.getPositiveEnd(new Vector3()));
-
- assertFalse(seg3.equals(new LineSegment3(Vector3.ONE, Vector3.ONE, 42)));
- assertFalse(seg3.equals(new LineSegment3(Vector3.ONE, Vector3.UNIT_Y, 42)));
- }
-
- @Test
- public void testEquals() {
- // couple of equals validity tests
- final LineSegment3 seg1 = new LineSegment3();
- assertEquals(seg1, seg1);
- assertFalse(seg1.equals(null));
- assertFalse(seg1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final LineSegment3 seg2 = LineSegment3.fetchTempInstance();
- seg2.set(seg1);
- assertEquals(seg1, seg2);
- assertNotSame(seg1, seg2);
- LineSegment3.releaseTempInstance(seg2);
-
- // cover more of equals
- assertFalse(seg1.equals(new LineSegment3(Vector3.ZERO, Vector3.UNIT_X, 2)));
- assertFalse(seg1.equals(new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, 2)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final LineSegment3 seg1 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 2);
- final LineSegment3 seg2 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 2);
- final LineSegment3 seg3 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 4);
-
- assertTrue(seg1.hashCode() == seg2.hashCode());
- assertTrue(seg1.hashCode() != seg3.hashCode());
- }
-
- @Test
- public void testClone() {
- final LineSegment3 seg1 = new LineSegment3();
- final LineSegment3 seg2 = seg1.clone();
- assertEquals(seg1, seg2);
- assertNotSame(seg1, seg2);
- }
-
- @Test
- public void testRandom() {
- MathUtils.setRandomSeed(0);
- final LineSegment3 seg1 = new LineSegment3();
- final Vector3 store = seg1.random(null);
- assertEquals(new Vector3(0.0, 0.0, 0.23096778737665702), store);
-
- seg1.random(store);
- assertEquals(new Vector3(0.0, 0.0, -0.25946358432851413), store);
- }
-
- @Test
- public void testValid() {
- final LineSegment3 seg1 = new LineSegment3();
- final LineSegment3 seg2 = new LineSegment3(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Z, 0.5);
- final LineSegment3 seg3 = new LineSegment3(Vector3.ZERO, new Vector3(Double.NaN, 0, 0), 0.5);
- final LineSegment3 seg4 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, Double.NaN);
- final LineSegment3 seg5 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, Double.POSITIVE_INFINITY);
-
- assertTrue(LineSegment3.isValid(seg1));
- assertFalse(LineSegment3.isValid(seg2));
- assertFalse(LineSegment3.isValid(seg3));
- assertFalse(LineSegment3.isValid(seg4));
- assertFalse(LineSegment3.isValid(seg5));
-
- seg5.setExtent(1);
- assertTrue(LineSegment3.isValid(seg5));
-
- assertFalse(LineSegment3.isValid(null));
- }
-
- @Test
- public void testDistance() {
- final LineSegment3 seg1 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, 1.0);
- final Vector3 store = new Vector3();
- assertTrue(16.0 == seg1.distanceSquared(new Vector3(0, 0, 5), store));
- assertEquals(Vector3.UNIT_Z, store);
- assertTrue(9.0 == seg1.distanceSquared(new Vector3(0, 0, -4), store));
- assertEquals(Vector3.NEG_UNIT_Z, store);
- assertTrue(4.0 == seg1.distanceSquared(new Vector3(2, 0, 0), store));
- assertEquals(Vector3.ZERO, store);
- assertTrue(1.0 == seg1.distanceSquared(Vector3.NEG_UNIT_X, null));
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestLineSegment3 { + + @Test + public void testGetSet() { + final LineSegment3 seg1 = new LineSegment3(); + assertEquals(Vector3.ZERO, seg1.getOrigin()); + assertEquals(Vector3.UNIT_Z, seg1.getDirection()); + assertTrue(seg1.getExtent() == 0.5); + + seg1.setOrigin(Vector3.NEG_ONE); + seg1.setDirection(Vector3.UNIT_X); + seg1.setExtent(42.0); + assertEquals(Vector3.NEG_ONE, seg1.getOrigin()); + assertEquals(Vector3.UNIT_X, seg1.getDirection()); + assertTrue(seg1.getExtent() == 42.0); + + final LineSegment3 seg2 = new LineSegment3(seg1); + assertEquals(Vector3.NEG_ONE, seg2.getOrigin()); + assertEquals(Vector3.UNIT_X, seg2.getDirection()); + assertTrue(seg2.getExtent() == 42.0); + + final LineSegment3 seg3 = new LineSegment3(Vector3.ONE, Vector3.UNIT_Y, 2.5); + assertEquals(Vector3.ONE, seg3.getOrigin()); + assertEquals(Vector3.UNIT_Y, seg3.getDirection()); + assertTrue(seg3.getExtent() == 2.5); + + final LineSegment3 seg4 = new LineSegment3(new Vector3(9, 2, 2), new Vector3(5, 2, 2)); + assertEquals(new Vector3(7, 2, 2), seg4.getOrigin()); + assertEquals(Vector3.NEG_UNIT_X, seg4.getDirection()); + assertTrue(seg4.getExtent() == 2); + + assertEquals(new Vector3(9, 2, 2), seg4.getNegativeEnd(null)); + assertEquals(new Vector3(1, -1.5, 1), seg3.getNegativeEnd(new Vector3())); + assertEquals(new Vector3(5, 2, 2), seg4.getPositiveEnd(null)); + assertEquals(new Vector3(1, 3.5, 1), seg3.getPositiveEnd(new Vector3())); + + assertFalse(seg3.equals(new LineSegment3(Vector3.ONE, Vector3.ONE, 42))); + assertFalse(seg3.equals(new LineSegment3(Vector3.ONE, Vector3.UNIT_Y, 42))); + } + + @Test + public void testEquals() { + // couple of equals validity tests + final LineSegment3 seg1 = new LineSegment3(); + assertEquals(seg1, seg1); + assertFalse(seg1.equals(null)); + assertFalse(seg1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final LineSegment3 seg2 = LineSegment3.fetchTempInstance(); + seg2.set(seg1); + assertEquals(seg1, seg2); + assertNotSame(seg1, seg2); + LineSegment3.releaseTempInstance(seg2); + + // cover more of equals + assertFalse(seg1.equals(new LineSegment3(Vector3.ZERO, Vector3.UNIT_X, 2))); + assertFalse(seg1.equals(new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, 2))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final LineSegment3 seg1 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 2); + final LineSegment3 seg2 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 2); + final LineSegment3 seg3 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Y, 4); + + assertTrue(seg1.hashCode() == seg2.hashCode()); + assertTrue(seg1.hashCode() != seg3.hashCode()); + } + + @Test + public void testClone() { + final LineSegment3 seg1 = new LineSegment3(); + final LineSegment3 seg2 = seg1.clone(); + assertEquals(seg1, seg2); + assertNotSame(seg1, seg2); + } + + @Test + public void testRandom() { + MathUtils.setRandomSeed(0); + final LineSegment3 seg1 = new LineSegment3(); + final Vector3 store = seg1.random(null); + assertEquals(new Vector3(0.0, 0.0, 0.23096778737665702), store); + + seg1.random(store); + assertEquals(new Vector3(0.0, 0.0, -0.25946358432851413), store); + } + + @Test + public void testValid() { + final LineSegment3 seg1 = new LineSegment3(); + final LineSegment3 seg2 = new LineSegment3(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Z, 0.5); + final LineSegment3 seg3 = new LineSegment3(Vector3.ZERO, new Vector3(Double.NaN, 0, 0), 0.5); + final LineSegment3 seg4 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, Double.NaN); + final LineSegment3 seg5 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, Double.POSITIVE_INFINITY); + + assertTrue(LineSegment3.isValid(seg1)); + assertFalse(LineSegment3.isValid(seg2)); + assertFalse(LineSegment3.isValid(seg3)); + assertFalse(LineSegment3.isValid(seg4)); + assertFalse(LineSegment3.isValid(seg5)); + + seg5.setExtent(1); + assertTrue(LineSegment3.isValid(seg5)); + + assertFalse(LineSegment3.isValid(null)); + } + + @Test + public void testDistance() { + final LineSegment3 seg1 = new LineSegment3(Vector3.ZERO, Vector3.UNIT_Z, 1.0); + final Vector3 store = new Vector3(); + assertTrue(16.0 == seg1.distanceSquared(new Vector3(0, 0, 5), store)); + assertEquals(Vector3.UNIT_Z, store); + assertTrue(9.0 == seg1.distanceSquared(new Vector3(0, 0, -4), store)); + assertEquals(Vector3.NEG_UNIT_Z, store); + assertTrue(4.0 == seg1.distanceSquared(new Vector3(2, 0, 0), store)); + assertEquals(Vector3.ZERO, store); + assertTrue(1.0 == seg1.distanceSquared(Vector3.NEG_UNIT_X, null)); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestMathExceptions.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestMathExceptions.java index 74b3c06..a38074c 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestMathExceptions.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestMathExceptions.java @@ -1,41 +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;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestMathExceptions {
- @Test
- public void testInvalidTransformException() {
- final InvalidTransformException ex1 = new InvalidTransformException();
- final InvalidTransformException ex2 = new InvalidTransformException("ABC");
- final Exception a = new Exception();
- final InvalidTransformException ex3 = new InvalidTransformException(a);
- final InvalidTransformException ex4 = new InvalidTransformException("DEF", a);
-
- assertNotNull(ex1);
- assertEquals("ABC", ex2.getMessage());
- assertEquals(a, ex3.getCause());
- assertEquals("DEF", ex4.getMessage());
- assertEquals(a, ex4.getCause());
- }
-
- @Test
- public void testTransformException() {
- final TransformException ex1 = new TransformException();
- final TransformException ex2 = new TransformException("ABC");
-
- assertNotNull(ex1);
- assertEquals("ABC", ex2.getMessage());
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestMathExceptions { + @Test + public void testInvalidTransformException() { + final InvalidTransformException ex1 = new InvalidTransformException(); + final InvalidTransformException ex2 = new InvalidTransformException("ABC"); + final Exception a = new Exception(); + final InvalidTransformException ex3 = new InvalidTransformException(a); + final InvalidTransformException ex4 = new InvalidTransformException("DEF", a); + + assertNotNull(ex1); + assertEquals("ABC", ex2.getMessage()); + assertEquals(a, ex3.getCause()); + assertEquals("DEF", ex4.getMessage()); + assertEquals(a, ex4.getCause()); + } + + @Test + public void testTransformException() { + final TransformException ex1 = new TransformException(); + final TransformException ex2 = new TransformException("ABC"); + + assertNotNull(ex1); + assertEquals("ABC", ex2.getMessage()); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix3.java index 6684c30..80d993c 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix3.java @@ -1,808 +1,808 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import java.nio.DoubleBuffer;
-import java.nio.FloatBuffer;
-
-import org.junit.Test;
-
-public class TestMatrix3 {
-
- @Test
- public void testGetSet() {
- final Matrix3 mat3A = new Matrix3();
- assertEquals(Matrix3.IDENTITY, mat3A);
-
- mat3A.setM00(0.0);
- mat3A.setM01(0.1);
- mat3A.setM02(0.2);
- mat3A.setM10(1.0);
- mat3A.setM11(1.1);
- mat3A.setM12(1.2);
- mat3A.setM20(2.0);
- mat3A.setM21(2.1);
- mat3A.setM22(2.2);
-
- assertTrue(0.0 == mat3A.getM00());
- assertTrue(0.1 == mat3A.getM01());
- assertTrue(0.2 == mat3A.getM02());
- assertTrue(1.0 == mat3A.getM10());
- assertTrue(1.1 == mat3A.getM11());
- assertTrue(1.2 == mat3A.getM12());
- assertTrue(2.0 == mat3A.getM20());
- assertTrue(2.1 == mat3A.getM21());
- assertTrue(2.2 == mat3A.getM22());
-
- final Matrix3 mat3B = new Matrix3(mat3A);
- assertTrue(0.0 == mat3B.getM00());
- assertTrue(0.1 == mat3B.getM01());
- assertTrue(0.2 == mat3B.getM02());
- assertTrue(1.0 == mat3B.getM10());
- assertTrue(1.1 == mat3B.getM11());
- assertTrue(1.2 == mat3B.getM12());
- assertTrue(2.0 == mat3B.getM20());
- assertTrue(2.1 == mat3B.getM21());
- assertTrue(2.2 == mat3B.getM22());
-
- final Matrix3 mat3C = new Matrix3(0.0, 0.1, 0.2, 1.0, 1.1, 1.2, 2.0, 2.1, 2.2);
- assertTrue(0.0 == mat3C.getM00());
- assertTrue(0.1 == mat3C.getM01());
- assertTrue(0.2 == mat3C.getM02());
- assertTrue(1.0 == mat3C.getM10());
- assertTrue(1.1 == mat3C.getM11());
- assertTrue(1.2 == mat3C.getM12());
- assertTrue(2.0 == mat3C.getM20());
- assertTrue(2.1 == mat3C.getM21());
- assertTrue(2.2 == mat3C.getM22());
-
- mat3C.setIdentity();
- assertTrue(mat3C.isIdentity());
-
- for (int x = 0; x < 3; x++) {
- for (int y = 0; y < 3; y++) {
- final double value = (10 * x + y) / 10.;
- mat3C.setValue(x, y, value);
- assertTrue(value == mat3C.getValue(x, y));
- }
- }
-
- mat3C.setIdentity();
- mat3C.set(0.0, 0.1, 0.2, 2.0, 2.1, 2.2, 4.0, 4.1, 4.2);
- for (int x = 0; x < 3; x++) {
- for (int y = 0; y < 3; y++) {
- assertTrue((20 * x + y) / 10.f == mat3C.getValuef(x, y));
- }
- }
-
- final Matrix3 store = new Matrix3(mat3C);
- // catch a few expected exceptions
- try {
- mat3C.getValue(-1, 0);
- fail("getValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.getValue(0, 3);
- fail("getValue(0, 3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.getValue(1, -1);
- fail("getValue(1, -1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.getValue(2, 3);
- fail("getValue(2, 3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.getValue(3, 0);
- fail("getValue(3, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
-
- try {
- mat3C.setValue(-1, 0, 0);
- fail("setValue(-1, 0, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.setValue(0, -1, 0);
- fail("setValue(0, -1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.setValue(1, 3, 0);
- fail("setValue(1, 3, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.setValue(2, -1, 0);
- fail("setValue(2, -1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3C.setValue(3, 0, 0);
- fail("setValue(3, 0, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered mat3C
- assertEquals(store, mat3C);
- }
-
- @Test
- public void testColumns() {
- final Matrix3 mat3A = new Matrix3();
- mat3A.setColumn(0, new Vector3(0, 3, 6));
- mat3A.setColumn(1, new Vector3(1, 4, 7));
- mat3A.setColumn(2, new Vector3(2, 5, 8));
- assertEquals(new Vector3(0, 3, 6), mat3A.getColumn(0, new Vector3()));
- assertEquals(new Vector3(1, 4, 7), mat3A.getColumn(1, null));
- assertEquals(new Vector3(2, 5, 8), mat3A.getColumn(2, null));
- try {
- mat3A.getColumn(-1, null);
- fail("getColumn(-1, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.getColumn(3, null);
- fail("getColumn(3, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.setColumn(-1, new Vector3());
- fail("setColumn(-1, Vector3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.setColumn(4, new Vector3());
- fail("setColumn(4, Vector3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
-
- mat3A.fromAxes(new Vector3(1, 2, 3), new Vector3(4, 5, 6), new Vector3(7, 8, 9));
- mat3A.setColumn(0, new Vector3(1, 2, 3));
- mat3A.setColumn(1, new Vector3(4, 5, 6));
- mat3A.setColumn(2, new Vector3(7, 8, 9));
- }
-
- @Test
- public void testRows() {
- final Matrix3 mat3A = new Matrix3();
- mat3A.setRow(0, new Vector3(0, 1, 2));
- mat3A.setRow(1, new Vector3(3, 4, 5));
- mat3A.setRow(2, new Vector3(6, 7, 8));
- assertEquals(new Vector3(0, 1, 2), mat3A.getRow(0, new Vector3()));
- assertEquals(new Vector3(3, 4, 5), mat3A.getRow(1, null));
- assertEquals(new Vector3(6, 7, 8), mat3A.getRow(2, null));
- try {
- mat3A.getRow(-1, null);
- fail("getRow(-1, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.getRow(3, null);
- fail("getRow(3, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.setRow(-1, new Vector3());
- fail("setRow(-1, Vector3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat3A.setRow(3, new Vector3());
- fail("setRow(3, Vector3]) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- }
-
- @Test
- public void testSetRotation() {
- final Matrix3 mat3A = new Matrix3();
- // rotate identity 90 degrees around Y
- final double a = MathUtils.HALF_PI;
- final Quaternion quaternion = new Quaternion();
- quaternion.fromAngleAxis(a, Vector3.UNIT_Y);
- mat3A.set(quaternion);
-
- assertEquals(new Matrix3( //
- Math.cos(a), 0, Math.sin(a), //
- 0, 1, 0, //
- -Math.sin(a), 0, Math.cos(a)), mat3A);
- }
-
- @Test
- public void testFromBuffer() {
- final FloatBuffer fb = FloatBuffer.allocate(9);
- fb.put(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
- fb.flip();
- // row major
- final Matrix3 mat3A = new Matrix3().fromFloatBuffer(fb);
- assertTrue(0 == mat3A.getM00());
- assertTrue(1 == mat3A.getM01());
- assertTrue(2 == mat3A.getM02());
- assertTrue(3 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(5 == mat3A.getM12());
- assertTrue(6 == mat3A.getM20());
- assertTrue(7 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
-
- // column major
- fb.rewind();
- mat3A.setIdentity();
- mat3A.fromFloatBuffer(fb, false);
- assertTrue(0 == mat3A.getM00());
- assertTrue(3 == mat3A.getM01());
- assertTrue(6 == mat3A.getM02());
- assertTrue(1 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(7 == mat3A.getM12());
- assertTrue(2 == mat3A.getM20());
- assertTrue(5 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
-
- final DoubleBuffer db = DoubleBuffer.allocate(16);
- db.put(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
- db.flip();
- // row major
- mat3A.setIdentity();
- mat3A.fromDoubleBuffer(db);
- assertTrue(0 == mat3A.getM00());
- assertTrue(1 == mat3A.getM01());
- assertTrue(2 == mat3A.getM02());
- assertTrue(3 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(5 == mat3A.getM12());
- assertTrue(6 == mat3A.getM20());
- assertTrue(7 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
-
- // column major
- db.rewind();
- mat3A.setIdentity();
- mat3A.fromDoubleBuffer(db, false);
- assertTrue(0 == mat3A.getM00());
- assertTrue(3 == mat3A.getM01());
- assertTrue(6 == mat3A.getM02());
- assertTrue(1 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(7 == mat3A.getM12());
- assertTrue(2 == mat3A.getM20());
- assertTrue(5 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
- }
-
- @Test
- public void testToBuffer() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
- final double[] colmajor = { 0, 3, 6, 1, 4, 7, 2, 5, 8 };
-
- final Matrix3 mat3A = new Matrix3().fromArray(values);
-
- // row major
- final FloatBuffer fb = mat3A.toFloatBuffer(FloatBuffer.allocate(9));
- fb.flip();
- for (int i = 0; i < 9; i++) {
- assertTrue(values[i] == fb.get());
- }
-
- // column major
- fb.rewind();
- mat3A.toFloatBuffer(fb, false);
- fb.flip();
- for (int i = 0; i < 9; i++) {
- assertTrue(colmajor[i] == fb.get());
- }
-
- // row major
- final DoubleBuffer db = mat3A.toDoubleBuffer(DoubleBuffer.allocate(9));
- db.flip();
- for (int i = 0; i < 9; i++) {
- assertTrue(values[i] == db.get());
- }
-
- // column major
- db.rewind();
- mat3A.toDoubleBuffer(db, false);
- db.flip();
- for (int i = 0; i < 9; i++) {
- assertTrue(colmajor[i] == db.get());
- }
- }
-
- @Test
- public void testFromArray() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
- final Matrix3 mat3A = new Matrix3();
-
- // row major
- mat3A.fromArray(values);
- assertTrue(0 == mat3A.getM00());
- assertTrue(1 == mat3A.getM01());
- assertTrue(2 == mat3A.getM02());
- assertTrue(3 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(5 == mat3A.getM12());
- assertTrue(6 == mat3A.getM20());
- assertTrue(7 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
-
- // column major
- mat3A.setIdentity();
- mat3A.fromArray(values, false);
- assertTrue(0 == mat3A.getM00());
- assertTrue(3 == mat3A.getM01());
- assertTrue(6 == mat3A.getM02());
- assertTrue(1 == mat3A.getM10());
- assertTrue(4 == mat3A.getM11());
- assertTrue(7 == mat3A.getM12());
- assertTrue(2 == mat3A.getM20());
- assertTrue(5 == mat3A.getM21());
- assertTrue(8 == mat3A.getM22());
- }
-
- @Test
- public void testToArray() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
- final Matrix3 mat3A = new Matrix3().fromArray(values);
-
- // row major
- final double[] dbls1 = mat3A.toArray(null);
- for (int i = 0; i < 9; i++) {
- assertTrue(values[i] == dbls1[i]);
- }
-
- // column major
- final double[] colmajor = { 0, 3, 6, 1, 4, 7, 2, 5, 8 };
- mat3A.toArray(dbls1, false);
- for (int i = 0; i < 9; i++) {
- assertTrue(colmajor[i] == dbls1[i]);
- }
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBadArray() {
- final Matrix3 mat3A = new Matrix3();
- mat3A.toArray(new double[4]);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBadAnglesArray() {
- final Matrix3 mat3A = new Matrix3();
- mat3A.toAngles(new double[2]);
- }
-
- @Test
- public void testAngleAxis() {
- final Matrix3 mat3A = new Matrix3();
- // rotate identity 90 degrees around X
- final double angle = MathUtils.HALF_PI;
- mat3A.fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X);
- assertEquals(new Matrix3( //
- 1, 0, 0, //
- 0, Math.cos(angle), -Math.sin(angle), //
- 0, Math.sin(angle), Math.cos(angle)), mat3A);
- }
-
- @Test
- public void testRotations() {
- final Vector3 rotated = new Vector3(1, 1, 1);
- final Vector3 expected = new Vector3(1, 1, 1);
-
- // rotated
- final Matrix3 mat3A = new Matrix3().fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.PI);
- mat3A.applyPost(rotated, rotated);
-
- // expected - post
- final Matrix3 worker = new Matrix3().fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X);
- worker.applyPost(expected, expected);
- worker.fromAngleAxis(MathUtils.PI, Vector3.UNIT_Z);
- worker.applyPost(expected, expected);
- worker.fromAngleAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y);
- worker.applyPost(expected, expected);
-
- // test how close it came out
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Try a new way with new angles...
- final Matrix3 mat3B = new Matrix3().fromAngles(MathUtils.QUARTER_PI, MathUtils.PI, MathUtils.HALF_PI);
- rotated.set(1, 1, 1);
- mat3B.applyPost(rotated, rotated);
-
- // expected
- expected.set(1, 1, 1);
- worker.setIdentity();
- // put together matrix, then apply to vector, so YZX
- worker.applyRotationY(MathUtils.PI);
- worker.applyRotationZ(MathUtils.HALF_PI);
- worker.applyRotationX(MathUtils.QUARTER_PI);
- worker.applyPost(expected, expected);
-
- // test how close it came out
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // test axis rotation methods against general purpose
- // X AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Y AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Z AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // test toAngles - not necessarily the same values as fromAngles, but should be same resulting Matrix.
- mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.PI);
- final double[] angles = mat3A.toAngles(null);
- worker.fromAngles(angles[0], angles[1], angles[2]);
- assertEquals(mat3A, worker);
-
- mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.HALF_PI);
- mat3A.toAngles(angles);
- worker.fromAngles(angles[0], angles[1], angles[2]);
- assertEquals(mat3A, worker);
-
- mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, -MathUtils.HALF_PI);
- mat3A.toAngles(angles);
- worker.fromAngles(angles[0], angles[1], angles[2]);
- assertEquals(mat3A, worker);
- }
-
- @Test
- public void testMultiplyDiagonal() {
- final Matrix3 mat3A = new Matrix3();
- Matrix3 result = mat3A.multiplyDiagonalPost(new Vector3(2, 4, 6), null);
- assertEquals(new Matrix3( //
- 2, 0, 0, //
- 0, 4, 0, //
- 0, 0, 6), result);
- mat3A.multiplyDiagonalPre(new Vector3(-2, -4, -6), result);
- assertEquals(new Matrix3( //
- -2, 0, 0, //
- 0, -4, 0, //
- 0, 0, -6), result);
-
- final double a = MathUtils.HALF_PI;
- mat3A.applyRotationY(a);
- mat3A.multiplyDiagonalPost(new Vector3(2, 4, 6), result);
- assertEquals(new Matrix3( //
- 2 * Math.cos(a), 4 * 0, 6 * Math.sin(a), //
- 2 * 0, 4 * 1, 6 * 0, //
- 2 * -Math.sin(a), 4 * 0, 6 * Math.cos(a)), result);
- result = mat3A.multiplyDiagonalPre(new Vector3(-2, -4, -6), null);
- assertEquals(new Matrix3( //
- -2 * Math.cos(a), -2 * 0, -2 * Math.sin(a), //
- -4 * 0, -4 * 1, -4 * 0, //
- -6 * -Math.sin(a), -6 * 0, -6 * Math.cos(a)), result);
- }
-
- @Test
- public void testMultiply() {
- final Matrix3 mat3A = new Matrix3( //
- 0.01, 0.1, 0.2, //
- 1.0, 1.1, 1.2, //
- 2.0, 2.1, 2.2);
- mat3A.multiplyLocal(2);
- assertEquals(new Matrix3( //
- 0.02, 0.2, 0.4, //
- 2.0, 2.2, 2.4, //
- 4.0, 4.2, 4.4), mat3A);
-
- final Matrix3 mat3B = new Matrix3( //
- 0.5, 1, 2, //
- 4, 5, 6, //
- 8, 9, 10);
- final Matrix3 result = mat3A.multiply(mat3B, null);
- assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 == result.getM00());
- assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 == result.getM01());
- assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 == result.getM02());
- assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 == result.getM10());
- assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 == result.getM11());
- assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 == result.getM12());
- assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 == result.getM20());
- assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 == result.getM21());
- assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 == result.getM22());
- mat3A.multiplyLocal(mat3B);
- assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 == mat3A.getM00());
- assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 == mat3A.getM01());
- assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 == mat3A.getM02());
- assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 == mat3A.getM10());
- assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 == mat3A.getM11());
- assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 == mat3A.getM12());
- assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 == mat3A.getM20());
- assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 == mat3A.getM21());
- assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 == mat3A.getM22());
- }
-
- @Test
- public void testAddSubtract() {
- final Matrix3 mat3A = new Matrix3( //
- 0.0, 0.1, 0.2, //
- 1.0, 1.1, 1.2, //
- 2.0, 2.1, 2.2);
-
- final Matrix3 result1 = mat3A.add(new Matrix3(//
- 1, 2, 3,//
- 5, 6, 7, //
- 9, 10, 11), null);
- assertEquals(new Matrix3( //
- 1.0, 2.1, 3.2, //
- 6.0, 7.1, 8.2, //
- 11.0, 12.1, 13.2), result1);
-
- final Matrix3 result2 = result1.subtract(new Matrix3(//
- 1, 2, 3, //
- 5, 6, 7, //
- 9, 10, 11), null);
- assertEquals(mat3A, result2);
- result2.addLocal(Matrix3.IDENTITY);
- assertEquals(new Matrix3( //
- 1.0, 0.1, 0.2, //
- 1.0, 2.1, 1.2, //
- 2.0, 2.1, 3.2), result2);
-
- result1.subtractLocal(Matrix3.IDENTITY);
- assertEquals(new Matrix3( //
- 0.0, 2.1, 3.2, //
- 6.0, 6.1, 8.2, //
- 11.0, 12.1, 12.2), result1);
- }
-
- @Test
- public void testScale() {
- final Matrix3 mat3A = new Matrix3( //
- 0.01, 0.1, 0.2, //
- 1.0, 1.1, 1.2, //
- 2.0, 2.1, 2.2);
- final Matrix3 result = mat3A.scale(new Vector3(-1, 2, 3), null);
- assertEquals(new Matrix3( //
- 0.01 * -1, 0.1 * 2, 0.2 * 3, //
- 1.0 * -1, 1.1 * 2, 1.2 * 3, //
- 2.0 * -1, 2.1 * 2, 2.2 * 3), result);
-
- result.scaleLocal(new Vector3(-1, 0.5, 1 / 3.));
- assertEquals(mat3A, result);
- }
-
- @Test
- public void testTranspose() {
- final Matrix3 mat3A = new Matrix3( //
- 0.01, 0.1, 0.2, //
- 1.0, 1.1, 1.2, //
- 2.0, 2.1, 2.2);
- final Matrix3 result = mat3A.transpose(null);
- assertEquals(new Matrix3( //
- 0.01, 1.0, 2.0, //
- 0.1, 1.1, 2.1, //
- 0.2, 1.2, 2.2), result);
- assertEquals(new Matrix3( //
- 0.01, 0.1, 0.2, //
- 1.0, 1.1, 1.2, //
- 2.0, 2.1, 2.2), result.transposeLocal());
- // coverage
- final Matrix3 result2 = result.transposeLocal().transpose(new Matrix3());
- assertEquals(mat3A, result2);
- }
-
- @Test
- public void testInvert() {
- final Matrix3 mat3A = new Matrix3().applyRotationX(MathUtils.QUARTER_PI);
- final Matrix3 inverted = mat3A.invert(null);
- assertEquals(Matrix3.IDENTITY, mat3A.multiply(inverted, null));
- assertEquals(mat3A, inverted.invertLocal());
- }
-
- @Test(expected = ArithmeticException.class)
- public void testBadInvert() {
- final Matrix3 mat3A = new Matrix3(0, 0, 0, 0, 0, 0, 0, 0, 0);
- mat3A.invertLocal();
- }
-
- @Test
- public void testAdjugate() {
- final double //
- a = -3, b = 2, c = -5, //
- d = -1, e = 0, f = -2, //
- g = 3, h = -4, i = 1;
-
- final Matrix3 mat3A = new Matrix3( //
- a, b, c, //
- d, e, f, //
- g, h, i);
-
- final Matrix3 testValue = new Matrix3( //
- e * i - h * f, -(b * i - h * c), b * f - e * c, //
- -(d * i - g * f), a * i - g * c, -(a * f - d * c),//
- d * h - g * e, -(a * h - g * b), a * e - d * b);
-
- assertEquals(testValue, mat3A.adjugate(null));
- assertEquals(testValue, mat3A.adjugateLocal());
- }
-
- @Test
- public void testDeterminant() {
- {
- final double //
- a = -3, b = 2, c = -5, //
- d = -1, e = 0, f = -2, //
- g = 3, h = -4, i = 1;
-
- final Matrix3 mat3A = new Matrix3( //
- a, b, c, //
- d, e, f, //
- g, h, i);
- final double determinant = a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h;
- assertTrue(determinant == mat3A.determinant());
- }
-
- {
- final double //
- a = -1, b = 2, c = -3, //
- d = 4, e = -5, f = 6, //
- g = -7, h = 8, i = -9;
-
- final Matrix3 mat3A = new Matrix3( //
- a, b, c, //
- d, e, f, //
- g, h, i);
- final double determinant = a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h;
- assertTrue(determinant == mat3A.determinant());
- }
- }
-
- @Test
- public void testClone() {
- final Matrix3 mat1 = new Matrix3();
- final Matrix3 mat2 = mat1.clone();
- assertEquals(mat1, mat2);
- assertNotSame(mat1, mat2);
- }
-
- @Test
- public void testValid() {
- final Matrix3 mat3 = new Matrix3();
- assertTrue(Matrix3.isValid(mat3));
- for (int i = 0; i < 9; i++) {
- mat3.setIdentity();
- mat3.setValue(i / 3, i % 3, Double.NaN);
- assertFalse(Matrix3.isValid(mat3));
- mat3.setIdentity();
- mat3.setValue(i / 3, i % 3, Double.POSITIVE_INFINITY);
- assertFalse(Matrix3.isValid(mat3));
- }
-
- mat3.setIdentity();
- assertTrue(Matrix3.isValid(mat3));
-
- assertFalse(Matrix3.isValid(null));
-
- // couple of equals validity tests
- assertEquals(mat3, mat3);
- assertTrue(mat3.strictEquals(mat3));
- assertFalse(mat3.equals(null));
- assertFalse(mat3.strictEquals(null));
- assertFalse(mat3.equals(new Vector2()));
- assertFalse(mat3.strictEquals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Matrix3 matTemp = Matrix3.fetchTempInstance();
- matTemp.set(mat3);
- assertEquals(mat3, matTemp);
- assertNotSame(mat3, matTemp);
- Matrix3.releaseTempInstance(matTemp);
-
- // cover more of equals
- mat3.set(0, 1, 2, 3, 4, 5, 6, 7, 8);
- final Matrix3 comp = new Matrix3(-1, -1, -1, -1, -1, -1, -1, -1, -1);
- assertFalse(mat3.equals(comp));
- assertFalse(mat3.strictEquals(comp));
- for (int i = 0; i < 8; i++) {
- comp.setValue(i / 3, i % 3, i);
- assertFalse(mat3.equals(comp));
- assertFalse(mat3.strictEquals(comp));
- }
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Matrix3 mat1 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 9);
- final Matrix3 mat2 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 9);
- final Matrix3 mat3 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 0);
-
- assertTrue(mat1.hashCode() == mat2.hashCode());
- assertTrue(mat1.hashCode() != mat3.hashCode());
- }
-
- @Test
- public void testOrthonormal() {
- final Matrix3 mat3 = new Matrix3();
- assertTrue(mat3.isOrthonormal());
- // just rotation
- mat3.applyRotationX(MathUtils.QUARTER_PI);
- assertTrue(mat3.isOrthonormal());
- // non-uniform scale
- mat3.setIdentity();
- mat3.scaleLocal(new Vector3(1, 2, 3));
- assertFalse(mat3.isOrthonormal());
- // non-uniform scale + rotation
- mat3.setIdentity();
- mat3.scaleLocal(new Vector3(1, 2, 3));
- mat3.applyRotationX(MathUtils.QUARTER_PI);
- assertFalse(mat3.isOrthonormal());
- }
-
- @Test
- public void testApplyVector3() {
- final Matrix3 mat3 = new Matrix3().applyRotationX(MathUtils.HALF_PI);
- final Vector3 vec3 = new Vector3(0, 1, 0);
- final Vector3 result = mat3.applyPost(vec3, null);
- assertTrue(Math.abs(new Vector3(0, 0, 1).distance(result)) <= MathUtils.EPSILON);
- vec3.set(0, 1, 1);
- mat3.applyPost(vec3, result);
- assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result)) <= MathUtils.EPSILON);
-
- vec3.set(0, 1, 1);
- mat3.applyPre(vec3, result);
- assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result)) <= MathUtils.EPSILON);
-
- vec3.set(1, 1, 1);
- assertTrue(Math.abs(new Vector3(1, 1, -1).distance(mat3.applyPre(vec3, null))) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testStartEnd() {
- final Matrix3 mat3 = new Matrix3();
- mat3.fromStartEndLocal(Vector3.UNIT_X, Vector3.UNIT_Y); // should be a 90 degree turn around Z
- assertEquals(new Vector3(-1, 1, 1), mat3.applyPost(new Vector3(1, 1, 1), null));
-
- // coverage
- mat3.fromStartEndLocal(new Vector3(1, 0, 0), new Vector3(1 + Double.MIN_VALUE, 0, 0));
- assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE);
- mat3.fromStartEndLocal(new Vector3(0, 1, 0), new Vector3(0, 1 + Double.MIN_VALUE, 0));
- assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE);
- mat3.fromStartEndLocal(new Vector3(0, 0, 1), new Vector3(0, 0, 1 + Double.MIN_VALUE));
- assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE);
- }
-
- @Test
- public void testLookAt() {
- final Vector3 direction = new Vector3(-1, 0, 0);
- final Matrix3 mat3 = new Matrix3().lookAt(direction, Vector3.UNIT_Y);
- assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, null));
-
- direction.set(1, 1, 1).normalizeLocal();
- mat3.lookAt(direction, Vector3.UNIT_Y);
- assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, null));
-
- direction.set(-1, 2, -1).normalizeLocal();
- mat3.lookAt(direction, Vector3.UNIT_Y);
- assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, new Vector3()));
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import org.junit.Test; + +public class TestMatrix3 { + + @Test + public void testGetSet() { + final Matrix3 mat3A = new Matrix3(); + assertEquals(Matrix3.IDENTITY, mat3A); + + mat3A.setM00(0.0); + mat3A.setM01(0.1); + mat3A.setM02(0.2); + mat3A.setM10(1.0); + mat3A.setM11(1.1); + mat3A.setM12(1.2); + mat3A.setM20(2.0); + mat3A.setM21(2.1); + mat3A.setM22(2.2); + + assertTrue(0.0 == mat3A.getM00()); + assertTrue(0.1 == mat3A.getM01()); + assertTrue(0.2 == mat3A.getM02()); + assertTrue(1.0 == mat3A.getM10()); + assertTrue(1.1 == mat3A.getM11()); + assertTrue(1.2 == mat3A.getM12()); + assertTrue(2.0 == mat3A.getM20()); + assertTrue(2.1 == mat3A.getM21()); + assertTrue(2.2 == mat3A.getM22()); + + final Matrix3 mat3B = new Matrix3(mat3A); + assertTrue(0.0 == mat3B.getM00()); + assertTrue(0.1 == mat3B.getM01()); + assertTrue(0.2 == mat3B.getM02()); + assertTrue(1.0 == mat3B.getM10()); + assertTrue(1.1 == mat3B.getM11()); + assertTrue(1.2 == mat3B.getM12()); + assertTrue(2.0 == mat3B.getM20()); + assertTrue(2.1 == mat3B.getM21()); + assertTrue(2.2 == mat3B.getM22()); + + final Matrix3 mat3C = new Matrix3(0.0, 0.1, 0.2, 1.0, 1.1, 1.2, 2.0, 2.1, 2.2); + assertTrue(0.0 == mat3C.getM00()); + assertTrue(0.1 == mat3C.getM01()); + assertTrue(0.2 == mat3C.getM02()); + assertTrue(1.0 == mat3C.getM10()); + assertTrue(1.1 == mat3C.getM11()); + assertTrue(1.2 == mat3C.getM12()); + assertTrue(2.0 == mat3C.getM20()); + assertTrue(2.1 == mat3C.getM21()); + assertTrue(2.2 == mat3C.getM22()); + + mat3C.setIdentity(); + assertTrue(mat3C.isIdentity()); + + for (int x = 0; x < 3; x++) { + for (int y = 0; y < 3; y++) { + final double value = (10 * x + y) / 10.; + mat3C.setValue(x, y, value); + assertTrue(value == mat3C.getValue(x, y)); + } + } + + mat3C.setIdentity(); + mat3C.set(0.0, 0.1, 0.2, 2.0, 2.1, 2.2, 4.0, 4.1, 4.2); + for (int x = 0; x < 3; x++) { + for (int y = 0; y < 3; y++) { + assertTrue((20 * x + y) / 10.f == mat3C.getValuef(x, y)); + } + } + + final Matrix3 store = new Matrix3(mat3C); + // catch a few expected exceptions + try { + mat3C.getValue(-1, 0); + fail("getValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.getValue(0, 3); + fail("getValue(0, 3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.getValue(1, -1); + fail("getValue(1, -1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.getValue(2, 3); + fail("getValue(2, 3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.getValue(3, 0); + fail("getValue(3, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + + try { + mat3C.setValue(-1, 0, 0); + fail("setValue(-1, 0, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.setValue(0, -1, 0); + fail("setValue(0, -1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.setValue(1, 3, 0); + fail("setValue(1, 3, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.setValue(2, -1, 0); + fail("setValue(2, -1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3C.setValue(3, 0, 0); + fail("setValue(3, 0, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered mat3C + assertEquals(store, mat3C); + } + + @Test + public void testColumns() { + final Matrix3 mat3A = new Matrix3(); + mat3A.setColumn(0, new Vector3(0, 3, 6)); + mat3A.setColumn(1, new Vector3(1, 4, 7)); + mat3A.setColumn(2, new Vector3(2, 5, 8)); + assertEquals(new Vector3(0, 3, 6), mat3A.getColumn(0, new Vector3())); + assertEquals(new Vector3(1, 4, 7), mat3A.getColumn(1, null)); + assertEquals(new Vector3(2, 5, 8), mat3A.getColumn(2, null)); + try { + mat3A.getColumn(-1, null); + fail("getColumn(-1, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.getColumn(3, null); + fail("getColumn(3, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.setColumn(-1, new Vector3()); + fail("setColumn(-1, Vector3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.setColumn(4, new Vector3()); + fail("setColumn(4, Vector3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + + mat3A.fromAxes(new Vector3(1, 2, 3), new Vector3(4, 5, 6), new Vector3(7, 8, 9)); + mat3A.setColumn(0, new Vector3(1, 2, 3)); + mat3A.setColumn(1, new Vector3(4, 5, 6)); + mat3A.setColumn(2, new Vector3(7, 8, 9)); + } + + @Test + public void testRows() { + final Matrix3 mat3A = new Matrix3(); + mat3A.setRow(0, new Vector3(0, 1, 2)); + mat3A.setRow(1, new Vector3(3, 4, 5)); + mat3A.setRow(2, new Vector3(6, 7, 8)); + assertEquals(new Vector3(0, 1, 2), mat3A.getRow(0, new Vector3())); + assertEquals(new Vector3(3, 4, 5), mat3A.getRow(1, null)); + assertEquals(new Vector3(6, 7, 8), mat3A.getRow(2, null)); + try { + mat3A.getRow(-1, null); + fail("getRow(-1, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.getRow(3, null); + fail("getRow(3, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.setRow(-1, new Vector3()); + fail("setRow(-1, Vector3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat3A.setRow(3, new Vector3()); + fail("setRow(3, Vector3]) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + } + + @Test + public void testSetRotation() { + final Matrix3 mat3A = new Matrix3(); + // rotate identity 90 degrees around Y + final double a = MathUtils.HALF_PI; + final Quaternion quaternion = new Quaternion(); + quaternion.fromAngleAxis(a, Vector3.UNIT_Y); + mat3A.set(quaternion); + + assertEquals(new Matrix3( // + Math.cos(a), 0, Math.sin(a), // + 0, 1, 0, // + -Math.sin(a), 0, Math.cos(a)), mat3A); + } + + @Test + public void testFromBuffer() { + final FloatBuffer fb = FloatBuffer.allocate(9); + fb.put(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); + fb.flip(); + // row major + final Matrix3 mat3A = new Matrix3().fromFloatBuffer(fb); + assertTrue(0 == mat3A.getM00()); + assertTrue(1 == mat3A.getM01()); + assertTrue(2 == mat3A.getM02()); + assertTrue(3 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(5 == mat3A.getM12()); + assertTrue(6 == mat3A.getM20()); + assertTrue(7 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + + // column major + fb.rewind(); + mat3A.setIdentity(); + mat3A.fromFloatBuffer(fb, false); + assertTrue(0 == mat3A.getM00()); + assertTrue(3 == mat3A.getM01()); + assertTrue(6 == mat3A.getM02()); + assertTrue(1 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(7 == mat3A.getM12()); + assertTrue(2 == mat3A.getM20()); + assertTrue(5 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + + final DoubleBuffer db = DoubleBuffer.allocate(16); + db.put(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); + db.flip(); + // row major + mat3A.setIdentity(); + mat3A.fromDoubleBuffer(db); + assertTrue(0 == mat3A.getM00()); + assertTrue(1 == mat3A.getM01()); + assertTrue(2 == mat3A.getM02()); + assertTrue(3 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(5 == mat3A.getM12()); + assertTrue(6 == mat3A.getM20()); + assertTrue(7 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + + // column major + db.rewind(); + mat3A.setIdentity(); + mat3A.fromDoubleBuffer(db, false); + assertTrue(0 == mat3A.getM00()); + assertTrue(3 == mat3A.getM01()); + assertTrue(6 == mat3A.getM02()); + assertTrue(1 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(7 == mat3A.getM12()); + assertTrue(2 == mat3A.getM20()); + assertTrue(5 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + } + + @Test + public void testToBuffer() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + final double[] colmajor = { 0, 3, 6, 1, 4, 7, 2, 5, 8 }; + + final Matrix3 mat3A = new Matrix3().fromArray(values); + + // row major + final FloatBuffer fb = mat3A.toFloatBuffer(FloatBuffer.allocate(9)); + fb.flip(); + for (int i = 0; i < 9; i++) { + assertTrue(values[i] == fb.get()); + } + + // column major + fb.rewind(); + mat3A.toFloatBuffer(fb, false); + fb.flip(); + for (int i = 0; i < 9; i++) { + assertTrue(colmajor[i] == fb.get()); + } + + // row major + final DoubleBuffer db = mat3A.toDoubleBuffer(DoubleBuffer.allocate(9)); + db.flip(); + for (int i = 0; i < 9; i++) { + assertTrue(values[i] == db.get()); + } + + // column major + db.rewind(); + mat3A.toDoubleBuffer(db, false); + db.flip(); + for (int i = 0; i < 9; i++) { + assertTrue(colmajor[i] == db.get()); + } + } + + @Test + public void testFromArray() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + final Matrix3 mat3A = new Matrix3(); + + // row major + mat3A.fromArray(values); + assertTrue(0 == mat3A.getM00()); + assertTrue(1 == mat3A.getM01()); + assertTrue(2 == mat3A.getM02()); + assertTrue(3 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(5 == mat3A.getM12()); + assertTrue(6 == mat3A.getM20()); + assertTrue(7 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + + // column major + mat3A.setIdentity(); + mat3A.fromArray(values, false); + assertTrue(0 == mat3A.getM00()); + assertTrue(3 == mat3A.getM01()); + assertTrue(6 == mat3A.getM02()); + assertTrue(1 == mat3A.getM10()); + assertTrue(4 == mat3A.getM11()); + assertTrue(7 == mat3A.getM12()); + assertTrue(2 == mat3A.getM20()); + assertTrue(5 == mat3A.getM21()); + assertTrue(8 == mat3A.getM22()); + } + + @Test + public void testToArray() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + final Matrix3 mat3A = new Matrix3().fromArray(values); + + // row major + final double[] dbls1 = mat3A.toArray(null); + for (int i = 0; i < 9; i++) { + assertTrue(values[i] == dbls1[i]); + } + + // column major + final double[] colmajor = { 0, 3, 6, 1, 4, 7, 2, 5, 8 }; + mat3A.toArray(dbls1, false); + for (int i = 0; i < 9; i++) { + assertTrue(colmajor[i] == dbls1[i]); + } + } + + @Test(expected = IllegalArgumentException.class) + public void testBadArray() { + final Matrix3 mat3A = new Matrix3(); + mat3A.toArray(new double[4]); + } + + @Test(expected = IllegalArgumentException.class) + public void testBadAnglesArray() { + final Matrix3 mat3A = new Matrix3(); + mat3A.toAngles(new double[2]); + } + + @Test + public void testAngleAxis() { + final Matrix3 mat3A = new Matrix3(); + // rotate identity 90 degrees around X + final double angle = MathUtils.HALF_PI; + mat3A.fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X); + assertEquals(new Matrix3( // + 1, 0, 0, // + 0, Math.cos(angle), -Math.sin(angle), // + 0, Math.sin(angle), Math.cos(angle)), mat3A); + } + + @Test + public void testRotations() { + final Vector3 rotated = new Vector3(1, 1, 1); + final Vector3 expected = new Vector3(1, 1, 1); + + // rotated + final Matrix3 mat3A = new Matrix3().fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.PI); + mat3A.applyPost(rotated, rotated); + + // expected - post + final Matrix3 worker = new Matrix3().fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X); + worker.applyPost(expected, expected); + worker.fromAngleAxis(MathUtils.PI, Vector3.UNIT_Z); + worker.applyPost(expected, expected); + worker.fromAngleAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y); + worker.applyPost(expected, expected); + + // test how close it came out + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Try a new way with new angles... + final Matrix3 mat3B = new Matrix3().fromAngles(MathUtils.QUARTER_PI, MathUtils.PI, MathUtils.HALF_PI); + rotated.set(1, 1, 1); + mat3B.applyPost(rotated, rotated); + + // expected + expected.set(1, 1, 1); + worker.setIdentity(); + // put together matrix, then apply to vector, so YZX + worker.applyRotationY(MathUtils.PI); + worker.applyRotationZ(MathUtils.HALF_PI); + worker.applyRotationX(MathUtils.QUARTER_PI); + worker.applyPost(expected, expected); + + // test how close it came out + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // test axis rotation methods against general purpose + // X AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Y AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Z AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // test toAngles - not necessarily the same values as fromAngles, but should be same resulting Matrix. + mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.PI); + final double[] angles = mat3A.toAngles(null); + worker.fromAngles(angles[0], angles[1], angles[2]); + assertEquals(mat3A, worker); + + mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, MathUtils.HALF_PI); + mat3A.toAngles(angles); + worker.fromAngles(angles[0], angles[1], angles[2]); + assertEquals(mat3A, worker); + + mat3A.fromAngles(MathUtils.HALF_PI, MathUtils.QUARTER_PI, -MathUtils.HALF_PI); + mat3A.toAngles(angles); + worker.fromAngles(angles[0], angles[1], angles[2]); + assertEquals(mat3A, worker); + } + + @Test + public void testMultiplyDiagonal() { + final Matrix3 mat3A = new Matrix3(); + Matrix3 result = mat3A.multiplyDiagonalPost(new Vector3(2, 4, 6), null); + assertEquals(new Matrix3( // + 2, 0, 0, // + 0, 4, 0, // + 0, 0, 6), result); + mat3A.multiplyDiagonalPre(new Vector3(-2, -4, -6), result); + assertEquals(new Matrix3( // + -2, 0, 0, // + 0, -4, 0, // + 0, 0, -6), result); + + final double a = MathUtils.HALF_PI; + mat3A.applyRotationY(a); + mat3A.multiplyDiagonalPost(new Vector3(2, 4, 6), result); + assertEquals(new Matrix3( // + 2 * Math.cos(a), 4 * 0, 6 * Math.sin(a), // + 2 * 0, 4 * 1, 6 * 0, // + 2 * -Math.sin(a), 4 * 0, 6 * Math.cos(a)), result); + result = mat3A.multiplyDiagonalPre(new Vector3(-2, -4, -6), null); + assertEquals(new Matrix3( // + -2 * Math.cos(a), -2 * 0, -2 * Math.sin(a), // + -4 * 0, -4 * 1, -4 * 0, // + -6 * -Math.sin(a), -6 * 0, -6 * Math.cos(a)), result); + } + + @Test + public void testMultiply() { + final Matrix3 mat3A = new Matrix3( // + 0.01, 0.1, 0.2, // + 1.0, 1.1, 1.2, // + 2.0, 2.1, 2.2); + mat3A.multiplyLocal(2); + assertEquals(new Matrix3( // + 0.02, 0.2, 0.4, // + 2.0, 2.2, 2.4, // + 4.0, 4.2, 4.4), mat3A); + + final Matrix3 mat3B = new Matrix3( // + 0.5, 1, 2, // + 4, 5, 6, // + 8, 9, 10); + final Matrix3 result = mat3A.multiply(mat3B, null); + assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 == result.getM00()); + assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 == result.getM01()); + assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 == result.getM02()); + assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 == result.getM10()); + assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 == result.getM11()); + assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 == result.getM12()); + assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 == result.getM20()); + assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 == result.getM21()); + assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 == result.getM22()); + mat3A.multiplyLocal(mat3B); + assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 == mat3A.getM00()); + assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 == mat3A.getM01()); + assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 == mat3A.getM02()); + assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 == mat3A.getM10()); + assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 == mat3A.getM11()); + assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 == mat3A.getM12()); + assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 == mat3A.getM20()); + assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 == mat3A.getM21()); + assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 == mat3A.getM22()); + } + + @Test + public void testAddSubtract() { + final Matrix3 mat3A = new Matrix3( // + 0.0, 0.1, 0.2, // + 1.0, 1.1, 1.2, // + 2.0, 2.1, 2.2); + + final Matrix3 result1 = mat3A.add(new Matrix3(// + 1, 2, 3,// + 5, 6, 7, // + 9, 10, 11), null); + assertEquals(new Matrix3( // + 1.0, 2.1, 3.2, // + 6.0, 7.1, 8.2, // + 11.0, 12.1, 13.2), result1); + + final Matrix3 result2 = result1.subtract(new Matrix3(// + 1, 2, 3, // + 5, 6, 7, // + 9, 10, 11), null); + assertEquals(mat3A, result2); + result2.addLocal(Matrix3.IDENTITY); + assertEquals(new Matrix3( // + 1.0, 0.1, 0.2, // + 1.0, 2.1, 1.2, // + 2.0, 2.1, 3.2), result2); + + result1.subtractLocal(Matrix3.IDENTITY); + assertEquals(new Matrix3( // + 0.0, 2.1, 3.2, // + 6.0, 6.1, 8.2, // + 11.0, 12.1, 12.2), result1); + } + + @Test + public void testScale() { + final Matrix3 mat3A = new Matrix3( // + 0.01, 0.1, 0.2, // + 1.0, 1.1, 1.2, // + 2.0, 2.1, 2.2); + final Matrix3 result = mat3A.scale(new Vector3(-1, 2, 3), null); + assertEquals(new Matrix3( // + 0.01 * -1, 0.1 * 2, 0.2 * 3, // + 1.0 * -1, 1.1 * 2, 1.2 * 3, // + 2.0 * -1, 2.1 * 2, 2.2 * 3), result); + + result.scaleLocal(new Vector3(-1, 0.5, 1 / 3.)); + assertEquals(mat3A, result); + } + + @Test + public void testTranspose() { + final Matrix3 mat3A = new Matrix3( // + 0.01, 0.1, 0.2, // + 1.0, 1.1, 1.2, // + 2.0, 2.1, 2.2); + final Matrix3 result = mat3A.transpose(null); + assertEquals(new Matrix3( // + 0.01, 1.0, 2.0, // + 0.1, 1.1, 2.1, // + 0.2, 1.2, 2.2), result); + assertEquals(new Matrix3( // + 0.01, 0.1, 0.2, // + 1.0, 1.1, 1.2, // + 2.0, 2.1, 2.2), result.transposeLocal()); + // coverage + final Matrix3 result2 = result.transposeLocal().transpose(new Matrix3()); + assertEquals(mat3A, result2); + } + + @Test + public void testInvert() { + final Matrix3 mat3A = new Matrix3().applyRotationX(MathUtils.QUARTER_PI); + final Matrix3 inverted = mat3A.invert(null); + assertEquals(Matrix3.IDENTITY, mat3A.multiply(inverted, null)); + assertEquals(mat3A, inverted.invertLocal()); + } + + @Test(expected = ArithmeticException.class) + public void testBadInvert() { + final Matrix3 mat3A = new Matrix3(0, 0, 0, 0, 0, 0, 0, 0, 0); + mat3A.invertLocal(); + } + + @Test + public void testAdjugate() { + final double // + a = -3, b = 2, c = -5, // + d = -1, e = 0, f = -2, // + g = 3, h = -4, i = 1; + + final Matrix3 mat3A = new Matrix3( // + a, b, c, // + d, e, f, // + g, h, i); + + final Matrix3 testValue = new Matrix3( // + e * i - h * f, -(b * i - h * c), b * f - e * c, // + -(d * i - g * f), a * i - g * c, -(a * f - d * c),// + d * h - g * e, -(a * h - g * b), a * e - d * b); + + assertEquals(testValue, mat3A.adjugate(null)); + assertEquals(testValue, mat3A.adjugateLocal()); + } + + @Test + public void testDeterminant() { + { + final double // + a = -3, b = 2, c = -5, // + d = -1, e = 0, f = -2, // + g = 3, h = -4, i = 1; + + final Matrix3 mat3A = new Matrix3( // + a, b, c, // + d, e, f, // + g, h, i); + final double determinant = a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h; + assertTrue(determinant == mat3A.determinant()); + } + + { + final double // + a = -1, b = 2, c = -3, // + d = 4, e = -5, f = 6, // + g = -7, h = 8, i = -9; + + final Matrix3 mat3A = new Matrix3( // + a, b, c, // + d, e, f, // + g, h, i); + final double determinant = a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h; + assertTrue(determinant == mat3A.determinant()); + } + } + + @Test + public void testClone() { + final Matrix3 mat1 = new Matrix3(); + final Matrix3 mat2 = mat1.clone(); + assertEquals(mat1, mat2); + assertNotSame(mat1, mat2); + } + + @Test + public void testValid() { + final Matrix3 mat3 = new Matrix3(); + assertTrue(Matrix3.isValid(mat3)); + for (int i = 0; i < 9; i++) { + mat3.setIdentity(); + mat3.setValue(i / 3, i % 3, Double.NaN); + assertFalse(Matrix3.isValid(mat3)); + mat3.setIdentity(); + mat3.setValue(i / 3, i % 3, Double.POSITIVE_INFINITY); + assertFalse(Matrix3.isValid(mat3)); + } + + mat3.setIdentity(); + assertTrue(Matrix3.isValid(mat3)); + + assertFalse(Matrix3.isValid(null)); + + // couple of equals validity tests + assertEquals(mat3, mat3); + assertTrue(mat3.strictEquals(mat3)); + assertFalse(mat3.equals(null)); + assertFalse(mat3.strictEquals(null)); + assertFalse(mat3.equals(new Vector2())); + assertFalse(mat3.strictEquals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Matrix3 matTemp = Matrix3.fetchTempInstance(); + matTemp.set(mat3); + assertEquals(mat3, matTemp); + assertNotSame(mat3, matTemp); + Matrix3.releaseTempInstance(matTemp); + + // cover more of equals + mat3.set(0, 1, 2, 3, 4, 5, 6, 7, 8); + final Matrix3 comp = new Matrix3(-1, -1, -1, -1, -1, -1, -1, -1, -1); + assertFalse(mat3.equals(comp)); + assertFalse(mat3.strictEquals(comp)); + for (int i = 0; i < 8; i++) { + comp.setValue(i / 3, i % 3, i); + assertFalse(mat3.equals(comp)); + assertFalse(mat3.strictEquals(comp)); + } + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Matrix3 mat1 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 9); + final Matrix3 mat2 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 9); + final Matrix3 mat3 = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 0); + + assertTrue(mat1.hashCode() == mat2.hashCode()); + assertTrue(mat1.hashCode() != mat3.hashCode()); + } + + @Test + public void testOrthonormal() { + final Matrix3 mat3 = new Matrix3(); + assertTrue(mat3.isOrthonormal()); + // just rotation + mat3.applyRotationX(MathUtils.QUARTER_PI); + assertTrue(mat3.isOrthonormal()); + // non-uniform scale + mat3.setIdentity(); + mat3.scaleLocal(new Vector3(1, 2, 3)); + assertFalse(mat3.isOrthonormal()); + // non-uniform scale + rotation + mat3.setIdentity(); + mat3.scaleLocal(new Vector3(1, 2, 3)); + mat3.applyRotationX(MathUtils.QUARTER_PI); + assertFalse(mat3.isOrthonormal()); + } + + @Test + public void testApplyVector3() { + final Matrix3 mat3 = new Matrix3().applyRotationX(MathUtils.HALF_PI); + final Vector3 vec3 = new Vector3(0, 1, 0); + final Vector3 result = mat3.applyPost(vec3, null); + assertTrue(Math.abs(new Vector3(0, 0, 1).distance(result)) <= MathUtils.EPSILON); + vec3.set(0, 1, 1); + mat3.applyPost(vec3, result); + assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result)) <= MathUtils.EPSILON); + + vec3.set(0, 1, 1); + mat3.applyPre(vec3, result); + assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result)) <= MathUtils.EPSILON); + + vec3.set(1, 1, 1); + assertTrue(Math.abs(new Vector3(1, 1, -1).distance(mat3.applyPre(vec3, null))) <= MathUtils.EPSILON); + } + + @Test + public void testStartEnd() { + final Matrix3 mat3 = new Matrix3(); + mat3.fromStartEndLocal(Vector3.UNIT_X, Vector3.UNIT_Y); // should be a 90 degree turn around Z + assertEquals(new Vector3(-1, 1, 1), mat3.applyPost(new Vector3(1, 1, 1), null)); + + // coverage + mat3.fromStartEndLocal(new Vector3(1, 0, 0), new Vector3(1 + Double.MIN_VALUE, 0, 0)); + assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE); + mat3.fromStartEndLocal(new Vector3(0, 1, 0), new Vector3(0, 1 + Double.MIN_VALUE, 0)); + assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE); + mat3.fromStartEndLocal(new Vector3(0, 0, 1), new Vector3(0, 0, 1 + Double.MIN_VALUE)); + assertTrue(mat3.applyPost(Vector3.ONE, null).distance(Vector3.ONE) < MathUtils.ZERO_TOLERANCE); + } + + @Test + public void testLookAt() { + final Vector3 direction = new Vector3(-1, 0, 0); + final Matrix3 mat3 = new Matrix3().lookAt(direction, Vector3.UNIT_Y); + assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, null)); + + direction.set(1, 1, 1).normalizeLocal(); + mat3.lookAt(direction, Vector3.UNIT_Y); + assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, null)); + + direction.set(-1, 2, -1).normalizeLocal(); + mat3.lookAt(direction, Vector3.UNIT_Y); + assertEquals(direction, mat3.applyPost(Vector3.UNIT_Z, new Vector3())); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix4.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix4.java index 9774434..e91ab5b 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix4.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestMatrix4.java @@ -1,935 +1,935 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import java.nio.DoubleBuffer;
-import java.nio.FloatBuffer;
-
-import org.junit.Test;
-
-public class TestMatrix4 {
-
- @Test
- public void testGetSet() {
- final Matrix4 mat4A = new Matrix4();
- assertEquals(Matrix4.IDENTITY, mat4A);
-
- mat4A.setM00(0.0);
- mat4A.setM01(0.1);
- mat4A.setM02(0.2);
- mat4A.setM03(0.3);
- mat4A.setM10(1.0);
- mat4A.setM11(1.1);
- mat4A.setM12(1.2);
- mat4A.setM13(1.3);
- mat4A.setM20(2.0);
- mat4A.setM21(2.1);
- mat4A.setM22(2.2);
- mat4A.setM23(2.3);
- mat4A.setM30(3.0);
- mat4A.setM31(3.1);
- mat4A.setM32(3.2);
- mat4A.setM33(3.3);
-
- assertTrue(0.0 == mat4A.getM00());
- assertTrue(0.1 == mat4A.getM01());
- assertTrue(0.2 == mat4A.getM02());
- assertTrue(0.3 == mat4A.getM03());
- assertTrue(1.0 == mat4A.getM10());
- assertTrue(1.1 == mat4A.getM11());
- assertTrue(1.2 == mat4A.getM12());
- assertTrue(1.3 == mat4A.getM13());
- assertTrue(2.0 == mat4A.getM20());
- assertTrue(2.1 == mat4A.getM21());
- assertTrue(2.2 == mat4A.getM22());
- assertTrue(2.3 == mat4A.getM23());
- assertTrue(3.0 == mat4A.getM30());
- assertTrue(3.1 == mat4A.getM31());
- assertTrue(3.2 == mat4A.getM32());
- assertTrue(3.3 == mat4A.getM33());
-
- final Matrix4 mat4B = new Matrix4(mat4A);
- assertTrue(0.0 == mat4B.getM00());
- assertTrue(0.1 == mat4B.getM01());
- assertTrue(0.2 == mat4B.getM02());
- assertTrue(0.3 == mat4B.getM03());
- assertTrue(1.0 == mat4B.getM10());
- assertTrue(1.1 == mat4B.getM11());
- assertTrue(1.2 == mat4B.getM12());
- assertTrue(1.3 == mat4B.getM13());
- assertTrue(2.0 == mat4B.getM20());
- assertTrue(2.1 == mat4B.getM21());
- assertTrue(2.2 == mat4B.getM22());
- assertTrue(2.3 == mat4B.getM23());
- assertTrue(3.0 == mat4B.getM30());
- assertTrue(3.1 == mat4B.getM31());
- assertTrue(3.2 == mat4B.getM32());
- assertTrue(3.3 == mat4B.getM33());
-
- final Matrix4 mat4C = new Matrix4(0.0, 0.1, 0.2, 0.3, 1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2,
- 3.3);
- assertTrue(0.0 == mat4C.getM00());
- assertTrue(0.1 == mat4C.getM01());
- assertTrue(0.2 == mat4C.getM02());
- assertTrue(0.3 == mat4C.getM03());
- assertTrue(1.0 == mat4C.getM10());
- assertTrue(1.1 == mat4C.getM11());
- assertTrue(1.2 == mat4C.getM12());
- assertTrue(1.3 == mat4C.getM13());
- assertTrue(2.0 == mat4C.getM20());
- assertTrue(2.1 == mat4C.getM21());
- assertTrue(2.2 == mat4C.getM22());
- assertTrue(2.3 == mat4C.getM23());
- assertTrue(3.0 == mat4C.getM30());
- assertTrue(3.1 == mat4C.getM31());
- assertTrue(3.2 == mat4C.getM32());
- assertTrue(3.3 == mat4C.getM33());
-
- mat4C.setIdentity();
- assertTrue(mat4C.isIdentity());
-
- for (int x = 0; x < 4; x++) {
- for (int y = 0; y < 4; y++) {
- final double value = (10 * x + y) / 10.;
- mat4C.setValue(x, y, value);
- assertTrue(value == mat4C.getValue(x, y));
- }
- }
-
- mat4C.setIdentity();
- mat4C.set(0.0, 0.1, 0.2, 0.3, 2.0, 2.1, 2.2, 2.3, 4.0, 4.1, 4.2, 4.3, 6.0, 6.1, 6.2, 6.3);
- for (int x = 0; x < 4; x++) {
- for (int y = 0; y < 4; y++) {
- assertTrue((20 * x + y) / 10.f == mat4C.getValuef(x, y));
- }
- }
-
- final Matrix4 store = new Matrix4(mat4C);
- // catch a few expected exceptions
- try {
- mat4C.getValue(-1, 0);
- fail("getValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.getValue(0, 4);
- fail("getValue(0, 4) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.getValue(1, -1);
- fail("getValue(1, -1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.getValue(2, 4);
- fail("getValue(2, 4) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.getValue(3, -1);
- fail("getValue(3, -1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.getValue(4, 0);
- fail("getValue(4, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
-
- try {
- mat4C.setValue(-1, 0, 0);
- fail("setValue(-1, 0, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.setValue(0, -1, 0);
- fail("setValue(0, -1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.setValue(1, 4, 0);
- fail("setValue(1, 4, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.setValue(2, -1, 0);
- fail("setValue(2, -1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.setValue(3, 4, 0);
- fail("setValue(3, 4, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4C.setValue(4, 0, 0);
- fail("setValue(4, 0, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered mat4C
- assertEquals(store, mat4C);
- }
-
- @Test
- public void testColumns() {
- final Matrix4 mat4A = new Matrix4();
- mat4A.setColumn(0, new Vector4(0, 4, 8, 12));
- mat4A.setColumn(1, new Vector4(1, 5, 9, 13));
- mat4A.setColumn(2, new Vector4(2, 6, 10, 14));
- mat4A.setColumn(3, new Vector4(3, 7, 11, 15));
- assertEquals(new Vector4(0, 4, 8, 12), mat4A.getColumn(0, new Vector4()));
- assertEquals(new Vector4(1, 5, 9, 13), mat4A.getColumn(1, null));
- assertEquals(new Vector4(2, 6, 10, 14), mat4A.getColumn(2, null));
- assertEquals(new Vector4(3, 7, 11, 15), mat4A.getColumn(3, null));
- try {
- mat4A.getColumn(-1, null);
- fail("getColumn(-1, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.getColumn(4, null);
- fail("getColumn(4, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.setColumn(-1, new Vector4());
- fail("setColumn(-1, double[]) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.setColumn(4, new Vector4());
- fail("setColumn(4, double[]) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- }
-
- @Test
- public void testRows() {
- final Matrix4 mat4A = new Matrix4();
- mat4A.setRow(0, new Vector4(0, 1, 2, 3));
- mat4A.setRow(1, new Vector4(4, 5, 6, 7));
- mat4A.setRow(2, new Vector4(8, 9, 10, 11));
- mat4A.setRow(3, new Vector4(12, 13, 14, 15));
- assertEquals(new Vector4(0, 1, 2, 3), mat4A.getRow(0, new Vector4()));
- assertEquals(new Vector4(4, 5, 6, 7), mat4A.getRow(1, null));
- assertEquals(new Vector4(8, 9, 10, 11), mat4A.getRow(2, null));
- assertEquals(new Vector4(12, 13, 14, 15), mat4A.getRow(3, null));
- try {
- mat4A.getRow(-1, null);
- fail("getRow(-1, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.getRow(4, null);
- fail("getRow(4, null) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.setRow(-1, new Vector4());
- fail("setRow(-1, double[]) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- mat4A.setRow(4, new Vector4());
- fail("setRow(4, double[]) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- }
-
- @Test
- public void testSetRotation() {
- final Matrix4 mat4A = new Matrix4(0.0, 0.1, 0.2, 0.3, 1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2,
- 3.3);
- mat4A.set(Matrix3.IDENTITY);
- assertTrue(1.0 == mat4A.getM00());
- assertTrue(0.0 == mat4A.getM01());
- assertTrue(0.0 == mat4A.getM02());
- assertTrue(0.3 == mat4A.getM03());
- assertTrue(0.0 == mat4A.getM10());
- assertTrue(1.0 == mat4A.getM11());
- assertTrue(0.0 == mat4A.getM12());
- assertTrue(1.3 == mat4A.getM13());
- assertTrue(0.0 == mat4A.getM20());
- assertTrue(0.0 == mat4A.getM21());
- assertTrue(1.0 == mat4A.getM22());
- assertTrue(2.3 == mat4A.getM23());
- assertTrue(3.0 == mat4A.getM30());
- assertTrue(3.1 == mat4A.getM31());
- assertTrue(3.2 == mat4A.getM32());
- assertTrue(3.3 == mat4A.getM33());
-
- mat4A.setIdentity();
- // rotate identity 90 degrees around Y
- final double a = MathUtils.HALF_PI;
- final Quaternion quaternion = new Quaternion();
- quaternion.fromAngleAxis(a, Vector3.UNIT_Y);
- mat4A.set(quaternion);
-
- assertEquals(new Matrix4( //
- Math.cos(a), 0, Math.sin(a), 0, //
- 0, 1, 0, 0, //
- -Math.sin(a), 0, Math.cos(a), 0, //
- 0, 0, 0, 1), mat4A);
- }
-
- @Test
- public void testFromBuffer() {
- final FloatBuffer fb = FloatBuffer.allocate(16);
- fb.put(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
- fb.flip();
- // row major
- final Matrix4 mat4A = new Matrix4().fromFloatBuffer(fb);
- assertTrue(0 == mat4A.getM00());
- assertTrue(1 == mat4A.getM01());
- assertTrue(2 == mat4A.getM02());
- assertTrue(3 == mat4A.getM03());
- assertTrue(4 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(6 == mat4A.getM12());
- assertTrue(7 == mat4A.getM13());
- assertTrue(8 == mat4A.getM20());
- assertTrue(9 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(11 == mat4A.getM23());
- assertTrue(12 == mat4A.getM30());
- assertTrue(13 == mat4A.getM31());
- assertTrue(14 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
-
- // column major
- fb.rewind();
- mat4A.setIdentity();
- mat4A.fromFloatBuffer(fb, false);
- assertTrue(0 == mat4A.getM00());
- assertTrue(4 == mat4A.getM01());
- assertTrue(8 == mat4A.getM02());
- assertTrue(12 == mat4A.getM03());
- assertTrue(1 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(9 == mat4A.getM12());
- assertTrue(13 == mat4A.getM13());
- assertTrue(2 == mat4A.getM20());
- assertTrue(6 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(14 == mat4A.getM23());
- assertTrue(3 == mat4A.getM30());
- assertTrue(7 == mat4A.getM31());
- assertTrue(11 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
-
- final DoubleBuffer db = DoubleBuffer.allocate(16);
- db.put(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
- db.flip();
- // row major
- mat4A.setIdentity();
- mat4A.fromDoubleBuffer(db);
- assertTrue(0 == mat4A.getM00());
- assertTrue(1 == mat4A.getM01());
- assertTrue(2 == mat4A.getM02());
- assertTrue(3 == mat4A.getM03());
- assertTrue(4 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(6 == mat4A.getM12());
- assertTrue(7 == mat4A.getM13());
- assertTrue(8 == mat4A.getM20());
- assertTrue(9 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(11 == mat4A.getM23());
- assertTrue(12 == mat4A.getM30());
- assertTrue(13 == mat4A.getM31());
- assertTrue(14 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
-
- // column major
- db.rewind();
- mat4A.setIdentity();
- mat4A.fromDoubleBuffer(db, false);
- assertTrue(0 == mat4A.getM00());
- assertTrue(4 == mat4A.getM01());
- assertTrue(8 == mat4A.getM02());
- assertTrue(12 == mat4A.getM03());
- assertTrue(1 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(9 == mat4A.getM12());
- assertTrue(13 == mat4A.getM13());
- assertTrue(2 == mat4A.getM20());
- assertTrue(6 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(14 == mat4A.getM23());
- assertTrue(3 == mat4A.getM30());
- assertTrue(7 == mat4A.getM31());
- assertTrue(11 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
- }
-
- @Test
- public void testToBuffer() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
- final double[] colmajor = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };
-
- final Matrix4 mat4A = new Matrix4().fromArray(values);
-
- // row major
- final FloatBuffer fb = mat4A.toFloatBuffer(FloatBuffer.allocate(16));
- fb.flip();
- for (int i = 0; i < 16; i++) {
- assertTrue(values[i] == fb.get());
- }
-
- // column major
- fb.rewind();
- mat4A.toFloatBuffer(fb, false);
- fb.flip();
- for (int i = 0; i < 16; i++) {
- assertTrue(colmajor[i] == fb.get());
- }
-
- // row major
- final DoubleBuffer db = mat4A.toDoubleBuffer(DoubleBuffer.allocate(16));
- db.flip();
- for (int i = 0; i < 16; i++) {
- assertTrue(values[i] == db.get());
- }
-
- // column major
- db.rewind();
- mat4A.toDoubleBuffer(db, false);
- db.flip();
- for (int i = 0; i < 16; i++) {
- assertTrue(colmajor[i] == db.get());
- }
- }
-
- @Test
- public void testFromArray() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
- final Matrix4 mat4A = new Matrix4();
-
- // row major
- mat4A.setIdentity();
- mat4A.fromArray(values);
- assertTrue(0 == mat4A.getM00());
- assertTrue(1 == mat4A.getM01());
- assertTrue(2 == mat4A.getM02());
- assertTrue(3 == mat4A.getM03());
- assertTrue(4 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(6 == mat4A.getM12());
- assertTrue(7 == mat4A.getM13());
- assertTrue(8 == mat4A.getM20());
- assertTrue(9 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(11 == mat4A.getM23());
- assertTrue(12 == mat4A.getM30());
- assertTrue(13 == mat4A.getM31());
- assertTrue(14 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
-
- // column major
- mat4A.setIdentity();
- mat4A.fromArray(values, false);
- assertTrue(0 == mat4A.getM00());
- assertTrue(4 == mat4A.getM01());
- assertTrue(8 == mat4A.getM02());
- assertTrue(12 == mat4A.getM03());
- assertTrue(1 == mat4A.getM10());
- assertTrue(5 == mat4A.getM11());
- assertTrue(9 == mat4A.getM12());
- assertTrue(13 == mat4A.getM13());
- assertTrue(2 == mat4A.getM20());
- assertTrue(6 == mat4A.getM21());
- assertTrue(10 == mat4A.getM22());
- assertTrue(14 == mat4A.getM23());
- assertTrue(3 == mat4A.getM30());
- assertTrue(7 == mat4A.getM31());
- assertTrue(11 == mat4A.getM32());
- assertTrue(15 == mat4A.getM33());
- }
-
- @Test
- public void testToArray() {
- final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
- final Matrix4 mat4A = new Matrix4().fromArray(values);
-
- // row major
- final double[] dbls1 = mat4A.toArray(null);
- for (int i = 0; i < 16; i++) {
- assertTrue(values[i] == dbls1[i]);
- }
-
- // column major
- final double[] colmajor = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };
- mat4A.toArray(dbls1, false);
- for (int i = 0; i < 16; i++) {
- assertTrue(colmajor[i] == dbls1[i]);
- }
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBadArray() {
- final Matrix4 mat4A = new Matrix4();
- mat4A.toArray(new double[9]);
- }
-
- @Test
- public void testAngleAxis() {
- final Matrix4 mat4A = new Matrix4();
- // rotate identity 90 degrees around X
- final double angle = MathUtils.HALF_PI;
- mat4A.fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X);
- assertEquals(new Matrix4( //
- 1, 0, 0, 0, //
- 0, Math.cos(angle), -Math.sin(angle), 0, //
- 0, Math.sin(angle), Math.cos(angle), 0, //
- 0, 0, 0, 1), mat4A);
- }
-
- @Test
- public void testRotations() {
- final Vector4 rotated = new Vector4();
- final Vector4 expected = new Vector4();
- final Matrix4 worker = new Matrix4();
-
- // test axis rotation methods against general purpose
- // X AXIS
- expected.set(1, 1, 1, 1);
- rotated.set(1, 1, 1, 1);
- worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Y AXIS
- expected.set(1, 1, 1, 1);
- rotated.set(1, 1, 1, 1);
- worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Z AXIS
- expected.set(1, 1, 1, 1);
- rotated.set(1, 1, 1, 1);
- worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).applyPost(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).applyPost(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testTranslation() {
- final Matrix4 src = new Matrix4();
- src.applyRotation(MathUtils.QUARTER_PI, 1, 0, 0);
-
- final Matrix4 trans = new Matrix4();
- trans.setColumn(3, new Vector4(1, 2, 3, 1));
- final Matrix4 transThenRotate = trans.multiply(src, null);
- final Matrix4 rotateThenTrans = src.multiply(trans, null);
-
- final Matrix4 pre1 = new Matrix4(src).applyTranslationPre(1, 2, 3);
- final Matrix4 post1 = new Matrix4(src).applyTranslationPost(1, 2, 3);
-
- assertEquals(transThenRotate, pre1);
- assertEquals(rotateThenTrans, post1);
- }
-
- @Test
- public void testMultiplyDiagonal() {
- final Matrix4 mat4A = new Matrix4();
- Matrix4 result = mat4A.multiplyDiagonalPost(new Vector4(2, 4, 6, 8), null);
- assertEquals(new Matrix4( //
- 2, 0, 0, 0, //
- 0, 4, 0, 0, //
- 0, 0, 6, 0, //
- 0, 0, 0, 8), result);
- mat4A.multiplyDiagonalPre(new Vector4(-2, -4, -6, -8), result);
- assertEquals(new Matrix4( //
- -2, 0, 0, 0, //
- 0, -4, 0, 0, //
- 0, 0, -6, 0, //
- 0, 0, 0, -8), result);
-
- final double a = MathUtils.HALF_PI;
- mat4A.applyRotationY(a);
- mat4A.multiplyDiagonalPost(new Vector4(2, 4, 6, 8), result);
- assertEquals(new Matrix4( //
- 2 * Math.cos(a), 4 * 0, 6 * Math.sin(a), 8 * 0, //
- 2 * 0, 4 * 1, 6 * 0, 8 * 0, //
- 2 * -Math.sin(a), 4 * 0, 6 * Math.cos(a), 8 * 0, //
- 2 * 0, 4 * 0, 6 * 0, 8 * 1), result);
- result = mat4A.multiplyDiagonalPre(new Vector4(-2, -4, -6, -8), null);
- assertEquals(new Matrix4( //
- -2 * Math.cos(a), -2 * 0, -2 * Math.sin(a), -2 * 0, //
- -4 * 0, -4 * 1, -4 * 0, -4 * 0, //
- -6 * -Math.sin(a), -6 * 0, -6 * Math.cos(a), -6 * 0, //
- -8 * 0, -8 * 0, -8 * 0, -8 * 1), result);
- }
-
- @Test
- public void testMultiply() {
- final Matrix4 mat4A = new Matrix4( //
- 0.01, 0.1, 0.2, 0.3, //
- 1.0, 1.1, 1.2, 1.3, //
- 2.0, 2.1, 2.2, 2.3, //
- 3.0, 3.1, 3.2, 3.3);
- mat4A.multiplyLocal(2);
- assertEquals(new Matrix4( //
- 0.02, 0.2, 0.4, 0.6, //
- 2.0, 2.2, 2.4, 2.6, //
- 4.0, 4.2, 4.4, 4.6, //
- 6.0, 6.2, 6.4, 6.6), mat4A);
-
- final Matrix4 mat4B = new Matrix4( //
- 0.5, 1, 2, 3, //
- 4, 5, 6, 7, //
- 8, 9, 10, 11, //
- 12, 13, 14, 15);
- final Matrix4 result = mat4A.multiply(mat4B, null);
- assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 + 0.6 * 12 == result.getM00());
- assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 + 0.6 * 13 == result.getM01());
- assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 + 0.6 * 14 == result.getM02());
- assertTrue(0.02 * 3 + 0.2 * 7 + 0.4 * 11 + 0.6 * 15 == result.getM03());
- assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 + 2.6 * 12 == result.getM10());
- assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 + 2.6 * 13 == result.getM11());
- assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 + 2.6 * 14 == result.getM12());
- assertTrue(2.0 * 3 + 2.2 * 7 + 2.4 * 11 + 2.6 * 15 == result.getM13());
- assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 + 4.6 * 12 == result.getM20());
- assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 + 4.6 * 13 == result.getM21());
- assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 + 4.6 * 14 == result.getM22());
- assertTrue(4.0 * 3 + 4.2 * 7 + 4.4 * 11 + 4.6 * 15 == result.getM23());
- assertTrue(6.0 * 0.5 + 6.2 * 4 + 6.4 * 8 + 6.6 * 12 == result.getM30());
- assertTrue(6.0 * 1 + 6.2 * 5 + 6.4 * 9 + 6.6 * 13 == result.getM31());
- assertTrue(6.0 * 2 + 6.2 * 6 + 6.4 * 10 + 6.6 * 14 == result.getM32());
- assertTrue(6.0 * 3 + 6.2 * 7 + 6.4 * 11 + 6.6 * 15 == result.getM33());
- mat4A.multiplyLocal(mat4B);
- assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 + 0.6 * 12 == mat4A.getM00());
- assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 + 0.6 * 13 == mat4A.getM01());
- assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 + 0.6 * 14 == mat4A.getM02());
- assertTrue(0.02 * 3 + 0.2 * 7 + 0.4 * 11 + 0.6 * 15 == mat4A.getM03());
- assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 + 2.6 * 12 == mat4A.getM10());
- assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 + 2.6 * 13 == mat4A.getM11());
- assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 + 2.6 * 14 == mat4A.getM12());
- assertTrue(2.0 * 3 + 2.2 * 7 + 2.4 * 11 + 2.6 * 15 == mat4A.getM13());
- assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 + 4.6 * 12 == mat4A.getM20());
- assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 + 4.6 * 13 == mat4A.getM21());
- assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 + 4.6 * 14 == mat4A.getM22());
- assertTrue(4.0 * 3 + 4.2 * 7 + 4.4 * 11 + 4.6 * 15 == mat4A.getM23());
- assertTrue(6.0 * 0.5 + 6.2 * 4 + 6.4 * 8 + 6.6 * 12 == mat4A.getM30());
- assertTrue(6.0 * 1 + 6.2 * 5 + 6.4 * 9 + 6.6 * 13 == mat4A.getM31());
- assertTrue(6.0 * 2 + 6.2 * 6 + 6.4 * 10 + 6.6 * 14 == mat4A.getM32());
- assertTrue(6.0 * 3 + 6.2 * 7 + 6.4 * 11 + 6.6 * 15 == mat4A.getM33());
- }
-
- @Test
- public void testAddSubtract() {
- final Matrix4 mat4A = new Matrix4( //
- 0.0, 0.1, 0.2, 0.3, //
- 1.0, 1.1, 1.2, 1.3, //
- 2.0, 2.1, 2.2, 2.3, //
- 3.0, 3.1, 3.2, 3.3);
-
- final Matrix4 result1 = mat4A.add(new Matrix4(//
- 1, 2, 3, 4,//
- 5, 6, 7, 8,//
- 9, 10, 11, 12,//
- 13, 14, 15, 16), null);
- assertEquals(new Matrix4( //
- 1.0, 2.1, 3.2, 4.3, //
- 6.0, 7.1, 8.2, 9.3, //
- 11.0, 12.1, 13.2, 14.3, //
- 16.0, 17.1, 18.2, 19.3), result1);
-
- final Matrix4 result2 = result1.subtract(new Matrix4(//
- 1, 2, 3, 4,//
- 5, 6, 7, 8,//
- 9, 10, 11, 12,//
- 13, 14, 15, 16), null);
- assertEquals(mat4A, result2);
- result2.addLocal(Matrix4.IDENTITY);
- assertEquals(new Matrix4( //
- 1.0, 0.1, 0.2, 0.3, //
- 1.0, 2.1, 1.2, 1.3, //
- 2.0, 2.1, 3.2, 2.3, //
- 3.0, 3.1, 3.2, 4.3), result2);
-
- result1.subtractLocal(Matrix4.IDENTITY);
- assertEquals(new Matrix4( //
- 0.0, 2.1, 3.2, 4.3, //
- 6.0, 6.1, 8.2, 9.3, //
- 11.0, 12.1, 12.2, 14.3, //
- 16.0, 17.1, 18.2, 18.3), result1);
- }
-
- @Test
- public void testScale() {
- final Matrix4 mat4A = new Matrix4( //
- 0.01, 0.1, 0.2, 0.3, //
- 1.0, 1.1, 1.2, 1.3, //
- 2.0, 2.1, 2.2, 2.3, //
- 3.0, 3.1, 3.2, 3.3);
- final Matrix4 result = mat4A.scale(new Vector4(-1, 2, 3, 4), null);
- assertEquals(new Matrix4( //
- 0.01 * -1, 0.1 * 2, 0.2 * 3, 0.3 * 4, //
- 1.0 * -1, 1.1 * 2, 1.2 * 3, 1.3 * 4, //
- 2.0 * -1, 2.1 * 2, 2.2 * 3, 2.3 * 4, //
- 3.0 * -1, 3.1 * 2, 3.2 * 3, 3.3 * 4), result);
-
- result.scaleLocal(new Vector4(-1, 0.5, 1 / 3., .25));
- assertEquals(mat4A, result);
- }
-
- @Test
- public void testTranspose() {
- final Matrix4 mat4A = new Matrix4( //
- 0.01, 0.1, 0.2, 0.3, //
- 1.0, 1.1, 1.2, 1.3, //
- 2.0, 2.1, 2.2, 2.3, //
- 3.0, 3.1, 3.2, 3.3);
- final Matrix4 result = mat4A.transpose(null);
- assertEquals(new Matrix4( //
- 0.01, 1.0, 2.0, 3.0, //
- 0.1, 1.1, 2.1, 3.1, //
- 0.2, 1.2, 2.2, 3.2, //
- 0.3, 1.3, 2.3, 3.3), result);
- assertEquals(new Matrix4( //
- 0.01, 0.1, 0.2, 0.3, //
- 1.0, 1.1, 1.2, 1.3, //
- 2.0, 2.1, 2.2, 2.3, //
- 3.0, 3.1, 3.2, 3.3), result.transposeLocal());
- // coverage
- final Matrix4 result2 = result.transposeLocal().transpose(new Matrix4());
- assertEquals(mat4A, result2);
- }
-
- @Test
- public void testInvert() {
- final Matrix4 mat4A = new Matrix4().applyRotationX(MathUtils.QUARTER_PI).applyTranslationPost(1, 2, 3);
- final Matrix4 inverted = mat4A.invert(null);
- assertEquals(Matrix4.IDENTITY, mat4A.multiply(inverted, null));
- assertEquals(mat4A, inverted.invertLocal());
- }
-
- @Test(expected = ArithmeticException.class)
- public void testBadInvert() {
- final Matrix4 mat4A = new Matrix4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
- mat4A.invertLocal();
- }
-
- @Test
- public void testAdjugate() {
- final double //
- a = -3, b = 2, c = -5, d = 2, //
- e = -1, f = 0, g = -2, h = 3, //
- i = 1, j = -3, k = -4, l = 0, //
- m = 4, n = 2, o = 3, p = 1;
-
- final Matrix4 mat4A = new Matrix4( //
- a, b, c, d,//
- e, f, g, h, //
- i, j, k, l, //
- m, n, o, p);
-
- // prepare sections
- final Matrix3 m00 = new Matrix3(f, g, h, j, k, l, n, o, p);
- final Matrix3 m01 = new Matrix3(b, c, d, j, k, l, n, o, p);
- final Matrix3 m02 = new Matrix3(b, c, d, f, g, h, n, o, p);
- final Matrix3 m03 = new Matrix3(b, c, d, f, g, h, j, k, l);
- final Matrix3 m10 = new Matrix3(e, g, h, i, k, l, m, o, p);
- final Matrix3 m11 = new Matrix3(a, c, d, i, k, l, m, o, p);
- final Matrix3 m12 = new Matrix3(a, c, d, e, g, h, m, o, p);
- final Matrix3 m13 = new Matrix3(a, c, d, e, g, h, i, k, l);
- final Matrix3 m20 = new Matrix3(e, f, h, i, j, l, m, n, p);
- final Matrix3 m21 = new Matrix3(a, b, d, i, j, l, m, n, p);
- final Matrix3 m22 = new Matrix3(a, b, d, e, f, h, m, n, p);
- final Matrix3 m23 = new Matrix3(a, b, d, e, f, h, i, j, l);
- final Matrix3 m30 = new Matrix3(e, f, g, i, j, k, m, n, o);
- final Matrix3 m31 = new Matrix3(a, b, c, i, j, k, m, n, o);
- final Matrix3 m32 = new Matrix3(a, b, c, e, f, g, m, n, o);
- final Matrix3 m33 = new Matrix3(a, b, c, e, f, g, i, j, k);
-
- // generate adjugate
- final Matrix4 testValue = new Matrix4( //
- m00.determinant(), -m01.determinant(), m02.determinant(), -m03.determinant(), //
- -m10.determinant(), m11.determinant(), -m12.determinant(), m13.determinant(), //
- m20.determinant(), -m21.determinant(), m22.determinant(), -m23.determinant(), //
- -m30.determinant(), m31.determinant(), -m32.determinant(), m33.determinant());
-
- assertEquals(testValue, mat4A.adjugate(null));
- assertEquals(testValue, mat4A.adjugateLocal());
- }
-
- @Test
- public void testDeterminant() {
- {
- final double //
- a = -3, b = 2, c = -5, d = 2, //
- e = -1, f = 0, g = -2, h = 3, //
- i = 1, j = -3, k = -4, l = 0, //
- m = 4, n = 2, o = 3, p = 1;
-
- final Matrix4 mat4A = new Matrix4( //
- a, b, c, d,//
- e, f, g, h, //
- i, j, k, l, //
- m, n, o, p);
-
- // prepare sections
- final double m00 = new Matrix3(f, g, h, j, k, l, n, o, p).determinant();
- final double m01 = new Matrix3(e, g, h, i, k, l, m, o, p).determinant();
- final double m02 = new Matrix3(e, f, h, i, j, l, m, n, p).determinant();
- final double m03 = new Matrix3(e, f, g, i, j, k, m, n, o).determinant();
- final double determinant = a * m00 - b * m01 + c * m02 - d * m03;
-
- assertTrue(Math.abs(determinant - mat4A.determinant()) <= MathUtils.EPSILON);
- }
-
- {
- final double //
- a = -1.2, b = 4, c = -2.5, d = 1.7, //
- e = 2, f = -3, g = -2, h = 3.2, //
- i = 3.1, j = -1, k = 2, l = 1.15, //
- m = 1, n = 2, o = 3.14, p = 1.4;
-
- final Matrix4 mat4A = new Matrix4( //
- a, b, c, d,//
- e, f, g, h, //
- i, j, k, l, //
- m, n, o, p);
-
- // prepare sections
- final double m00 = new Matrix3(f, g, h, j, k, l, n, o, p).determinant();
- final double m01 = new Matrix3(e, g, h, i, k, l, m, o, p).determinant();
- final double m02 = new Matrix3(e, f, h, i, j, l, m, n, p).determinant();
- final double m03 = new Matrix3(e, f, g, i, j, k, m, n, o).determinant();
- final double determinant = a * m00 - b * m01 + c * m02 - d * m03;
-
- assertTrue(Math.abs(determinant - mat4A.determinant()) <= MathUtils.EPSILON);
- }
- }
-
- @Test
- public void testClone() {
- final Matrix4 mat1 = new Matrix4();
- final Matrix4 mat2 = mat1.clone();
- assertEquals(mat1, mat2);
- assertNotSame(mat1, mat2);
- }
-
- @Test
- public void testValid() {
- final Matrix4 mat4 = new Matrix4();
- assertTrue(Matrix4.isValid(mat4));
- for (int i = 0; i < 16; i++) {
- mat4.setIdentity();
- mat4.setValue(i / 4, i % 4, Double.NaN);
- assertFalse(Matrix4.isValid(mat4));
- mat4.setIdentity();
- mat4.setValue(i / 4, i % 4, Double.POSITIVE_INFINITY);
- assertFalse(Matrix4.isValid(mat4));
- }
-
- mat4.setIdentity();
- assertTrue(Matrix4.isValid(mat4));
-
- assertFalse(Matrix4.isValid(null));
-
- // couple of equals validity tests
- assertEquals(mat4, mat4);
- assertTrue(mat4.strictEquals(mat4));
- assertFalse(mat4.equals(null));
- assertFalse(mat4.strictEquals(null));
- assertFalse(mat4.equals(new Vector2()));
- assertFalse(mat4.strictEquals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Matrix4 matTemp = Matrix4.fetchTempInstance();
- matTemp.set(mat4);
- assertEquals(mat4, matTemp);
- assertNotSame(mat4, matTemp);
- Matrix4.releaseTempInstance(matTemp);
-
- // cover more of equals
- mat4.set(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- final Matrix4 comp = new Matrix4(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
- assertFalse(mat4.equals(comp));
- assertFalse(mat4.strictEquals(comp));
- for (int i = 0; i < 15; i++) {
- comp.setValue(i / 4, i % 4, i);
- assertFalse(mat4.equals(comp));
- assertFalse(mat4.strictEquals(comp));
- }
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Matrix4 mat1 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
- final Matrix4 mat2 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
- final Matrix4 mat3 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0);
-
- assertTrue(mat1.hashCode() == mat2.hashCode());
- assertTrue(mat1.hashCode() != mat3.hashCode());
- }
-
- @Test
- public void testOrthonormal() {
- final Matrix4 mat4 = new Matrix4();
- assertTrue(mat4.isOrthonormal());
- // just rotation
- mat4.set(new Matrix3().applyRotationX(MathUtils.QUARTER_PI));
- assertTrue(mat4.isOrthonormal());
- // non-uniform scale
- mat4.set(new Matrix3().scaleLocal(new Vector3(1, 2, 3)).applyRotationX(MathUtils.QUARTER_PI));
- assertFalse(mat4.isOrthonormal());
- // uniform scale
- mat4.set(new Matrix3().scaleLocal(new Vector3(2, 2, 2)).applyRotationX(MathUtils.QUARTER_PI));
- assertFalse(mat4.isOrthonormal());
- // uniform scale 1
- mat4.set(new Matrix3().scaleLocal(new Vector3(1, 1, 1)).applyRotationX(MathUtils.QUARTER_PI));
- assertTrue(mat4.isOrthonormal());
- }
-
- @Test
- public void testApplyVector4() {
- final Matrix4 mat4 = new Matrix4().applyRotationX(MathUtils.HALF_PI);
- final Vector4 vec4 = new Vector4(0, 1, 0, 1);
- final Vector4 result = mat4.applyPost(vec4, null);
- assertTrue(Math.abs(new Vector4(0, 0, 1, 1).distance(result)) <= MathUtils.EPSILON);
- vec4.set(0, 1, 1, 1);
- mat4.applyPost(vec4, result);
- assertTrue(Math.abs(new Vector4(0, -1, 1, 1).distance(result)) <= MathUtils.EPSILON);
-
- vec4.set(0, 1, 1, 1);
- mat4.applyPre(vec4, result);
- assertTrue(Math.abs(new Vector4(0, 1, -1, 1).distance(result)) <= MathUtils.EPSILON);
-
- vec4.set(1, 1, 1, 1);
- assertTrue(Math.abs(new Vector4(1, 1, -1, 1).distance(mat4.applyPre(vec4, null))) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testApplyVector3() {
- final Matrix4 mat4 = new Matrix4().applyRotationX(MathUtils.HALF_PI).applyTranslationPre(1, 2, 3);
- final Vector3 vec3 = new Vector3(0, 1, 0);
- final Vector3 result = mat4.applyPostPoint(vec3, null);
- assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON);
- vec3.set(0, 1, 1);
- mat4.applyPostPoint(vec3, result);
- assertTrue(Math.abs(new Vector3(1, 1, 4).distance(result)) <= MathUtils.EPSILON);
-
- vec3.set(0, 1, 1);
- mat4.applyPostVector(vec3, result);
- assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result)) <= MathUtils.EPSILON);
-
- vec3.set(1, 1, 1);
- assertTrue(Math.abs(new Vector3(1, -1, 1).distance(mat4.applyPostVector(vec3, null))) <= MathUtils.EPSILON);
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import org.junit.Test; + +public class TestMatrix4 { + + @Test + public void testGetSet() { + final Matrix4 mat4A = new Matrix4(); + assertEquals(Matrix4.IDENTITY, mat4A); + + mat4A.setM00(0.0); + mat4A.setM01(0.1); + mat4A.setM02(0.2); + mat4A.setM03(0.3); + mat4A.setM10(1.0); + mat4A.setM11(1.1); + mat4A.setM12(1.2); + mat4A.setM13(1.3); + mat4A.setM20(2.0); + mat4A.setM21(2.1); + mat4A.setM22(2.2); + mat4A.setM23(2.3); + mat4A.setM30(3.0); + mat4A.setM31(3.1); + mat4A.setM32(3.2); + mat4A.setM33(3.3); + + assertTrue(0.0 == mat4A.getM00()); + assertTrue(0.1 == mat4A.getM01()); + assertTrue(0.2 == mat4A.getM02()); + assertTrue(0.3 == mat4A.getM03()); + assertTrue(1.0 == mat4A.getM10()); + assertTrue(1.1 == mat4A.getM11()); + assertTrue(1.2 == mat4A.getM12()); + assertTrue(1.3 == mat4A.getM13()); + assertTrue(2.0 == mat4A.getM20()); + assertTrue(2.1 == mat4A.getM21()); + assertTrue(2.2 == mat4A.getM22()); + assertTrue(2.3 == mat4A.getM23()); + assertTrue(3.0 == mat4A.getM30()); + assertTrue(3.1 == mat4A.getM31()); + assertTrue(3.2 == mat4A.getM32()); + assertTrue(3.3 == mat4A.getM33()); + + final Matrix4 mat4B = new Matrix4(mat4A); + assertTrue(0.0 == mat4B.getM00()); + assertTrue(0.1 == mat4B.getM01()); + assertTrue(0.2 == mat4B.getM02()); + assertTrue(0.3 == mat4B.getM03()); + assertTrue(1.0 == mat4B.getM10()); + assertTrue(1.1 == mat4B.getM11()); + assertTrue(1.2 == mat4B.getM12()); + assertTrue(1.3 == mat4B.getM13()); + assertTrue(2.0 == mat4B.getM20()); + assertTrue(2.1 == mat4B.getM21()); + assertTrue(2.2 == mat4B.getM22()); + assertTrue(2.3 == mat4B.getM23()); + assertTrue(3.0 == mat4B.getM30()); + assertTrue(3.1 == mat4B.getM31()); + assertTrue(3.2 == mat4B.getM32()); + assertTrue(3.3 == mat4B.getM33()); + + final Matrix4 mat4C = new Matrix4(0.0, 0.1, 0.2, 0.3, 1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2, + 3.3); + assertTrue(0.0 == mat4C.getM00()); + assertTrue(0.1 == mat4C.getM01()); + assertTrue(0.2 == mat4C.getM02()); + assertTrue(0.3 == mat4C.getM03()); + assertTrue(1.0 == mat4C.getM10()); + assertTrue(1.1 == mat4C.getM11()); + assertTrue(1.2 == mat4C.getM12()); + assertTrue(1.3 == mat4C.getM13()); + assertTrue(2.0 == mat4C.getM20()); + assertTrue(2.1 == mat4C.getM21()); + assertTrue(2.2 == mat4C.getM22()); + assertTrue(2.3 == mat4C.getM23()); + assertTrue(3.0 == mat4C.getM30()); + assertTrue(3.1 == mat4C.getM31()); + assertTrue(3.2 == mat4C.getM32()); + assertTrue(3.3 == mat4C.getM33()); + + mat4C.setIdentity(); + assertTrue(mat4C.isIdentity()); + + for (int x = 0; x < 4; x++) { + for (int y = 0; y < 4; y++) { + final double value = (10 * x + y) / 10.; + mat4C.setValue(x, y, value); + assertTrue(value == mat4C.getValue(x, y)); + } + } + + mat4C.setIdentity(); + mat4C.set(0.0, 0.1, 0.2, 0.3, 2.0, 2.1, 2.2, 2.3, 4.0, 4.1, 4.2, 4.3, 6.0, 6.1, 6.2, 6.3); + for (int x = 0; x < 4; x++) { + for (int y = 0; y < 4; y++) { + assertTrue((20 * x + y) / 10.f == mat4C.getValuef(x, y)); + } + } + + final Matrix4 store = new Matrix4(mat4C); + // catch a few expected exceptions + try { + mat4C.getValue(-1, 0); + fail("getValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.getValue(0, 4); + fail("getValue(0, 4) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.getValue(1, -1); + fail("getValue(1, -1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.getValue(2, 4); + fail("getValue(2, 4) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.getValue(3, -1); + fail("getValue(3, -1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.getValue(4, 0); + fail("getValue(4, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + + try { + mat4C.setValue(-1, 0, 0); + fail("setValue(-1, 0, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.setValue(0, -1, 0); + fail("setValue(0, -1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.setValue(1, 4, 0); + fail("setValue(1, 4, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.setValue(2, -1, 0); + fail("setValue(2, -1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.setValue(3, 4, 0); + fail("setValue(3, 4, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4C.setValue(4, 0, 0); + fail("setValue(4, 0, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered mat4C + assertEquals(store, mat4C); + } + + @Test + public void testColumns() { + final Matrix4 mat4A = new Matrix4(); + mat4A.setColumn(0, new Vector4(0, 4, 8, 12)); + mat4A.setColumn(1, new Vector4(1, 5, 9, 13)); + mat4A.setColumn(2, new Vector4(2, 6, 10, 14)); + mat4A.setColumn(3, new Vector4(3, 7, 11, 15)); + assertEquals(new Vector4(0, 4, 8, 12), mat4A.getColumn(0, new Vector4())); + assertEquals(new Vector4(1, 5, 9, 13), mat4A.getColumn(1, null)); + assertEquals(new Vector4(2, 6, 10, 14), mat4A.getColumn(2, null)); + assertEquals(new Vector4(3, 7, 11, 15), mat4A.getColumn(3, null)); + try { + mat4A.getColumn(-1, null); + fail("getColumn(-1, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.getColumn(4, null); + fail("getColumn(4, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.setColumn(-1, new Vector4()); + fail("setColumn(-1, double[]) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.setColumn(4, new Vector4()); + fail("setColumn(4, double[]) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + } + + @Test + public void testRows() { + final Matrix4 mat4A = new Matrix4(); + mat4A.setRow(0, new Vector4(0, 1, 2, 3)); + mat4A.setRow(1, new Vector4(4, 5, 6, 7)); + mat4A.setRow(2, new Vector4(8, 9, 10, 11)); + mat4A.setRow(3, new Vector4(12, 13, 14, 15)); + assertEquals(new Vector4(0, 1, 2, 3), mat4A.getRow(0, new Vector4())); + assertEquals(new Vector4(4, 5, 6, 7), mat4A.getRow(1, null)); + assertEquals(new Vector4(8, 9, 10, 11), mat4A.getRow(2, null)); + assertEquals(new Vector4(12, 13, 14, 15), mat4A.getRow(3, null)); + try { + mat4A.getRow(-1, null); + fail("getRow(-1, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.getRow(4, null); + fail("getRow(4, null) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.setRow(-1, new Vector4()); + fail("setRow(-1, double[]) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + mat4A.setRow(4, new Vector4()); + fail("setRow(4, double[]) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + } + + @Test + public void testSetRotation() { + final Matrix4 mat4A = new Matrix4(0.0, 0.1, 0.2, 0.3, 1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2, + 3.3); + mat4A.set(Matrix3.IDENTITY); + assertTrue(1.0 == mat4A.getM00()); + assertTrue(0.0 == mat4A.getM01()); + assertTrue(0.0 == mat4A.getM02()); + assertTrue(0.3 == mat4A.getM03()); + assertTrue(0.0 == mat4A.getM10()); + assertTrue(1.0 == mat4A.getM11()); + assertTrue(0.0 == mat4A.getM12()); + assertTrue(1.3 == mat4A.getM13()); + assertTrue(0.0 == mat4A.getM20()); + assertTrue(0.0 == mat4A.getM21()); + assertTrue(1.0 == mat4A.getM22()); + assertTrue(2.3 == mat4A.getM23()); + assertTrue(3.0 == mat4A.getM30()); + assertTrue(3.1 == mat4A.getM31()); + assertTrue(3.2 == mat4A.getM32()); + assertTrue(3.3 == mat4A.getM33()); + + mat4A.setIdentity(); + // rotate identity 90 degrees around Y + final double a = MathUtils.HALF_PI; + final Quaternion quaternion = new Quaternion(); + quaternion.fromAngleAxis(a, Vector3.UNIT_Y); + mat4A.set(quaternion); + + assertEquals(new Matrix4( // + Math.cos(a), 0, Math.sin(a), 0, // + 0, 1, 0, 0, // + -Math.sin(a), 0, Math.cos(a), 0, // + 0, 0, 0, 1), mat4A); + } + + @Test + public void testFromBuffer() { + final FloatBuffer fb = FloatBuffer.allocate(16); + fb.put(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); + fb.flip(); + // row major + final Matrix4 mat4A = new Matrix4().fromFloatBuffer(fb); + assertTrue(0 == mat4A.getM00()); + assertTrue(1 == mat4A.getM01()); + assertTrue(2 == mat4A.getM02()); + assertTrue(3 == mat4A.getM03()); + assertTrue(4 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(6 == mat4A.getM12()); + assertTrue(7 == mat4A.getM13()); + assertTrue(8 == mat4A.getM20()); + assertTrue(9 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(11 == mat4A.getM23()); + assertTrue(12 == mat4A.getM30()); + assertTrue(13 == mat4A.getM31()); + assertTrue(14 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + + // column major + fb.rewind(); + mat4A.setIdentity(); + mat4A.fromFloatBuffer(fb, false); + assertTrue(0 == mat4A.getM00()); + assertTrue(4 == mat4A.getM01()); + assertTrue(8 == mat4A.getM02()); + assertTrue(12 == mat4A.getM03()); + assertTrue(1 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(9 == mat4A.getM12()); + assertTrue(13 == mat4A.getM13()); + assertTrue(2 == mat4A.getM20()); + assertTrue(6 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(14 == mat4A.getM23()); + assertTrue(3 == mat4A.getM30()); + assertTrue(7 == mat4A.getM31()); + assertTrue(11 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + + final DoubleBuffer db = DoubleBuffer.allocate(16); + db.put(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); + db.flip(); + // row major + mat4A.setIdentity(); + mat4A.fromDoubleBuffer(db); + assertTrue(0 == mat4A.getM00()); + assertTrue(1 == mat4A.getM01()); + assertTrue(2 == mat4A.getM02()); + assertTrue(3 == mat4A.getM03()); + assertTrue(4 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(6 == mat4A.getM12()); + assertTrue(7 == mat4A.getM13()); + assertTrue(8 == mat4A.getM20()); + assertTrue(9 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(11 == mat4A.getM23()); + assertTrue(12 == mat4A.getM30()); + assertTrue(13 == mat4A.getM31()); + assertTrue(14 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + + // column major + db.rewind(); + mat4A.setIdentity(); + mat4A.fromDoubleBuffer(db, false); + assertTrue(0 == mat4A.getM00()); + assertTrue(4 == mat4A.getM01()); + assertTrue(8 == mat4A.getM02()); + assertTrue(12 == mat4A.getM03()); + assertTrue(1 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(9 == mat4A.getM12()); + assertTrue(13 == mat4A.getM13()); + assertTrue(2 == mat4A.getM20()); + assertTrue(6 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(14 == mat4A.getM23()); + assertTrue(3 == mat4A.getM30()); + assertTrue(7 == mat4A.getM31()); + assertTrue(11 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + } + + @Test + public void testToBuffer() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + final double[] colmajor = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 }; + + final Matrix4 mat4A = new Matrix4().fromArray(values); + + // row major + final FloatBuffer fb = mat4A.toFloatBuffer(FloatBuffer.allocate(16)); + fb.flip(); + for (int i = 0; i < 16; i++) { + assertTrue(values[i] == fb.get()); + } + + // column major + fb.rewind(); + mat4A.toFloatBuffer(fb, false); + fb.flip(); + for (int i = 0; i < 16; i++) { + assertTrue(colmajor[i] == fb.get()); + } + + // row major + final DoubleBuffer db = mat4A.toDoubleBuffer(DoubleBuffer.allocate(16)); + db.flip(); + for (int i = 0; i < 16; i++) { + assertTrue(values[i] == db.get()); + } + + // column major + db.rewind(); + mat4A.toDoubleBuffer(db, false); + db.flip(); + for (int i = 0; i < 16; i++) { + assertTrue(colmajor[i] == db.get()); + } + } + + @Test + public void testFromArray() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + final Matrix4 mat4A = new Matrix4(); + + // row major + mat4A.setIdentity(); + mat4A.fromArray(values); + assertTrue(0 == mat4A.getM00()); + assertTrue(1 == mat4A.getM01()); + assertTrue(2 == mat4A.getM02()); + assertTrue(3 == mat4A.getM03()); + assertTrue(4 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(6 == mat4A.getM12()); + assertTrue(7 == mat4A.getM13()); + assertTrue(8 == mat4A.getM20()); + assertTrue(9 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(11 == mat4A.getM23()); + assertTrue(12 == mat4A.getM30()); + assertTrue(13 == mat4A.getM31()); + assertTrue(14 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + + // column major + mat4A.setIdentity(); + mat4A.fromArray(values, false); + assertTrue(0 == mat4A.getM00()); + assertTrue(4 == mat4A.getM01()); + assertTrue(8 == mat4A.getM02()); + assertTrue(12 == mat4A.getM03()); + assertTrue(1 == mat4A.getM10()); + assertTrue(5 == mat4A.getM11()); + assertTrue(9 == mat4A.getM12()); + assertTrue(13 == mat4A.getM13()); + assertTrue(2 == mat4A.getM20()); + assertTrue(6 == mat4A.getM21()); + assertTrue(10 == mat4A.getM22()); + assertTrue(14 == mat4A.getM23()); + assertTrue(3 == mat4A.getM30()); + assertTrue(7 == mat4A.getM31()); + assertTrue(11 == mat4A.getM32()); + assertTrue(15 == mat4A.getM33()); + } + + @Test + public void testToArray() { + final double[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + final Matrix4 mat4A = new Matrix4().fromArray(values); + + // row major + final double[] dbls1 = mat4A.toArray(null); + for (int i = 0; i < 16; i++) { + assertTrue(values[i] == dbls1[i]); + } + + // column major + final double[] colmajor = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 }; + mat4A.toArray(dbls1, false); + for (int i = 0; i < 16; i++) { + assertTrue(colmajor[i] == dbls1[i]); + } + } + + @Test(expected = IllegalArgumentException.class) + public void testBadArray() { + final Matrix4 mat4A = new Matrix4(); + mat4A.toArray(new double[9]); + } + + @Test + public void testAngleAxis() { + final Matrix4 mat4A = new Matrix4(); + // rotate identity 90 degrees around X + final double angle = MathUtils.HALF_PI; + mat4A.fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_X); + assertEquals(new Matrix4( // + 1, 0, 0, 0, // + 0, Math.cos(angle), -Math.sin(angle), 0, // + 0, Math.sin(angle), Math.cos(angle), 0, // + 0, 0, 0, 1), mat4A); + } + + @Test + public void testRotations() { + final Vector4 rotated = new Vector4(); + final Vector4 expected = new Vector4(); + final Matrix4 worker = new Matrix4(); + + // test axis rotation methods against general purpose + // X AXIS + expected.set(1, 1, 1, 1); + rotated.set(1, 1, 1, 1); + worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Y AXIS + expected.set(1, 1, 1, 1); + rotated.set(1, 1, 1, 1); + worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Z AXIS + expected.set(1, 1, 1, 1); + rotated.set(1, 1, 1, 1); + worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).applyPost(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).applyPost(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + } + + @Test + public void testTranslation() { + final Matrix4 src = new Matrix4(); + src.applyRotation(MathUtils.QUARTER_PI, 1, 0, 0); + + final Matrix4 trans = new Matrix4(); + trans.setColumn(3, new Vector4(1, 2, 3, 1)); + final Matrix4 transThenRotate = trans.multiply(src, null); + final Matrix4 rotateThenTrans = src.multiply(trans, null); + + final Matrix4 pre1 = new Matrix4(src).applyTranslationPre(1, 2, 3); + final Matrix4 post1 = new Matrix4(src).applyTranslationPost(1, 2, 3); + + assertEquals(transThenRotate, pre1); + assertEquals(rotateThenTrans, post1); + } + + @Test + public void testMultiplyDiagonal() { + final Matrix4 mat4A = new Matrix4(); + Matrix4 result = mat4A.multiplyDiagonalPost(new Vector4(2, 4, 6, 8), null); + assertEquals(new Matrix4( // + 2, 0, 0, 0, // + 0, 4, 0, 0, // + 0, 0, 6, 0, // + 0, 0, 0, 8), result); + mat4A.multiplyDiagonalPre(new Vector4(-2, -4, -6, -8), result); + assertEquals(new Matrix4( // + -2, 0, 0, 0, // + 0, -4, 0, 0, // + 0, 0, -6, 0, // + 0, 0, 0, -8), result); + + final double a = MathUtils.HALF_PI; + mat4A.applyRotationY(a); + mat4A.multiplyDiagonalPost(new Vector4(2, 4, 6, 8), result); + assertEquals(new Matrix4( // + 2 * Math.cos(a), 4 * 0, 6 * Math.sin(a), 8 * 0, // + 2 * 0, 4 * 1, 6 * 0, 8 * 0, // + 2 * -Math.sin(a), 4 * 0, 6 * Math.cos(a), 8 * 0, // + 2 * 0, 4 * 0, 6 * 0, 8 * 1), result); + result = mat4A.multiplyDiagonalPre(new Vector4(-2, -4, -6, -8), null); + assertEquals(new Matrix4( // + -2 * Math.cos(a), -2 * 0, -2 * Math.sin(a), -2 * 0, // + -4 * 0, -4 * 1, -4 * 0, -4 * 0, // + -6 * -Math.sin(a), -6 * 0, -6 * Math.cos(a), -6 * 0, // + -8 * 0, -8 * 0, -8 * 0, -8 * 1), result); + } + + @Test + public void testMultiply() { + final Matrix4 mat4A = new Matrix4( // + 0.01, 0.1, 0.2, 0.3, // + 1.0, 1.1, 1.2, 1.3, // + 2.0, 2.1, 2.2, 2.3, // + 3.0, 3.1, 3.2, 3.3); + mat4A.multiplyLocal(2); + assertEquals(new Matrix4( // + 0.02, 0.2, 0.4, 0.6, // + 2.0, 2.2, 2.4, 2.6, // + 4.0, 4.2, 4.4, 4.6, // + 6.0, 6.2, 6.4, 6.6), mat4A); + + final Matrix4 mat4B = new Matrix4( // + 0.5, 1, 2, 3, // + 4, 5, 6, 7, // + 8, 9, 10, 11, // + 12, 13, 14, 15); + final Matrix4 result = mat4A.multiply(mat4B, null); + assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 + 0.6 * 12 == result.getM00()); + assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 + 0.6 * 13 == result.getM01()); + assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 + 0.6 * 14 == result.getM02()); + assertTrue(0.02 * 3 + 0.2 * 7 + 0.4 * 11 + 0.6 * 15 == result.getM03()); + assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 + 2.6 * 12 == result.getM10()); + assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 + 2.6 * 13 == result.getM11()); + assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 + 2.6 * 14 == result.getM12()); + assertTrue(2.0 * 3 + 2.2 * 7 + 2.4 * 11 + 2.6 * 15 == result.getM13()); + assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 + 4.6 * 12 == result.getM20()); + assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 + 4.6 * 13 == result.getM21()); + assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 + 4.6 * 14 == result.getM22()); + assertTrue(4.0 * 3 + 4.2 * 7 + 4.4 * 11 + 4.6 * 15 == result.getM23()); + assertTrue(6.0 * 0.5 + 6.2 * 4 + 6.4 * 8 + 6.6 * 12 == result.getM30()); + assertTrue(6.0 * 1 + 6.2 * 5 + 6.4 * 9 + 6.6 * 13 == result.getM31()); + assertTrue(6.0 * 2 + 6.2 * 6 + 6.4 * 10 + 6.6 * 14 == result.getM32()); + assertTrue(6.0 * 3 + 6.2 * 7 + 6.4 * 11 + 6.6 * 15 == result.getM33()); + mat4A.multiplyLocal(mat4B); + assertTrue(0.02 * 0.5 + 0.2 * 4 + 0.4 * 8 + 0.6 * 12 == mat4A.getM00()); + assertTrue(0.02 * 1 + 0.2 * 5 + 0.4 * 9 + 0.6 * 13 == mat4A.getM01()); + assertTrue(0.02 * 2 + 0.2 * 6 + 0.4 * 10 + 0.6 * 14 == mat4A.getM02()); + assertTrue(0.02 * 3 + 0.2 * 7 + 0.4 * 11 + 0.6 * 15 == mat4A.getM03()); + assertTrue(2.0 * 0.5 + 2.2 * 4 + 2.4 * 8 + 2.6 * 12 == mat4A.getM10()); + assertTrue(2.0 * 1 + 2.2 * 5 + 2.4 * 9 + 2.6 * 13 == mat4A.getM11()); + assertTrue(2.0 * 2 + 2.2 * 6 + 2.4 * 10 + 2.6 * 14 == mat4A.getM12()); + assertTrue(2.0 * 3 + 2.2 * 7 + 2.4 * 11 + 2.6 * 15 == mat4A.getM13()); + assertTrue(4.0 * 0.5 + 4.2 * 4 + 4.4 * 8 + 4.6 * 12 == mat4A.getM20()); + assertTrue(4.0 * 1 + 4.2 * 5 + 4.4 * 9 + 4.6 * 13 == mat4A.getM21()); + assertTrue(4.0 * 2 + 4.2 * 6 + 4.4 * 10 + 4.6 * 14 == mat4A.getM22()); + assertTrue(4.0 * 3 + 4.2 * 7 + 4.4 * 11 + 4.6 * 15 == mat4A.getM23()); + assertTrue(6.0 * 0.5 + 6.2 * 4 + 6.4 * 8 + 6.6 * 12 == mat4A.getM30()); + assertTrue(6.0 * 1 + 6.2 * 5 + 6.4 * 9 + 6.6 * 13 == mat4A.getM31()); + assertTrue(6.0 * 2 + 6.2 * 6 + 6.4 * 10 + 6.6 * 14 == mat4A.getM32()); + assertTrue(6.0 * 3 + 6.2 * 7 + 6.4 * 11 + 6.6 * 15 == mat4A.getM33()); + } + + @Test + public void testAddSubtract() { + final Matrix4 mat4A = new Matrix4( // + 0.0, 0.1, 0.2, 0.3, // + 1.0, 1.1, 1.2, 1.3, // + 2.0, 2.1, 2.2, 2.3, // + 3.0, 3.1, 3.2, 3.3); + + final Matrix4 result1 = mat4A.add(new Matrix4(// + 1, 2, 3, 4,// + 5, 6, 7, 8,// + 9, 10, 11, 12,// + 13, 14, 15, 16), null); + assertEquals(new Matrix4( // + 1.0, 2.1, 3.2, 4.3, // + 6.0, 7.1, 8.2, 9.3, // + 11.0, 12.1, 13.2, 14.3, // + 16.0, 17.1, 18.2, 19.3), result1); + + final Matrix4 result2 = result1.subtract(new Matrix4(// + 1, 2, 3, 4,// + 5, 6, 7, 8,// + 9, 10, 11, 12,// + 13, 14, 15, 16), null); + assertEquals(mat4A, result2); + result2.addLocal(Matrix4.IDENTITY); + assertEquals(new Matrix4( // + 1.0, 0.1, 0.2, 0.3, // + 1.0, 2.1, 1.2, 1.3, // + 2.0, 2.1, 3.2, 2.3, // + 3.0, 3.1, 3.2, 4.3), result2); + + result1.subtractLocal(Matrix4.IDENTITY); + assertEquals(new Matrix4( // + 0.0, 2.1, 3.2, 4.3, // + 6.0, 6.1, 8.2, 9.3, // + 11.0, 12.1, 12.2, 14.3, // + 16.0, 17.1, 18.2, 18.3), result1); + } + + @Test + public void testScale() { + final Matrix4 mat4A = new Matrix4( // + 0.01, 0.1, 0.2, 0.3, // + 1.0, 1.1, 1.2, 1.3, // + 2.0, 2.1, 2.2, 2.3, // + 3.0, 3.1, 3.2, 3.3); + final Matrix4 result = mat4A.scale(new Vector4(-1, 2, 3, 4), null); + assertEquals(new Matrix4( // + 0.01 * -1, 0.1 * 2, 0.2 * 3, 0.3 * 4, // + 1.0 * -1, 1.1 * 2, 1.2 * 3, 1.3 * 4, // + 2.0 * -1, 2.1 * 2, 2.2 * 3, 2.3 * 4, // + 3.0 * -1, 3.1 * 2, 3.2 * 3, 3.3 * 4), result); + + result.scaleLocal(new Vector4(-1, 0.5, 1 / 3., .25)); + assertEquals(mat4A, result); + } + + @Test + public void testTranspose() { + final Matrix4 mat4A = new Matrix4( // + 0.01, 0.1, 0.2, 0.3, // + 1.0, 1.1, 1.2, 1.3, // + 2.0, 2.1, 2.2, 2.3, // + 3.0, 3.1, 3.2, 3.3); + final Matrix4 result = mat4A.transpose(null); + assertEquals(new Matrix4( // + 0.01, 1.0, 2.0, 3.0, // + 0.1, 1.1, 2.1, 3.1, // + 0.2, 1.2, 2.2, 3.2, // + 0.3, 1.3, 2.3, 3.3), result); + assertEquals(new Matrix4( // + 0.01, 0.1, 0.2, 0.3, // + 1.0, 1.1, 1.2, 1.3, // + 2.0, 2.1, 2.2, 2.3, // + 3.0, 3.1, 3.2, 3.3), result.transposeLocal()); + // coverage + final Matrix4 result2 = result.transposeLocal().transpose(new Matrix4()); + assertEquals(mat4A, result2); + } + + @Test + public void testInvert() { + final Matrix4 mat4A = new Matrix4().applyRotationX(MathUtils.QUARTER_PI).applyTranslationPost(1, 2, 3); + final Matrix4 inverted = mat4A.invert(null); + assertEquals(Matrix4.IDENTITY, mat4A.multiply(inverted, null)); + assertEquals(mat4A, inverted.invertLocal()); + } + + @Test(expected = ArithmeticException.class) + public void testBadInvert() { + final Matrix4 mat4A = new Matrix4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + mat4A.invertLocal(); + } + + @Test + public void testAdjugate() { + final double // + a = -3, b = 2, c = -5, d = 2, // + e = -1, f = 0, g = -2, h = 3, // + i = 1, j = -3, k = -4, l = 0, // + m = 4, n = 2, o = 3, p = 1; + + final Matrix4 mat4A = new Matrix4( // + a, b, c, d,// + e, f, g, h, // + i, j, k, l, // + m, n, o, p); + + // prepare sections + final Matrix3 m00 = new Matrix3(f, g, h, j, k, l, n, o, p); + final Matrix3 m01 = new Matrix3(b, c, d, j, k, l, n, o, p); + final Matrix3 m02 = new Matrix3(b, c, d, f, g, h, n, o, p); + final Matrix3 m03 = new Matrix3(b, c, d, f, g, h, j, k, l); + final Matrix3 m10 = new Matrix3(e, g, h, i, k, l, m, o, p); + final Matrix3 m11 = new Matrix3(a, c, d, i, k, l, m, o, p); + final Matrix3 m12 = new Matrix3(a, c, d, e, g, h, m, o, p); + final Matrix3 m13 = new Matrix3(a, c, d, e, g, h, i, k, l); + final Matrix3 m20 = new Matrix3(e, f, h, i, j, l, m, n, p); + final Matrix3 m21 = new Matrix3(a, b, d, i, j, l, m, n, p); + final Matrix3 m22 = new Matrix3(a, b, d, e, f, h, m, n, p); + final Matrix3 m23 = new Matrix3(a, b, d, e, f, h, i, j, l); + final Matrix3 m30 = new Matrix3(e, f, g, i, j, k, m, n, o); + final Matrix3 m31 = new Matrix3(a, b, c, i, j, k, m, n, o); + final Matrix3 m32 = new Matrix3(a, b, c, e, f, g, m, n, o); + final Matrix3 m33 = new Matrix3(a, b, c, e, f, g, i, j, k); + + // generate adjugate + final Matrix4 testValue = new Matrix4( // + m00.determinant(), -m01.determinant(), m02.determinant(), -m03.determinant(), // + -m10.determinant(), m11.determinant(), -m12.determinant(), m13.determinant(), // + m20.determinant(), -m21.determinant(), m22.determinant(), -m23.determinant(), // + -m30.determinant(), m31.determinant(), -m32.determinant(), m33.determinant()); + + assertEquals(testValue, mat4A.adjugate(null)); + assertEquals(testValue, mat4A.adjugateLocal()); + } + + @Test + public void testDeterminant() { + { + final double // + a = -3, b = 2, c = -5, d = 2, // + e = -1, f = 0, g = -2, h = 3, // + i = 1, j = -3, k = -4, l = 0, // + m = 4, n = 2, o = 3, p = 1; + + final Matrix4 mat4A = new Matrix4( // + a, b, c, d,// + e, f, g, h, // + i, j, k, l, // + m, n, o, p); + + // prepare sections + final double m00 = new Matrix3(f, g, h, j, k, l, n, o, p).determinant(); + final double m01 = new Matrix3(e, g, h, i, k, l, m, o, p).determinant(); + final double m02 = new Matrix3(e, f, h, i, j, l, m, n, p).determinant(); + final double m03 = new Matrix3(e, f, g, i, j, k, m, n, o).determinant(); + final double determinant = a * m00 - b * m01 + c * m02 - d * m03; + + assertTrue(Math.abs(determinant - mat4A.determinant()) <= MathUtils.EPSILON); + } + + { + final double // + a = -1.2, b = 4, c = -2.5, d = 1.7, // + e = 2, f = -3, g = -2, h = 3.2, // + i = 3.1, j = -1, k = 2, l = 1.15, // + m = 1, n = 2, o = 3.14, p = 1.4; + + final Matrix4 mat4A = new Matrix4( // + a, b, c, d,// + e, f, g, h, // + i, j, k, l, // + m, n, o, p); + + // prepare sections + final double m00 = new Matrix3(f, g, h, j, k, l, n, o, p).determinant(); + final double m01 = new Matrix3(e, g, h, i, k, l, m, o, p).determinant(); + final double m02 = new Matrix3(e, f, h, i, j, l, m, n, p).determinant(); + final double m03 = new Matrix3(e, f, g, i, j, k, m, n, o).determinant(); + final double determinant = a * m00 - b * m01 + c * m02 - d * m03; + + assertTrue(Math.abs(determinant - mat4A.determinant()) <= MathUtils.EPSILON); + } + } + + @Test + public void testClone() { + final Matrix4 mat1 = new Matrix4(); + final Matrix4 mat2 = mat1.clone(); + assertEquals(mat1, mat2); + assertNotSame(mat1, mat2); + } + + @Test + public void testValid() { + final Matrix4 mat4 = new Matrix4(); + assertTrue(Matrix4.isValid(mat4)); + for (int i = 0; i < 16; i++) { + mat4.setIdentity(); + mat4.setValue(i / 4, i % 4, Double.NaN); + assertFalse(Matrix4.isValid(mat4)); + mat4.setIdentity(); + mat4.setValue(i / 4, i % 4, Double.POSITIVE_INFINITY); + assertFalse(Matrix4.isValid(mat4)); + } + + mat4.setIdentity(); + assertTrue(Matrix4.isValid(mat4)); + + assertFalse(Matrix4.isValid(null)); + + // couple of equals validity tests + assertEquals(mat4, mat4); + assertTrue(mat4.strictEquals(mat4)); + assertFalse(mat4.equals(null)); + assertFalse(mat4.strictEquals(null)); + assertFalse(mat4.equals(new Vector2())); + assertFalse(mat4.strictEquals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Matrix4 matTemp = Matrix4.fetchTempInstance(); + matTemp.set(mat4); + assertEquals(mat4, matTemp); + assertNotSame(mat4, matTemp); + Matrix4.releaseTempInstance(matTemp); + + // cover more of equals + mat4.set(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + final Matrix4 comp = new Matrix4(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1); + assertFalse(mat4.equals(comp)); + assertFalse(mat4.strictEquals(comp)); + for (int i = 0; i < 15; i++) { + comp.setValue(i / 4, i % 4, i); + assertFalse(mat4.equals(comp)); + assertFalse(mat4.strictEquals(comp)); + } + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Matrix4 mat1 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + final Matrix4 mat2 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); + final Matrix4 mat3 = new Matrix4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0); + + assertTrue(mat1.hashCode() == mat2.hashCode()); + assertTrue(mat1.hashCode() != mat3.hashCode()); + } + + @Test + public void testOrthonormal() { + final Matrix4 mat4 = new Matrix4(); + assertTrue(mat4.isOrthonormal()); + // just rotation + mat4.set(new Matrix3().applyRotationX(MathUtils.QUARTER_PI)); + assertTrue(mat4.isOrthonormal()); + // non-uniform scale + mat4.set(new Matrix3().scaleLocal(new Vector3(1, 2, 3)).applyRotationX(MathUtils.QUARTER_PI)); + assertFalse(mat4.isOrthonormal()); + // uniform scale + mat4.set(new Matrix3().scaleLocal(new Vector3(2, 2, 2)).applyRotationX(MathUtils.QUARTER_PI)); + assertFalse(mat4.isOrthonormal()); + // uniform scale 1 + mat4.set(new Matrix3().scaleLocal(new Vector3(1, 1, 1)).applyRotationX(MathUtils.QUARTER_PI)); + assertTrue(mat4.isOrthonormal()); + } + + @Test + public void testApplyVector4() { + final Matrix4 mat4 = new Matrix4().applyRotationX(MathUtils.HALF_PI); + final Vector4 vec4 = new Vector4(0, 1, 0, 1); + final Vector4 result = mat4.applyPost(vec4, null); + assertTrue(Math.abs(new Vector4(0, 0, 1, 1).distance(result)) <= MathUtils.EPSILON); + vec4.set(0, 1, 1, 1); + mat4.applyPost(vec4, result); + assertTrue(Math.abs(new Vector4(0, -1, 1, 1).distance(result)) <= MathUtils.EPSILON); + + vec4.set(0, 1, 1, 1); + mat4.applyPre(vec4, result); + assertTrue(Math.abs(new Vector4(0, 1, -1, 1).distance(result)) <= MathUtils.EPSILON); + + vec4.set(1, 1, 1, 1); + assertTrue(Math.abs(new Vector4(1, 1, -1, 1).distance(mat4.applyPre(vec4, null))) <= MathUtils.EPSILON); + } + + @Test + public void testApplyVector3() { + final Matrix4 mat4 = new Matrix4().applyRotationX(MathUtils.HALF_PI).applyTranslationPre(1, 2, 3); + final Vector3 vec3 = new Vector3(0, 1, 0); + final Vector3 result = mat4.applyPostPoint(vec3, null); + assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON); + vec3.set(0, 1, 1); + mat4.applyPostPoint(vec3, result); + assertTrue(Math.abs(new Vector3(1, 1, 4).distance(result)) <= MathUtils.EPSILON); + + vec3.set(0, 1, 1); + mat4.applyPostVector(vec3, result); + assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result)) <= MathUtils.EPSILON); + + vec3.set(1, 1, 1); + assertTrue(Math.abs(new Vector3(1, -1, 1).distance(mat4.applyPostVector(vec3, null))) <= MathUtils.EPSILON); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestObjectPool.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestObjectPool.java index 5f06c34..9ecfe95 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestObjectPool.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestObjectPool.java @@ -1,34 +1,34 @@ -/**
- * 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 org.junit.Test;
-
-public class TestObjectPool {
-
- @Test(expected = RuntimeException.class)
- public void testPoolReleaseNullError() {
- Vector2.releaseTempInstance(null);
- }
-
- @Test(expected = RuntimeException.class)
- public void testPoolBadClass() {
- ObjectPool.create(Poolable.class, 10).fetch();
- }
-
- @Test
- public void testPoolSize() {
- final ObjectPool<Vector2> pool = ObjectPool.create(Vector2.class, 10);
- for (int i = 0; i < 11; i++) {
- pool.release(new Vector2());
- }
- }
-}
+/** + * 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 org.junit.Test; + +public class TestObjectPool { + + @Test(expected = RuntimeException.class) + public void testPoolReleaseNullError() { + Vector2.releaseTempInstance(null); + } + + @Test(expected = RuntimeException.class) + public void testPoolBadClass() { + ObjectPool.create(Poolable.class, 10).fetch(); + } + + @Test + public void testPoolSize() { + final ObjectPool<Vector2> pool = ObjectPool.create(Vector2.class, 10); + for (int i = 0; i < 11; i++) { + pool.release(new Vector2()); + } + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestPlane.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestPlane.java index 1b6b164..cbae5fe 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestPlane.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestPlane.java @@ -1,136 +1,136 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-import com.ardor3d.math.type.ReadOnlyPlane.Side;
-
-public class TestPlane {
-
- @Test
- public void testGetSet() {
- final Plane plane = new Plane();
- assertEquals(Vector3.UNIT_Y, plane.getNormal());
- assertTrue(plane.getConstant() == 0.0);
-
- plane.setNormal(Vector3.UNIT_X);
- plane.setConstant(1.0);
- assertEquals(Vector3.UNIT_X, plane.getNormal());
- assertTrue(plane.getConstant() == 1.0);
-
- final Plane plane2 = new Plane(plane);
- assertEquals(Vector3.UNIT_X, plane2.getNormal());
- assertTrue(plane.getConstant() == 1.0);
-
- final Plane plane3 = new Plane(Vector3.NEG_UNIT_Z, 2.5);
- assertEquals(Vector3.NEG_UNIT_Z, plane3.getNormal());
- assertTrue(plane3.getConstant() == 2.5);
-
- final Plane plane4 = new Plane().setPlanePoints(new Vector3(1, 1, 1), new Vector3(2, 1, 1),
- new Vector3(2, 2, 1));
- assertEquals(Vector3.UNIT_Z, plane4.getNormal());
- assertTrue(plane4.getConstant() == 1.0);
- }
-
- @Test
- public void testEquals() {
- // couple of equals validity tests
- final Plane plane1 = new Plane();
- assertEquals(plane1, plane1);
- assertFalse(plane1.equals(null));
- assertFalse(plane1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Plane plane2 = Plane.fetchTempInstance();
- plane2.set(plane1);
- assertEquals(plane1, plane2);
- assertNotSame(plane1, plane2);
- Plane.releaseTempInstance(plane2);
-
- // cover more of equals
- assertFalse(plane1.equals(new Plane(Vector3.UNIT_X, 0)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Plane plane1 = new Plane(Vector3.UNIT_Y, 2);
- final Plane plane2 = new Plane(Vector3.UNIT_Y, 2);
- final Plane plane3 = new Plane(Vector3.UNIT_Z, 2);
-
- assertTrue(plane1.hashCode() == plane2.hashCode());
- assertTrue(plane1.hashCode() != plane3.hashCode());
- }
-
- @Test
- public void testClone() {
- final Plane plane1 = new Plane();
- final Plane plane2 = plane1.clone();
- assertEquals(plane1, plane2);
- assertNotSame(plane1, plane2);
- }
-
- @Test
- public void testValid() {
- final Plane plane1 = new Plane();
- final Plane plane2 = new Plane(new Vector3(Double.NaN, 0, 0), 0.5);
- final Plane plane3 = new Plane(Vector3.UNIT_X, Double.NaN);
- final Plane plane4 = new Plane(Vector3.UNIT_X, Double.POSITIVE_INFINITY);
-
- assertTrue(Plane.isValid(plane1));
- assertFalse(Plane.isValid(plane2));
- assertFalse(Plane.isValid(plane3));
- assertFalse(Plane.isValid(plane4));
-
- plane4.setConstant(1);
- assertTrue(Plane.isValid(plane4));
-
- assertFalse(Plane.isValid(null));
- }
-
- @Test
- public void testDistance() {
- final Plane plane1 = new Plane(Vector3.UNIT_Y, 1.0);
- final Vector3 point = new Vector3(0, 5, 0);
- assertTrue(4.0 == plane1.pseudoDistance(point));
- assertEquals(Side.Outside, plane1.whichSide(point));
-
- point.set(0, -4, 0);
- assertTrue(-5.0 == plane1.pseudoDistance(point));
- assertEquals(Side.Inside, plane1.whichSide(point));
-
- point.set(1, 1, 1);
- assertTrue(0.0 == plane1.pseudoDistance(point));
- assertEquals(Side.Neither, plane1.whichSide(point));
- }
-
- @Test
- public void testReflect() {
- final Plane plane1 = new Plane(Vector3.UNIT_X, 5.0);
- assertEquals(new Vector3(), plane1.reflectVector(new Vector3(), new Vector3()));
- assertEquals(new Vector3(-1, 0, 0), plane1.reflectVector(new Vector3(1, 0, 0), null));
- assertEquals(new Vector3(-1, 1, 1).normalizeLocal(),
- plane1.reflectVector(new Vector3(1, 1, 1).normalizeLocal(), null));
- assertEquals(new Vector3(-3, 2, -1).normalizeLocal(),
- plane1.reflectVector(new Vector3(3, 2, -1).normalizeLocal(), null));
-
- final Plane plane2 = new Plane(Vector3.UNIT_Z, 1.0);
- assertEquals(new Vector3(), plane2.reflectVector(new Vector3(), new Vector3()));
- assertEquals(new Vector3(0, 0, -1), plane2.reflectVector(new Vector3(0, 0, 1), null));
- assertEquals(new Vector3(1, 1, -1).normalizeLocal(),
- plane2.reflectVector(new Vector3(1, 1, 1).normalizeLocal(), null));
- assertEquals(new Vector3(3, 2, 1).normalizeLocal(),
- plane2.reflectVector(new Vector3(3, 2, -1).normalizeLocal(), null));
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +import com.ardor3d.math.type.ReadOnlyPlane.Side; + +public class TestPlane { + + @Test + public void testGetSet() { + final Plane plane = new Plane(); + assertEquals(Vector3.UNIT_Y, plane.getNormal()); + assertTrue(plane.getConstant() == 0.0); + + plane.setNormal(Vector3.UNIT_X); + plane.setConstant(1.0); + assertEquals(Vector3.UNIT_X, plane.getNormal()); + assertTrue(plane.getConstant() == 1.0); + + final Plane plane2 = new Plane(plane); + assertEquals(Vector3.UNIT_X, plane2.getNormal()); + assertTrue(plane.getConstant() == 1.0); + + final Plane plane3 = new Plane(Vector3.NEG_UNIT_Z, 2.5); + assertEquals(Vector3.NEG_UNIT_Z, plane3.getNormal()); + assertTrue(plane3.getConstant() == 2.5); + + final Plane plane4 = new Plane().setPlanePoints(new Vector3(1, 1, 1), new Vector3(2, 1, 1), + new Vector3(2, 2, 1)); + assertEquals(Vector3.UNIT_Z, plane4.getNormal()); + assertTrue(plane4.getConstant() == 1.0); + } + + @Test + public void testEquals() { + // couple of equals validity tests + final Plane plane1 = new Plane(); + assertEquals(plane1, plane1); + assertFalse(plane1.equals(null)); + assertFalse(plane1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Plane plane2 = Plane.fetchTempInstance(); + plane2.set(plane1); + assertEquals(plane1, plane2); + assertNotSame(plane1, plane2); + Plane.releaseTempInstance(plane2); + + // cover more of equals + assertFalse(plane1.equals(new Plane(Vector3.UNIT_X, 0))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Plane plane1 = new Plane(Vector3.UNIT_Y, 2); + final Plane plane2 = new Plane(Vector3.UNIT_Y, 2); + final Plane plane3 = new Plane(Vector3.UNIT_Z, 2); + + assertTrue(plane1.hashCode() == plane2.hashCode()); + assertTrue(plane1.hashCode() != plane3.hashCode()); + } + + @Test + public void testClone() { + final Plane plane1 = new Plane(); + final Plane plane2 = plane1.clone(); + assertEquals(plane1, plane2); + assertNotSame(plane1, plane2); + } + + @Test + public void testValid() { + final Plane plane1 = new Plane(); + final Plane plane2 = new Plane(new Vector3(Double.NaN, 0, 0), 0.5); + final Plane plane3 = new Plane(Vector3.UNIT_X, Double.NaN); + final Plane plane4 = new Plane(Vector3.UNIT_X, Double.POSITIVE_INFINITY); + + assertTrue(Plane.isValid(plane1)); + assertFalse(Plane.isValid(plane2)); + assertFalse(Plane.isValid(plane3)); + assertFalse(Plane.isValid(plane4)); + + plane4.setConstant(1); + assertTrue(Plane.isValid(plane4)); + + assertFalse(Plane.isValid(null)); + } + + @Test + public void testDistance() { + final Plane plane1 = new Plane(Vector3.UNIT_Y, 1.0); + final Vector3 point = new Vector3(0, 5, 0); + assertTrue(4.0 == plane1.pseudoDistance(point)); + assertEquals(Side.Outside, plane1.whichSide(point)); + + point.set(0, -4, 0); + assertTrue(-5.0 == plane1.pseudoDistance(point)); + assertEquals(Side.Inside, plane1.whichSide(point)); + + point.set(1, 1, 1); + assertTrue(0.0 == plane1.pseudoDistance(point)); + assertEquals(Side.Neither, plane1.whichSide(point)); + } + + @Test + public void testReflect() { + final Plane plane1 = new Plane(Vector3.UNIT_X, 5.0); + assertEquals(new Vector3(), plane1.reflectVector(new Vector3(), new Vector3())); + assertEquals(new Vector3(-1, 0, 0), plane1.reflectVector(new Vector3(1, 0, 0), null)); + assertEquals(new Vector3(-1, 1, 1).normalizeLocal(), + plane1.reflectVector(new Vector3(1, 1, 1).normalizeLocal(), null)); + assertEquals(new Vector3(-3, 2, -1).normalizeLocal(), + plane1.reflectVector(new Vector3(3, 2, -1).normalizeLocal(), null)); + + final Plane plane2 = new Plane(Vector3.UNIT_Z, 1.0); + assertEquals(new Vector3(), plane2.reflectVector(new Vector3(), new Vector3())); + assertEquals(new Vector3(0, 0, -1), plane2.reflectVector(new Vector3(0, 0, 1), null)); + assertEquals(new Vector3(1, 1, -1).normalizeLocal(), + plane2.reflectVector(new Vector3(1, 1, 1).normalizeLocal(), null)); + assertEquals(new Vector3(3, 2, 1).normalizeLocal(), + plane2.reflectVector(new Vector3(3, 2, -1).normalizeLocal(), null)); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestQuaternion.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestQuaternion.java index f7ee4f4..4ef89e7 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestQuaternion.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestQuaternion.java @@ -1,554 +1,554 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-import com.ardor3d.math.type.ReadOnlyVector3;
-
-public class TestQuaternion {
-
- @Test
- public void testGetSet() {
- final Quaternion quat1 = new Quaternion();
- assertEquals(Quaternion.IDENTITY, quat1);
- assertTrue(quat1.isIdentity());
-
- quat1.setX(1);
- assertTrue(quat1.getX() == 1.0);
- quat1.setX(Double.POSITIVE_INFINITY);
- assertTrue(quat1.getX() == Double.POSITIVE_INFINITY);
- quat1.setX(Double.NEGATIVE_INFINITY);
- assertTrue(quat1.getX() == Double.NEGATIVE_INFINITY);
-
- quat1.setY(1);
- assertTrue(quat1.getY() == 1.0);
- quat1.setY(Double.POSITIVE_INFINITY);
- assertTrue(quat1.getY() == Double.POSITIVE_INFINITY);
- quat1.setY(Double.NEGATIVE_INFINITY);
- assertTrue(quat1.getY() == Double.NEGATIVE_INFINITY);
-
- quat1.setZ(1);
- assertTrue(quat1.getZ() == 1.0);
- quat1.setZ(Double.POSITIVE_INFINITY);
- assertTrue(quat1.getZ() == Double.POSITIVE_INFINITY);
- quat1.setZ(Double.NEGATIVE_INFINITY);
- assertTrue(quat1.getZ() == Double.NEGATIVE_INFINITY);
-
- quat1.setW(1);
- assertTrue(quat1.getW() == 1.0);
- quat1.setW(Double.POSITIVE_INFINITY);
- assertTrue(quat1.getW() == Double.POSITIVE_INFINITY);
- quat1.setW(Double.NEGATIVE_INFINITY);
- assertTrue(quat1.getW() == Double.NEGATIVE_INFINITY);
-
- quat1.set(Math.PI, Math.PI, Math.PI, Math.PI);
- assertTrue(quat1.getXf() == (float) Math.PI);
- assertTrue(quat1.getYf() == (float) Math.PI);
- assertTrue(quat1.getZf() == (float) Math.PI);
- assertTrue(quat1.getWf() == (float) Math.PI);
-
- final Quaternion quat2 = new Quaternion();
- quat2.set(quat1);
- assertEquals(quat1, quat2);
- }
-
- @Test
- public void testToArray() {
- final Quaternion quat1 = new Quaternion();
- quat1.set(Math.PI, Double.MAX_VALUE, 42, -1);
- final double[] array = quat1.toArray(null);
- final double[] array2 = quat1.toArray(new double[4]);
- assertNotNull(array);
- assertTrue(array.length == 4);
- assertTrue(array[0] == Math.PI);
- assertTrue(array[1] == Double.MAX_VALUE);
- assertTrue(array[2] == 42);
- assertTrue(array[3] == -1);
- assertNotNull(array2);
- assertTrue(array2.length == 4);
- assertTrue(array2[0] == Math.PI);
- assertTrue(array2[1] == Double.MAX_VALUE);
- assertTrue(array2[2] == 42);
- assertTrue(array2[3] == -1);
- }
-
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void testBadArray() {
- final Quaternion quat = new Quaternion();
- quat.toArray(new double[2]);
- }
-
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void testBadAxesArray() {
- final Quaternion quat = new Quaternion();
- quat.toAxes(new Vector3[2]);
- }
-
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void testBadEuler1() {
- new Quaternion().fromEulerAngles(new double[2]);
- }
-
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void testBadEuler2() {
- final Quaternion quat = new Quaternion();
- quat.toEulerAngles(new double[2]);
- }
-
- @Test
- public void testEulerAngles() {
- final Quaternion quat = new Quaternion().fromEulerAngles(new double[] { MathUtils.HALF_PI, 0, 0 });
- assertTrue(1.0 == quat.magnitude());
- assertTrue(Math.abs(Vector3.NEG_UNIT_Z.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON);
-
- quat.fromEulerAngles(0, -MathUtils.HALF_PI, 0);
- assertTrue(1.0 == quat.magnitude());
- assertTrue(Math.abs(Vector3.NEG_UNIT_Y.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON);
-
- quat.fromEulerAngles(0, 0, MathUtils.HALF_PI);
- assertTrue(1.0 == quat.magnitude());
- assertTrue(Math.abs(Vector3.UNIT_Z.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON);
-
- quat.fromEulerAngles(0, MathUtils.HALF_PI, 0);
- double[] angles = quat.toEulerAngles(null);
- final Quaternion quat2 = new Quaternion().fromEulerAngles(angles);
- assertEquals(quat, quat2);
- quat.fromEulerAngles(0, -MathUtils.HALF_PI, 0);
- angles = quat.toEulerAngles(null);
- quat2.fromEulerAngles(angles);
- assertEquals(quat, quat2);
- quat.fromEulerAngles(0, 0, MathUtils.HALF_PI);
- angles = quat.toEulerAngles(null);
- quat2.fromEulerAngles(angles);
- assertEquals(quat, quat2);
- }
-
- @Test
- public void testMatrix3() {
- double a = MathUtils.HALF_PI;
- final Quaternion quat = new Quaternion();
- quat.fromRotationMatrix( //
- 1, 0, 0, //
- 0, Math.cos(a), -Math.sin(a), //
- 0, Math.sin(a), Math.cos(a));
-
- assertTrue(Math.abs(Vector3.UNIT_Z.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON);
- final Matrix3 mat = quat.toRotationMatrix((Matrix3) null);
- assertTrue(Math.abs(quat.apply(Vector3.NEG_ONE, null).distance(mat.applyPost(Vector3.NEG_ONE, null))) <= MathUtils.EPSILON);
-
- a = MathUtils.PI;
- quat.fromRotationMatrix( //
- 1, 0, 0, //
- 0, Math.cos(a), -Math.sin(a), //
- 0, Math.sin(a), Math.cos(a));
-
- assertTrue(Math.abs(Vector3.NEG_UNIT_Y.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON);
- quat.toRotationMatrix(mat);
- assertTrue(Math.abs(quat.apply(Vector3.ONE, null).distance(mat.applyPost(Vector3.ONE, null))) <= MathUtils.EPSILON);
-
- quat.set(0, 0, 0, 0);
- assertEquals(Matrix3.IDENTITY, quat.toRotationMatrix((Matrix3) null));
-
- a = MathUtils.PI;
- quat.fromRotationMatrix( //
- Math.cos(a), 0, Math.sin(a), //
- 0, 1, 0, //
- -Math.sin(a), 0, Math.cos(a));
-
- assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON);
- final Matrix4 mat4 = quat.toRotationMatrix((Matrix4) null);
- assertTrue(Math.abs(quat.apply(Vector3.NEG_ONE, null).distance(mat4.applyPostVector(Vector3.NEG_ONE, null))) <= MathUtils.EPSILON);
-
- a = MathUtils.PI;
- quat.fromRotationMatrix(new Matrix3(//
- Math.cos(a), -Math.sin(a), 0, //
- Math.sin(a), Math.cos(a), 0, //
- 0, 0, 1));
-
- assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON);
- quat.toRotationMatrix(mat4);
- assertTrue(Math.abs(quat.apply(Vector3.ONE, null).distance(mat4.applyPostVector(Vector3.ONE, null))) <= MathUtils.EPSILON);
-
- quat.set(0, 0, 0, 0);
- assertEquals(Matrix4.IDENTITY, quat.toRotationMatrix((Matrix4) null));
- }
-
- @Test
- public void testRotations() {
- final double a = MathUtils.QUARTER_PI;
- final Quaternion quat = new Quaternion().fromRotationMatrix(new Matrix3(//
- Math.cos(a), -Math.sin(a), 0, //
- Math.sin(a), Math.cos(a), 0, //
- 0, 0, 1));
- final Vector3 column = quat.getRotationColumn(0, null);
- assertTrue(Math.abs(new Vector3(Math.cos(a), Math.sin(a), 0).distance(column)) <= MathUtils.EPSILON);
- quat.getRotationColumn(1, column);
- assertTrue(Math.abs(new Vector3(-Math.sin(a), Math.sin(a), 0).distance(column)) <= MathUtils.EPSILON);
- quat.getRotationColumn(2, column);
- assertTrue(Math.abs(new Vector3(0, 0, 1).distance(column)) <= MathUtils.EPSILON);
-
- quat.set(0, 0, 0, 0);
- assertEquals(Vector3.UNIT_X, quat.getRotationColumn(0, null));
-
- // Try a new way with new angles...
- quat.fromEulerAngles(MathUtils.QUARTER_PI, MathUtils.PI, MathUtils.HALF_PI);
- final Vector3 rotated = new Vector3(1, 1, 1);
- quat.apply(rotated, rotated);
-
- // expected
- final Vector3 expected = new Vector3(1, 1, 1);
- final Quaternion worker = new Quaternion();
- // put together matrix, then apply to vector, so YZX
- worker.applyRotationY(MathUtils.QUARTER_PI);
- worker.applyRotationZ(MathUtils.PI);
- worker.applyRotationX(MathUtils.HALF_PI);
- worker.apply(expected, expected);
-
- // test how close it came out
- assertTrue(rotated.distance(expected) <= Quaternion.ALLOWED_DEVIANCE);
-
- // test axis rotation methods against general purpose
- // X AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).apply(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).apply(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Y AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).apply(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).apply(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- // Z AXIS
- expected.set(1, 1, 1);
- rotated.set(1, 1, 1);
- worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).apply(expected, expected);
- worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).apply(rotated, rotated);
- assertTrue(rotated.distance(expected) <= MathUtils.EPSILON);
-
- quat.set(worker);
- worker.applyRotation(0, 0, 0, 0);
- assertEquals(quat, worker);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBadRotationColumn1() {
- new Quaternion().getRotationColumn(-1, null);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testBadRotationColumn2() {
- new Quaternion().getRotationColumn(4, null);
- }
-
- @Test
- public void testAngleAxis() {
- final Quaternion quat = new Quaternion().fromAngleAxis(MathUtils.HALF_PI, new Vector3(2, 0, 0));
- final Quaternion quat2 = new Quaternion().fromAngleNormalAxis(MathUtils.HALF_PI, new Vector3(1, 0, 0));
-
- assertEquals(quat2, quat);
- assertTrue(1 - quat.magnitude() <= MathUtils.EPSILON);
-
- assertEquals(quat.apply(Vector3.ONE, null), quat2.apply(Vector3.ONE, null));
- assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(new Vector3(0, 0, 1), null))) <= MathUtils.EPSILON);
-
- assertEquals(Quaternion.IDENTITY,
- new Quaternion(1, 2, 3, 4).fromAngleAxis(MathUtils.HALF_PI, new Vector3(0, 0, 0)));
-
- final Vector3 axisStore = new Vector3();
- double angle = quat.toAngleAxis(axisStore);
- assertEquals(quat, new Quaternion().fromAngleAxis(angle, axisStore));
-
- quat.set(0, 0, 0, 0);
- angle = quat.toAngleAxis(axisStore);
- assertTrue(0.0 == angle);
- assertEquals(Vector3.UNIT_X, axisStore);
- }
-
- @Test
- public void testFromVectorToVector() {
- final Quaternion quat = new Quaternion().fromVectorToVector(Vector3.UNIT_Z, Vector3.UNIT_X);
- assertEquals(new Quaternion().fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_Y), quat);
-
- quat.fromVectorToVector(Vector3.UNIT_Z, Vector3.NEG_UNIT_Z);
- assertTrue(Math.abs(new Vector3(0, 0, -1).distance(quat.apply(new Vector3(0, 0, 1), null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat.fromVectorToVector(Vector3.UNIT_X, Vector3.NEG_UNIT_X);
- assertTrue(Math.abs(new Vector3(-1, 0, 0).distance(quat.apply(new Vector3(1, 0, 0), null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat.fromVectorToVector(Vector3.UNIT_Y, Vector3.NEG_UNIT_Y);
- assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(new Vector3(0, 1, 0), null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat.fromVectorToVector(Vector3.ONE, Vector3.NEG_ONE);
- assertTrue(Math.abs(new Vector3(-1, -1, -1).distance(quat.apply(new Vector3(1, 1, 1), null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat.fromVectorToVector(Vector3.ZERO, Vector3.ZERO);
- assertEquals(Quaternion.IDENTITY, quat);
- }
-
- @Test
- public void testNormalize() {
- final Quaternion quat = new Quaternion(0, 1, 2, 3);
- final Quaternion quat2 = quat.normalize(null);
- assertEquals(quat2, quat.normalizeLocal());
- assertTrue(Math.abs(1 - quat.magnitude()) <= MathUtils.EPSILON);
- assertTrue(Math.abs(1 - quat2.magnitude()) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testApplyToZero() {
- assertEquals(Vector3.ZERO, new Quaternion().apply(new Vector3(0, 0, 0), null));
- }
-
- @Test
- public void testInvert() {
- final Quaternion quat1 = new Quaternion(0, 1, 2, 3);
- final Quaternion quat2 = quat1.invert(null);
- assertEquals(Quaternion.IDENTITY, quat1.multiply(quat2, null));
- assertEquals(quat1, quat2.invert(new Quaternion()));
- assertEquals(quat1, quat2.invertLocal());
-
- // normalized version
- quat1.fromAngleAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y);
- quat1.invert(quat2);
- assertEquals(Quaternion.IDENTITY, quat1.multiply(quat2, null));
- assertEquals(quat1, quat2.invert(new Quaternion()));
- assertEquals(quat1, quat2.invertLocal());
-
- // conjugate check
- assertEquals(new Quaternion(-1, -2, -3, 4), new Quaternion(1, 2, 3, 4).conjugate(null));
- }
-
- @Test
- public void testAddSubtract() {
- final Quaternion quat1 = new Quaternion(0, 1, 2, 3);
- final Quaternion quat2 = new Quaternion(1, 1, 1, 1);
- assertEquals(new Quaternion(1, 2, 3, 4), quat1.add(quat2, null));
- assertEquals(new Quaternion(1, 2, 3, 4), quat1.add(quat2, new Quaternion()));
- assertEquals(new Quaternion(1, 2, 3, 4), quat1.addLocal(quat2));
-
- quat1.set(0, 1, 2, 3);
- quat2.set(1, 1, 1, 1);
- assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtract(quat2, null));
- assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtract(quat2, new Quaternion()));
- assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtractLocal(quat2));
- }
-
- @Test
- public void testMultiply() {
- final Quaternion quat1 = new Quaternion(0.5, 1, 2, 3);
- final Quaternion quat2 = new Quaternion();
- assertEquals(new Quaternion(1, 2, 4, 6), quat1.multiply(2, null));
- assertEquals(new Quaternion(2, 4, 8, 12), quat1.multiply(4, quat2));
- assertEquals(new Quaternion(1, 2, 4, 6), quat1.multiplyLocal(2));
-
- quat1.fromAngleNormalAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y);
- quat1.multiply(quat1, quat2);
-
- final ReadOnlyVector3 vec = Vector3.UNIT_Z;
- assertTrue(Math.abs(Vector3.UNIT_X.distance(quat2.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE);
- quat1.multiplyLocal(quat1.getX(), quat1.getY(), quat1.getZ(), quat1.getW());
- assertTrue(Math.abs(Vector3.UNIT_X.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE);
- quat2.fromAngleNormalAxis(MathUtils.HALF_PI, Vector3.UNIT_Y);
- quat1.multiplyLocal(quat2);
- assertTrue(Math.abs(Vector3.NEG_UNIT_Z.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat1.multiplyLocal(new Matrix3().applyRotationY(MathUtils.HALF_PI));
- assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE);
- }
-
- @Test
- public void testAxes() {
- final Matrix3 rot = new Matrix3().applyRotationX(MathUtils.QUARTER_PI).applyRotationY(MathUtils.HALF_PI);
- final Quaternion quat1 = new Quaternion().fromAxes(rot.getColumn(0, null), rot.getColumn(1, null),
- rot.getColumn(2, null));
- final Quaternion quat2 = new Quaternion().fromRotationMatrix(rot);
- assertEquals(quat2, quat1);
-
- final Vector3[] axes = quat1.toAxes(new Vector3[3]);
- quat1.fromAxes(axes[0], axes[1], axes[2]);
- assertEquals(quat2, quat1);
- }
-
- @Test
- public void testSlerp() {
- final Quaternion quat = new Quaternion();
- final Quaternion quat2 = new Quaternion().applyRotationY(MathUtils.HALF_PI);
- final Quaternion store = quat.slerp(quat2, .5, null);
- assertTrue(Math.abs(new Vector3(Math.sin(MathUtils.QUARTER_PI), 0, Math.sin(MathUtils.QUARTER_PI))
- .distance(store.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // delta == 100%
- quat2.setIdentity().applyRotationZ(MathUtils.PI);
- quat.slerp(quat2, 1.0, store);
- assertTrue(Math.abs(new Vector3(-1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat2.setIdentity().applyRotationZ(MathUtils.PI);
- quat.slerp(quat2, .5, store);
- assertTrue(Math.abs(new Vector3(0, 1, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // delta == 0%
- quat2.setIdentity().applyRotationZ(MathUtils.PI);
- quat.slerp(quat2, 0, store);
- assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // a==b
- quat2.setIdentity();
- quat.slerp(quat2, 0.25, store);
- assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // negative dot product
- quat.setIdentity().applyRotationX(-2 * MathUtils.HALF_PI);
- quat2.setIdentity().applyRotationX(MathUtils.HALF_PI);
- quat.slerp(quat2, 0.5, store);
- assertTrue(Math.abs(new Vector3(0, -Math.sin(MathUtils.QUARTER_PI), Math.sin(MathUtils.QUARTER_PI))
- .distance(store.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // LOCAL
- // delta == 100%
- quat2.setIdentity().applyRotationX(MathUtils.PI);
- quat.slerpLocal(quat2, 1.0);
- assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- quat.setIdentity();
- quat.slerpLocal(quat2, .5);
- assertTrue(Math.abs(new Vector3(0, 0, 1).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // delta == 0%
- quat.setIdentity();
- quat.slerpLocal(quat2, 0);
- assertTrue(Math.abs(new Vector3(0, 1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // a==b
- quat.setIdentity();
- quat2.setIdentity();
- quat.slerpLocal(quat2, 0.25);
- assertTrue(Math.abs(new Vector3(0, 1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- // negative dot product
- quat.setIdentity().applyRotationX(-2 * MathUtils.HALF_PI);
- quat2.setIdentity().applyRotationX(MathUtils.HALF_PI);
- quat.slerpLocal(quat2, 0.5);
- assertTrue(Math.abs(new Vector3(0, -Math.sin(MathUtils.QUARTER_PI), Math.sin(MathUtils.QUARTER_PI))
- .distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE);
- }
-
- @Test
- public void testLookAt() {
- final Vector3 direction = new Vector3(-1, 0, 0);
- final Quaternion quat = new Quaternion().lookAt(direction, Vector3.UNIT_Y);
- assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- direction.set(1, 1, 1).normalizeLocal();
- quat.lookAt(direction, Vector3.UNIT_Y);
- assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE);
-
- direction.set(-1, 2, -1).normalizeLocal();
- quat.lookAt(direction, Vector3.UNIT_Y);
- assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE);
- }
-
- @Test
- public void testDot() {
- final Quaternion quat = new Quaternion(7, 2, 5, -1);
- assertTrue(35.0 == quat.dot(3, 1, 2, -2));
-
- assertTrue(-11.0 == quat.dot(new Quaternion(-1, 1, -1, 1)));
- }
-
- @Test
- public void testClone() {
- final Quaternion quat1 = new Quaternion();
- final Quaternion quat2 = quat1.clone();
- assertEquals(quat1, quat2);
- assertNotSame(quat1, quat2);
- }
-
- @Test
- public void testValid() {
- final Quaternion quat = new Quaternion();
- assertTrue(Quaternion.isValid(quat));
-
- quat.set(Double.NaN, 0, 0, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, Double.NaN, 0, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, 0, Double.NaN, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, 0, 0, Double.NaN);
- assertFalse(Quaternion.isValid(quat));
-
- quat.set(Double.NEGATIVE_INFINITY, 0, 0, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, Double.NEGATIVE_INFINITY, 0, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, 0, Double.NEGATIVE_INFINITY, 0);
- assertFalse(Quaternion.isValid(quat));
- quat.set(0, 0, 0, Double.NEGATIVE_INFINITY);
- assertFalse(Quaternion.isValid(quat));
-
- quat.setIdentity();
- assertTrue(Quaternion.isValid(quat));
-
- assertFalse(Quaternion.isValid(null));
-
- // couple of equals validity tests
- assertEquals(quat, quat);
- assertTrue(quat.strictEquals(quat));
- assertFalse(quat.equals(null));
- assertFalse(quat.strictEquals(null));
- assertFalse(quat.equals(new Vector2()));
- assertFalse(quat.strictEquals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Quaternion quatTemp = Quaternion.fetchTempInstance();
- quatTemp.set(quat);
- assertEquals(quat, quatTemp);
- assertNotSame(quat, quatTemp);
- Quaternion.releaseTempInstance(quatTemp);
-
- // cover more of equals
- quat.set(0, 1, 2, 3);
- final Quaternion comp = new Quaternion(-1, -1, -1, -1);
- assertFalse(quat.equals(comp));
- assertFalse(quat.strictEquals(comp));
- comp.setX(0);
- assertFalse(quat.equals(comp));
- assertFalse(quat.strictEquals(comp));
- comp.setY(1);
- assertFalse(quat.equals(comp));
- assertFalse(quat.strictEquals(comp));
- comp.setZ(2);
- assertFalse(quat.equals(comp));
- assertFalse(quat.strictEquals(comp));
- comp.setW(3);
- assertEquals(quat, comp);
- assertTrue(quat.strictEquals(comp));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Quaternion quat1 = new Quaternion(1, 2, 3, 4);
- final Quaternion quat2 = new Quaternion(1, 2, 3, 4);
- final Quaternion quat3 = new Quaternion(1, 2, 3, 0);
-
- assertTrue(quat1.hashCode() == quat2.hashCode());
- assertTrue(quat1.hashCode() != quat3.hashCode());
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +import com.ardor3d.math.type.ReadOnlyVector3; + +public class TestQuaternion { + + @Test + public void testGetSet() { + final Quaternion quat1 = new Quaternion(); + assertEquals(Quaternion.IDENTITY, quat1); + assertTrue(quat1.isIdentity()); + + quat1.setX(1); + assertTrue(quat1.getX() == 1.0); + quat1.setX(Double.POSITIVE_INFINITY); + assertTrue(quat1.getX() == Double.POSITIVE_INFINITY); + quat1.setX(Double.NEGATIVE_INFINITY); + assertTrue(quat1.getX() == Double.NEGATIVE_INFINITY); + + quat1.setY(1); + assertTrue(quat1.getY() == 1.0); + quat1.setY(Double.POSITIVE_INFINITY); + assertTrue(quat1.getY() == Double.POSITIVE_INFINITY); + quat1.setY(Double.NEGATIVE_INFINITY); + assertTrue(quat1.getY() == Double.NEGATIVE_INFINITY); + + quat1.setZ(1); + assertTrue(quat1.getZ() == 1.0); + quat1.setZ(Double.POSITIVE_INFINITY); + assertTrue(quat1.getZ() == Double.POSITIVE_INFINITY); + quat1.setZ(Double.NEGATIVE_INFINITY); + assertTrue(quat1.getZ() == Double.NEGATIVE_INFINITY); + + quat1.setW(1); + assertTrue(quat1.getW() == 1.0); + quat1.setW(Double.POSITIVE_INFINITY); + assertTrue(quat1.getW() == Double.POSITIVE_INFINITY); + quat1.setW(Double.NEGATIVE_INFINITY); + assertTrue(quat1.getW() == Double.NEGATIVE_INFINITY); + + quat1.set(Math.PI, Math.PI, Math.PI, Math.PI); + assertTrue(quat1.getXf() == (float) Math.PI); + assertTrue(quat1.getYf() == (float) Math.PI); + assertTrue(quat1.getZf() == (float) Math.PI); + assertTrue(quat1.getWf() == (float) Math.PI); + + final Quaternion quat2 = new Quaternion(); + quat2.set(quat1); + assertEquals(quat1, quat2); + } + + @Test + public void testToArray() { + final Quaternion quat1 = new Quaternion(); + quat1.set(Math.PI, Double.MAX_VALUE, 42, -1); + final double[] array = quat1.toArray(null); + final double[] array2 = quat1.toArray(new double[4]); + assertNotNull(array); + assertTrue(array.length == 4); + assertTrue(array[0] == Math.PI); + assertTrue(array[1] == Double.MAX_VALUE); + assertTrue(array[2] == 42); + assertTrue(array[3] == -1); + assertNotNull(array2); + assertTrue(array2.length == 4); + assertTrue(array2[0] == Math.PI); + assertTrue(array2[1] == Double.MAX_VALUE); + assertTrue(array2[2] == 42); + assertTrue(array2[3] == -1); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testBadArray() { + final Quaternion quat = new Quaternion(); + quat.toArray(new double[2]); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testBadAxesArray() { + final Quaternion quat = new Quaternion(); + quat.toAxes(new Vector3[2]); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testBadEuler1() { + new Quaternion().fromEulerAngles(new double[2]); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testBadEuler2() { + final Quaternion quat = new Quaternion(); + quat.toEulerAngles(new double[2]); + } + + @Test + public void testEulerAngles() { + final Quaternion quat = new Quaternion().fromEulerAngles(new double[] { MathUtils.HALF_PI, 0, 0 }); + assertTrue(1.0 == quat.magnitude()); + assertTrue(Math.abs(Vector3.NEG_UNIT_Z.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON); + + quat.fromEulerAngles(0, -MathUtils.HALF_PI, 0); + assertTrue(1.0 == quat.magnitude()); + assertTrue(Math.abs(Vector3.NEG_UNIT_Y.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON); + + quat.fromEulerAngles(0, 0, MathUtils.HALF_PI); + assertTrue(1.0 == quat.magnitude()); + assertTrue(Math.abs(Vector3.UNIT_Z.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON); + + quat.fromEulerAngles(0, MathUtils.HALF_PI, 0); + double[] angles = quat.toEulerAngles(null); + final Quaternion quat2 = new Quaternion().fromEulerAngles(angles); + assertEquals(quat, quat2); + quat.fromEulerAngles(0, -MathUtils.HALF_PI, 0); + angles = quat.toEulerAngles(null); + quat2.fromEulerAngles(angles); + assertEquals(quat, quat2); + quat.fromEulerAngles(0, 0, MathUtils.HALF_PI); + angles = quat.toEulerAngles(null); + quat2.fromEulerAngles(angles); + assertEquals(quat, quat2); + } + + @Test + public void testMatrix3() { + double a = MathUtils.HALF_PI; + final Quaternion quat = new Quaternion(); + quat.fromRotationMatrix( // + 1, 0, 0, // + 0, Math.cos(a), -Math.sin(a), // + 0, Math.sin(a), Math.cos(a)); + + assertTrue(Math.abs(Vector3.UNIT_Z.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON); + final Matrix3 mat = quat.toRotationMatrix((Matrix3) null); + assertTrue(Math.abs(quat.apply(Vector3.NEG_ONE, null).distance(mat.applyPost(Vector3.NEG_ONE, null))) <= MathUtils.EPSILON); + + a = MathUtils.PI; + quat.fromRotationMatrix( // + 1, 0, 0, // + 0, Math.cos(a), -Math.sin(a), // + 0, Math.sin(a), Math.cos(a)); + + assertTrue(Math.abs(Vector3.NEG_UNIT_Y.distance(quat.apply(Vector3.UNIT_Y, null))) <= MathUtils.EPSILON); + quat.toRotationMatrix(mat); + assertTrue(Math.abs(quat.apply(Vector3.ONE, null).distance(mat.applyPost(Vector3.ONE, null))) <= MathUtils.EPSILON); + + quat.set(0, 0, 0, 0); + assertEquals(Matrix3.IDENTITY, quat.toRotationMatrix((Matrix3) null)); + + a = MathUtils.PI; + quat.fromRotationMatrix( // + Math.cos(a), 0, Math.sin(a), // + 0, 1, 0, // + -Math.sin(a), 0, Math.cos(a)); + + assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON); + final Matrix4 mat4 = quat.toRotationMatrix((Matrix4) null); + assertTrue(Math.abs(quat.apply(Vector3.NEG_ONE, null).distance(mat4.applyPostVector(Vector3.NEG_ONE, null))) <= MathUtils.EPSILON); + + a = MathUtils.PI; + quat.fromRotationMatrix(new Matrix3(// + Math.cos(a), -Math.sin(a), 0, // + Math.sin(a), Math.cos(a), 0, // + 0, 0, 1)); + + assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat.apply(Vector3.UNIT_X, null))) <= MathUtils.EPSILON); + quat.toRotationMatrix(mat4); + assertTrue(Math.abs(quat.apply(Vector3.ONE, null).distance(mat4.applyPostVector(Vector3.ONE, null))) <= MathUtils.EPSILON); + + quat.set(0, 0, 0, 0); + assertEquals(Matrix4.IDENTITY, quat.toRotationMatrix((Matrix4) null)); + } + + @Test + public void testRotations() { + final double a = MathUtils.QUARTER_PI; + final Quaternion quat = new Quaternion().fromRotationMatrix(new Matrix3(// + Math.cos(a), -Math.sin(a), 0, // + Math.sin(a), Math.cos(a), 0, // + 0, 0, 1)); + final Vector3 column = quat.getRotationColumn(0, null); + assertTrue(Math.abs(new Vector3(Math.cos(a), Math.sin(a), 0).distance(column)) <= MathUtils.EPSILON); + quat.getRotationColumn(1, column); + assertTrue(Math.abs(new Vector3(-Math.sin(a), Math.sin(a), 0).distance(column)) <= MathUtils.EPSILON); + quat.getRotationColumn(2, column); + assertTrue(Math.abs(new Vector3(0, 0, 1).distance(column)) <= MathUtils.EPSILON); + + quat.set(0, 0, 0, 0); + assertEquals(Vector3.UNIT_X, quat.getRotationColumn(0, null)); + + // Try a new way with new angles... + quat.fromEulerAngles(MathUtils.QUARTER_PI, MathUtils.PI, MathUtils.HALF_PI); + final Vector3 rotated = new Vector3(1, 1, 1); + quat.apply(rotated, rotated); + + // expected + final Vector3 expected = new Vector3(1, 1, 1); + final Quaternion worker = new Quaternion(); + // put together matrix, then apply to vector, so YZX + worker.applyRotationY(MathUtils.QUARTER_PI); + worker.applyRotationZ(MathUtils.PI); + worker.applyRotationX(MathUtils.HALF_PI); + worker.apply(expected, expected); + + // test how close it came out + assertTrue(rotated.distance(expected) <= Quaternion.ALLOWED_DEVIANCE); + + // test axis rotation methods against general purpose + // X AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationX(MathUtils.QUARTER_PI).apply(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 1, 0, 0).apply(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Y AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationY(MathUtils.QUARTER_PI).apply(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 1, 0).apply(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + // Z AXIS + expected.set(1, 1, 1); + rotated.set(1, 1, 1); + worker.setIdentity().applyRotationZ(MathUtils.QUARTER_PI).apply(expected, expected); + worker.setIdentity().applyRotation(MathUtils.QUARTER_PI, 0, 0, 1).apply(rotated, rotated); + assertTrue(rotated.distance(expected) <= MathUtils.EPSILON); + + quat.set(worker); + worker.applyRotation(0, 0, 0, 0); + assertEquals(quat, worker); + } + + @Test(expected = IllegalArgumentException.class) + public void testBadRotationColumn1() { + new Quaternion().getRotationColumn(-1, null); + } + + @Test(expected = IllegalArgumentException.class) + public void testBadRotationColumn2() { + new Quaternion().getRotationColumn(4, null); + } + + @Test + public void testAngleAxis() { + final Quaternion quat = new Quaternion().fromAngleAxis(MathUtils.HALF_PI, new Vector3(2, 0, 0)); + final Quaternion quat2 = new Quaternion().fromAngleNormalAxis(MathUtils.HALF_PI, new Vector3(1, 0, 0)); + + assertEquals(quat2, quat); + assertTrue(1 - quat.magnitude() <= MathUtils.EPSILON); + + assertEquals(quat.apply(Vector3.ONE, null), quat2.apply(Vector3.ONE, null)); + assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(new Vector3(0, 0, 1), null))) <= MathUtils.EPSILON); + + assertEquals(Quaternion.IDENTITY, + new Quaternion(1, 2, 3, 4).fromAngleAxis(MathUtils.HALF_PI, new Vector3(0, 0, 0))); + + final Vector3 axisStore = new Vector3(); + double angle = quat.toAngleAxis(axisStore); + assertEquals(quat, new Quaternion().fromAngleAxis(angle, axisStore)); + + quat.set(0, 0, 0, 0); + angle = quat.toAngleAxis(axisStore); + assertTrue(0.0 == angle); + assertEquals(Vector3.UNIT_X, axisStore); + } + + @Test + public void testFromVectorToVector() { + final Quaternion quat = new Quaternion().fromVectorToVector(Vector3.UNIT_Z, Vector3.UNIT_X); + assertEquals(new Quaternion().fromAngleAxis(MathUtils.HALF_PI, Vector3.UNIT_Y), quat); + + quat.fromVectorToVector(Vector3.UNIT_Z, Vector3.NEG_UNIT_Z); + assertTrue(Math.abs(new Vector3(0, 0, -1).distance(quat.apply(new Vector3(0, 0, 1), null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat.fromVectorToVector(Vector3.UNIT_X, Vector3.NEG_UNIT_X); + assertTrue(Math.abs(new Vector3(-1, 0, 0).distance(quat.apply(new Vector3(1, 0, 0), null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat.fromVectorToVector(Vector3.UNIT_Y, Vector3.NEG_UNIT_Y); + assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(new Vector3(0, 1, 0), null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat.fromVectorToVector(Vector3.ONE, Vector3.NEG_ONE); + assertTrue(Math.abs(new Vector3(-1, -1, -1).distance(quat.apply(new Vector3(1, 1, 1), null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat.fromVectorToVector(Vector3.ZERO, Vector3.ZERO); + assertEquals(Quaternion.IDENTITY, quat); + } + + @Test + public void testNormalize() { + final Quaternion quat = new Quaternion(0, 1, 2, 3); + final Quaternion quat2 = quat.normalize(null); + assertEquals(quat2, quat.normalizeLocal()); + assertTrue(Math.abs(1 - quat.magnitude()) <= MathUtils.EPSILON); + assertTrue(Math.abs(1 - quat2.magnitude()) <= MathUtils.EPSILON); + } + + @Test + public void testApplyToZero() { + assertEquals(Vector3.ZERO, new Quaternion().apply(new Vector3(0, 0, 0), null)); + } + + @Test + public void testInvert() { + final Quaternion quat1 = new Quaternion(0, 1, 2, 3); + final Quaternion quat2 = quat1.invert(null); + assertEquals(Quaternion.IDENTITY, quat1.multiply(quat2, null)); + assertEquals(quat1, quat2.invert(new Quaternion())); + assertEquals(quat1, quat2.invertLocal()); + + // normalized version + quat1.fromAngleAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y); + quat1.invert(quat2); + assertEquals(Quaternion.IDENTITY, quat1.multiply(quat2, null)); + assertEquals(quat1, quat2.invert(new Quaternion())); + assertEquals(quat1, quat2.invertLocal()); + + // conjugate check + assertEquals(new Quaternion(-1, -2, -3, 4), new Quaternion(1, 2, 3, 4).conjugate(null)); + } + + @Test + public void testAddSubtract() { + final Quaternion quat1 = new Quaternion(0, 1, 2, 3); + final Quaternion quat2 = new Quaternion(1, 1, 1, 1); + assertEquals(new Quaternion(1, 2, 3, 4), quat1.add(quat2, null)); + assertEquals(new Quaternion(1, 2, 3, 4), quat1.add(quat2, new Quaternion())); + assertEquals(new Quaternion(1, 2, 3, 4), quat1.addLocal(quat2)); + + quat1.set(0, 1, 2, 3); + quat2.set(1, 1, 1, 1); + assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtract(quat2, null)); + assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtract(quat2, new Quaternion())); + assertEquals(new Quaternion(-1, 0, 1, 2), quat1.subtractLocal(quat2)); + } + + @Test + public void testMultiply() { + final Quaternion quat1 = new Quaternion(0.5, 1, 2, 3); + final Quaternion quat2 = new Quaternion(); + assertEquals(new Quaternion(1, 2, 4, 6), quat1.multiply(2, null)); + assertEquals(new Quaternion(2, 4, 8, 12), quat1.multiply(4, quat2)); + assertEquals(new Quaternion(1, 2, 4, 6), quat1.multiplyLocal(2)); + + quat1.fromAngleNormalAxis(MathUtils.QUARTER_PI, Vector3.UNIT_Y); + quat1.multiply(quat1, quat2); + + final ReadOnlyVector3 vec = Vector3.UNIT_Z; + assertTrue(Math.abs(Vector3.UNIT_X.distance(quat2.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE); + quat1.multiplyLocal(quat1.getX(), quat1.getY(), quat1.getZ(), quat1.getW()); + assertTrue(Math.abs(Vector3.UNIT_X.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE); + quat2.fromAngleNormalAxis(MathUtils.HALF_PI, Vector3.UNIT_Y); + quat1.multiplyLocal(quat2); + assertTrue(Math.abs(Vector3.NEG_UNIT_Z.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat1.multiplyLocal(new Matrix3().applyRotationY(MathUtils.HALF_PI)); + assertTrue(Math.abs(Vector3.NEG_UNIT_X.distance(quat1.apply(vec, null))) <= Quaternion.ALLOWED_DEVIANCE); + } + + @Test + public void testAxes() { + final Matrix3 rot = new Matrix3().applyRotationX(MathUtils.QUARTER_PI).applyRotationY(MathUtils.HALF_PI); + final Quaternion quat1 = new Quaternion().fromAxes(rot.getColumn(0, null), rot.getColumn(1, null), + rot.getColumn(2, null)); + final Quaternion quat2 = new Quaternion().fromRotationMatrix(rot); + assertEquals(quat2, quat1); + + final Vector3[] axes = quat1.toAxes(new Vector3[3]); + quat1.fromAxes(axes[0], axes[1], axes[2]); + assertEquals(quat2, quat1); + } + + @Test + public void testSlerp() { + final Quaternion quat = new Quaternion(); + final Quaternion quat2 = new Quaternion().applyRotationY(MathUtils.HALF_PI); + final Quaternion store = quat.slerp(quat2, .5, null); + assertTrue(Math.abs(new Vector3(Math.sin(MathUtils.QUARTER_PI), 0, Math.sin(MathUtils.QUARTER_PI)) + .distance(store.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // delta == 100% + quat2.setIdentity().applyRotationZ(MathUtils.PI); + quat.slerp(quat2, 1.0, store); + assertTrue(Math.abs(new Vector3(-1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat2.setIdentity().applyRotationZ(MathUtils.PI); + quat.slerp(quat2, .5, store); + assertTrue(Math.abs(new Vector3(0, 1, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // delta == 0% + quat2.setIdentity().applyRotationZ(MathUtils.PI); + quat.slerp(quat2, 0, store); + assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // a==b + quat2.setIdentity(); + quat.slerp(quat2, 0.25, store); + assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // negative dot product + quat.setIdentity().applyRotationX(-2 * MathUtils.HALF_PI); + quat2.setIdentity().applyRotationX(MathUtils.HALF_PI); + quat.slerp(quat2, 0.5, store); + assertTrue(Math.abs(new Vector3(0, -Math.sin(MathUtils.QUARTER_PI), Math.sin(MathUtils.QUARTER_PI)) + .distance(store.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // LOCAL + // delta == 100% + quat2.setIdentity().applyRotationX(MathUtils.PI); + quat.slerpLocal(quat2, 1.0); + assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + + quat.setIdentity(); + quat.slerpLocal(quat2, .5); + assertTrue(Math.abs(new Vector3(0, 0, 1).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // delta == 0% + quat.setIdentity(); + quat.slerpLocal(quat2, 0); + assertTrue(Math.abs(new Vector3(0, 1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // a==b + quat.setIdentity(); + quat2.setIdentity(); + quat.slerpLocal(quat2, 0.25); + assertTrue(Math.abs(new Vector3(0, 1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + + // negative dot product + quat.setIdentity().applyRotationX(-2 * MathUtils.HALF_PI); + quat2.setIdentity().applyRotationX(MathUtils.HALF_PI); + quat.slerpLocal(quat2, 0.5); + assertTrue(Math.abs(new Vector3(0, -Math.sin(MathUtils.QUARTER_PI), Math.sin(MathUtils.QUARTER_PI)) + .distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); + } + + @Test + public void testLookAt() { + final Vector3 direction = new Vector3(-1, 0, 0); + final Quaternion quat = new Quaternion().lookAt(direction, Vector3.UNIT_Y); + assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE); + + direction.set(1, 1, 1).normalizeLocal(); + quat.lookAt(direction, Vector3.UNIT_Y); + assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE); + + direction.set(-1, 2, -1).normalizeLocal(); + quat.lookAt(direction, Vector3.UNIT_Y); + assertTrue(Math.abs(direction.distance(quat.apply(Vector3.UNIT_Z, null))) <= Quaternion.ALLOWED_DEVIANCE); + } + + @Test + public void testDot() { + final Quaternion quat = new Quaternion(7, 2, 5, -1); + assertTrue(35.0 == quat.dot(3, 1, 2, -2)); + + assertTrue(-11.0 == quat.dot(new Quaternion(-1, 1, -1, 1))); + } + + @Test + public void testClone() { + final Quaternion quat1 = new Quaternion(); + final Quaternion quat2 = quat1.clone(); + assertEquals(quat1, quat2); + assertNotSame(quat1, quat2); + } + + @Test + public void testValid() { + final Quaternion quat = new Quaternion(); + assertTrue(Quaternion.isValid(quat)); + + quat.set(Double.NaN, 0, 0, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, Double.NaN, 0, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, 0, Double.NaN, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, 0, 0, Double.NaN); + assertFalse(Quaternion.isValid(quat)); + + quat.set(Double.NEGATIVE_INFINITY, 0, 0, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, Double.NEGATIVE_INFINITY, 0, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, 0, Double.NEGATIVE_INFINITY, 0); + assertFalse(Quaternion.isValid(quat)); + quat.set(0, 0, 0, Double.NEGATIVE_INFINITY); + assertFalse(Quaternion.isValid(quat)); + + quat.setIdentity(); + assertTrue(Quaternion.isValid(quat)); + + assertFalse(Quaternion.isValid(null)); + + // couple of equals validity tests + assertEquals(quat, quat); + assertTrue(quat.strictEquals(quat)); + assertFalse(quat.equals(null)); + assertFalse(quat.strictEquals(null)); + assertFalse(quat.equals(new Vector2())); + assertFalse(quat.strictEquals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Quaternion quatTemp = Quaternion.fetchTempInstance(); + quatTemp.set(quat); + assertEquals(quat, quatTemp); + assertNotSame(quat, quatTemp); + Quaternion.releaseTempInstance(quatTemp); + + // cover more of equals + quat.set(0, 1, 2, 3); + final Quaternion comp = new Quaternion(-1, -1, -1, -1); + assertFalse(quat.equals(comp)); + assertFalse(quat.strictEquals(comp)); + comp.setX(0); + assertFalse(quat.equals(comp)); + assertFalse(quat.strictEquals(comp)); + comp.setY(1); + assertFalse(quat.equals(comp)); + assertFalse(quat.strictEquals(comp)); + comp.setZ(2); + assertFalse(quat.equals(comp)); + assertFalse(quat.strictEquals(comp)); + comp.setW(3); + assertEquals(quat, comp); + assertTrue(quat.strictEquals(comp)); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Quaternion quat1 = new Quaternion(1, 2, 3, 4); + final Quaternion quat2 = new Quaternion(1, 2, 3, 4); + final Quaternion quat3 = new Quaternion(1, 2, 3, 0); + + assertTrue(quat1.hashCode() == quat2.hashCode()); + assertTrue(quat1.hashCode() != quat3.hashCode()); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestRay3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestRay3.java index f662700..a7064ad 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestRay3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestRay3.java @@ -1,230 +1,230 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-import com.ardor3d.math.type.ReadOnlyRay3;
-
-public class TestRay3 {
- @Test
- public void testData() {
- final Ray3 ray = new Ray3();
- assertEquals(Vector3.UNIT_Z, ray.getDirection());
- assertEquals(Vector3.ZERO, ray.getOrigin());
-
- ray.setDirection(Vector3.NEG_UNIT_X);
- assertEquals(Vector3.NEG_UNIT_X, ray.getDirection());
- ray.setOrigin(Vector3.ONE);
- assertEquals(Vector3.ONE, ray.getOrigin());
-
- final Ray3 ray2 = new Ray3(ray);
- assertEquals(Vector3.NEG_UNIT_X, ray2.getDirection());
- assertEquals(Vector3.ONE, ray2.getOrigin());
-
- ray.set(new Ray3());
- assertEquals(Vector3.UNIT_Z, ray.getDirection());
- assertEquals(Vector3.ZERO, ray.getOrigin());
- }
-
- @Test
- public void testValid() {
- final Ray3 ray1 = new Ray3(new Vector3(0, 0, 0), new Vector3(0, 0, 1));
- final Ray3 ray2 = new Ray3(new Vector3(Double.POSITIVE_INFINITY, 0, 0), new Vector3(0, 0, 1));
- final Ray3 ray3 = new Ray3(new Vector3(0, 0, 0), new Vector3(Double.POSITIVE_INFINITY, 0, 1));
-
- assertTrue(Ray3.isValid(ray1));
- assertFalse(Ray3.isValid(ray2));
- assertFalse(Ray3.isValid(ray3));
-
- assertFalse(Ray3.isValid(null));
-
- // couple if equals validity tests
- assertEquals(ray1, ray1);
- assertFalse(ray1.equals(null));
- assertFalse(ray1.equals(new Vector3()));
-
- // throw in a couple pool accesses for coverage
- final Ray3 ray4 = Ray3.fetchTempInstance();
- ray4.set(ray1);
- assertEquals(ray1, ray4);
- assertNotSame(ray1, ray4);
- Ray3.releaseTempInstance(ray4);
-
- // cover more of equals
- assertFalse(ray1.equals(new Ray3(Vector3.ZERO, Vector3.NEG_UNIT_X)));
- }
-
- @Test
- public void testClone() {
- final Ray3 ray1 = new Ray3();
- final Ray3 ray2 = ray1.clone();
- assertEquals(ray1, ray2);
- assertNotSame(ray1, ray2);
- }
-
- @Test
- public void testDistance() {
- final Ray3 ray1 = new Ray3();
- assertTrue(25.0 == ray1.distanceSquared(new Vector3(0, 5, 3), null));
-
- final Vector3 store = new Vector3();
- assertTrue(9.0 == ray1.distanceSquared(new Vector3(0, 3, 3), store));
- assertEquals(new Vector3(0, 0, 3), store);
- assertTrue(18.0 == ray1.distanceSquared(new Vector3(0, 3, -3), store));
- assertEquals(new Vector3(0, 0, 0), store);
- }
-
- @Test
- public void testIntersectsTriangle() {
- final Vector3 v0 = new Vector3(-1, -1, -1);
- final Vector3 v1 = new Vector3(+1, -1, -1);
- final Vector3 v2 = new Vector3(+1, +1, -1);
-
- final Vector3 intersectionPoint = new Vector3();
-
- // inside triangle
- Ray3 pickRay = new Ray3(new Vector3(0.5, -0.5, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // horizontal edge
- pickRay = new Ray3(new Vector3(0, -1, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // diagonal edge
- pickRay = new Ray3(new Vector3(0, 0, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // vertical edge
- pickRay = new Ray3(new Vector3(+1, 0, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // v0
- pickRay = new Ray3(new Vector3(-1, -1, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // v1
- pickRay = new Ray3(new Vector3(+1, -1, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // v2
- pickRay = new Ray3(new Vector3(1, 1, 3), new Vector3(0, 0, -1));
- assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // outside horizontal edge
- pickRay = new Ray3(new Vector3(0, -1.1, 3), new Vector3(0, 0, -1));
- assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // outside diagonal edge
- pickRay = new Ray3(new Vector3(-0.1, 0.1, 3), new Vector3(0, 0, -1));
- assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // outside vertical edge
- pickRay = new Ray3(new Vector3(+1.1, 0, 3), new Vector3(0, 0, -1));
- assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // inside triangle but ray pointing other way
- pickRay = new Ray3(new Vector3(-0.5, -0.5, 3), new Vector3(0, 0, +1));
- assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint));
-
- // test distance
- pickRay = new Ray3(new Vector3(0.5, -0.5, 3), new Vector3(0, 0, -1));
- assertTrue(4.0 == pickRay.getDistanceToPrimitive(new Vector3[] { v0, v1, v2 }));
-
- // test intersect planar
- assertTrue(pickRay.intersectsTrianglePlanar(v0, v1, v2, intersectionPoint));
-
- }
-
- @Test
- public void testIntersectsPlane() {
- final Vector3 intersectionPoint = new Vector3();
-
- Plane plane = new Plane(new Vector3(0, 1, 0), 2);
-
- Ray3 pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, 0, 1));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, 1, 0));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, 2, 0), new Vector3(0, 1, 0));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, 1, 0), new Vector3(0, 1, 0));
- assertTrue(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, 0, 0), new Vector3(1, 0, 0));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(0, 0, 1));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, -1, 0));
- assertTrue(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(1, 1, 1));
- assertTrue(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(-1, -1, -1));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- plane = new Plane(new Vector3(1, 1, 1), -2);
-
- pickRay = new Ray3(new Vector3(0, 0, 0), new Vector3(1, -1, 1));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -1, 0), new Vector3(0, 1, 0));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -2, 0), new Vector3(0, 1, 0));
- assertFalse(pickRay.intersectsPlane(plane, intersectionPoint));
-
- pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(0, 1, 0));
- assertTrue(pickRay.intersectsPlane(plane, null));
- }
-
- @Test
- public void testIntersectsQuad() {
- final Vector3 v0 = new Vector3(0, 0, 0);
- final Vector3 v1 = new Vector3(5, 0, 0);
- final Vector3 v2 = new Vector3(5, 5, 0);
- final Vector3 v3 = new Vector3(0, 5, 0);
-
- Vector3 intersectionPoint = null;
-
- // inside quad
- final ReadOnlyRay3 pickRayA = new Ray3(new Vector3(2, 2, 10), new Vector3(0, 0, -1));
- final ReadOnlyRay3 pickRayB = new Ray3(new Vector3(2, 4, 10), new Vector3(0, 0, -1));
- assertTrue(pickRayA.intersectsQuad(v0, v1, v2, v3, intersectionPoint));
- assertTrue(pickRayB.intersectsQuad(v0, v1, v2, v3, intersectionPoint));
-
- // inside quad
- final Ray3 pickRay2 = new Ray3(new Vector3(-1, 0, 10), new Vector3(0, 0, -1));
- assertFalse(pickRay2.intersectsQuad(v0, v1, v2, v3, intersectionPoint));
-
- // test distance
- assertTrue(10.0 == pickRayA.getDistanceToPrimitive(new Vector3[] { v0, v1, v2, v3 }));
- assertTrue(Double.POSITIVE_INFINITY == pickRay2.getDistanceToPrimitive(new Vector3[] { v0, v1, v2, v3 }));
-
- // test unsupported pick
- assertFalse(pickRay2.intersects(new Vector3[] { v0, v1 }, null));
-
- // test intersect planar
- assertFalse(new Ray3(new Vector3(0, 0, -1), Vector3.UNIT_Y).intersectsQuadPlanar(v0, v1, v2, v3,
- intersectionPoint));
- intersectionPoint = new Vector3();
- assertTrue(pickRayA.intersectsQuadPlanar(v0, v1, v2, v3, intersectionPoint));
- assertTrue(pickRayB.intersectsQuadPlanar(v0, v1, v2, v3, intersectionPoint));
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +import com.ardor3d.math.type.ReadOnlyRay3; + +public class TestRay3 { + @Test + public void testData() { + final Ray3 ray = new Ray3(); + assertEquals(Vector3.UNIT_Z, ray.getDirection()); + assertEquals(Vector3.ZERO, ray.getOrigin()); + + ray.setDirection(Vector3.NEG_UNIT_X); + assertEquals(Vector3.NEG_UNIT_X, ray.getDirection()); + ray.setOrigin(Vector3.ONE); + assertEquals(Vector3.ONE, ray.getOrigin()); + + final Ray3 ray2 = new Ray3(ray); + assertEquals(Vector3.NEG_UNIT_X, ray2.getDirection()); + assertEquals(Vector3.ONE, ray2.getOrigin()); + + ray.set(new Ray3()); + assertEquals(Vector3.UNIT_Z, ray.getDirection()); + assertEquals(Vector3.ZERO, ray.getOrigin()); + } + + @Test + public void testValid() { + final Ray3 ray1 = new Ray3(new Vector3(0, 0, 0), new Vector3(0, 0, 1)); + final Ray3 ray2 = new Ray3(new Vector3(Double.POSITIVE_INFINITY, 0, 0), new Vector3(0, 0, 1)); + final Ray3 ray3 = new Ray3(new Vector3(0, 0, 0), new Vector3(Double.POSITIVE_INFINITY, 0, 1)); + + assertTrue(Ray3.isValid(ray1)); + assertFalse(Ray3.isValid(ray2)); + assertFalse(Ray3.isValid(ray3)); + + assertFalse(Ray3.isValid(null)); + + // couple if equals validity tests + assertEquals(ray1, ray1); + assertFalse(ray1.equals(null)); + assertFalse(ray1.equals(new Vector3())); + + // throw in a couple pool accesses for coverage + final Ray3 ray4 = Ray3.fetchTempInstance(); + ray4.set(ray1); + assertEquals(ray1, ray4); + assertNotSame(ray1, ray4); + Ray3.releaseTempInstance(ray4); + + // cover more of equals + assertFalse(ray1.equals(new Ray3(Vector3.ZERO, Vector3.NEG_UNIT_X))); + } + + @Test + public void testClone() { + final Ray3 ray1 = new Ray3(); + final Ray3 ray2 = ray1.clone(); + assertEquals(ray1, ray2); + assertNotSame(ray1, ray2); + } + + @Test + public void testDistance() { + final Ray3 ray1 = new Ray3(); + assertTrue(25.0 == ray1.distanceSquared(new Vector3(0, 5, 3), null)); + + final Vector3 store = new Vector3(); + assertTrue(9.0 == ray1.distanceSquared(new Vector3(0, 3, 3), store)); + assertEquals(new Vector3(0, 0, 3), store); + assertTrue(18.0 == ray1.distanceSquared(new Vector3(0, 3, -3), store)); + assertEquals(new Vector3(0, 0, 0), store); + } + + @Test + public void testIntersectsTriangle() { + final Vector3 v0 = new Vector3(-1, -1, -1); + final Vector3 v1 = new Vector3(+1, -1, -1); + final Vector3 v2 = new Vector3(+1, +1, -1); + + final Vector3 intersectionPoint = new Vector3(); + + // inside triangle + Ray3 pickRay = new Ray3(new Vector3(0.5, -0.5, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // horizontal edge + pickRay = new Ray3(new Vector3(0, -1, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // diagonal edge + pickRay = new Ray3(new Vector3(0, 0, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // vertical edge + pickRay = new Ray3(new Vector3(+1, 0, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // v0 + pickRay = new Ray3(new Vector3(-1, -1, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // v1 + pickRay = new Ray3(new Vector3(+1, -1, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // v2 + pickRay = new Ray3(new Vector3(1, 1, 3), new Vector3(0, 0, -1)); + assertTrue(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // outside horizontal edge + pickRay = new Ray3(new Vector3(0, -1.1, 3), new Vector3(0, 0, -1)); + assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // outside diagonal edge + pickRay = new Ray3(new Vector3(-0.1, 0.1, 3), new Vector3(0, 0, -1)); + assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // outside vertical edge + pickRay = new Ray3(new Vector3(+1.1, 0, 3), new Vector3(0, 0, -1)); + assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // inside triangle but ray pointing other way + pickRay = new Ray3(new Vector3(-0.5, -0.5, 3), new Vector3(0, 0, +1)); + assertFalse(pickRay.intersectsTriangle(v0, v1, v2, intersectionPoint)); + + // test distance + pickRay = new Ray3(new Vector3(0.5, -0.5, 3), new Vector3(0, 0, -1)); + assertTrue(4.0 == pickRay.getDistanceToPrimitive(new Vector3[] { v0, v1, v2 })); + + // test intersect planar + assertTrue(pickRay.intersectsTrianglePlanar(v0, v1, v2, intersectionPoint)); + + } + + @Test + public void testIntersectsPlane() { + final Vector3 intersectionPoint = new Vector3(); + + Plane plane = new Plane(new Vector3(0, 1, 0), 2); + + Ray3 pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, 0, 1)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, 1, 0)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, 2, 0), new Vector3(0, 1, 0)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, 1, 0), new Vector3(0, 1, 0)); + assertTrue(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, 0, 0), new Vector3(1, 0, 0)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(0, 0, 1)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, 3, 0), new Vector3(0, -1, 0)); + assertTrue(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(1, 1, 1)); + assertTrue(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(-1, -1, -1)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + plane = new Plane(new Vector3(1, 1, 1), -2); + + pickRay = new Ray3(new Vector3(0, 0, 0), new Vector3(1, -1, 1)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -1, 0), new Vector3(0, 1, 0)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -2, 0), new Vector3(0, 1, 0)); + assertFalse(pickRay.intersectsPlane(plane, intersectionPoint)); + + pickRay = new Ray3(new Vector3(0, -3, 0), new Vector3(0, 1, 0)); + assertTrue(pickRay.intersectsPlane(plane, null)); + } + + @Test + public void testIntersectsQuad() { + final Vector3 v0 = new Vector3(0, 0, 0); + final Vector3 v1 = new Vector3(5, 0, 0); + final Vector3 v2 = new Vector3(5, 5, 0); + final Vector3 v3 = new Vector3(0, 5, 0); + + Vector3 intersectionPoint = null; + + // inside quad + final ReadOnlyRay3 pickRayA = new Ray3(new Vector3(2, 2, 10), new Vector3(0, 0, -1)); + final ReadOnlyRay3 pickRayB = new Ray3(new Vector3(2, 4, 10), new Vector3(0, 0, -1)); + assertTrue(pickRayA.intersectsQuad(v0, v1, v2, v3, intersectionPoint)); + assertTrue(pickRayB.intersectsQuad(v0, v1, v2, v3, intersectionPoint)); + + // inside quad + final Ray3 pickRay2 = new Ray3(new Vector3(-1, 0, 10), new Vector3(0, 0, -1)); + assertFalse(pickRay2.intersectsQuad(v0, v1, v2, v3, intersectionPoint)); + + // test distance + assertTrue(10.0 == pickRayA.getDistanceToPrimitive(new Vector3[] { v0, v1, v2, v3 })); + assertTrue(Double.POSITIVE_INFINITY == pickRay2.getDistanceToPrimitive(new Vector3[] { v0, v1, v2, v3 })); + + // test unsupported pick + assertFalse(pickRay2.intersects(new Vector3[] { v0, v1 }, null)); + + // test intersect planar + assertFalse(new Ray3(new Vector3(0, 0, -1), Vector3.UNIT_Y).intersectsQuadPlanar(v0, v1, v2, v3, + intersectionPoint)); + intersectionPoint = new Vector3(); + assertTrue(pickRayA.intersectsQuadPlanar(v0, v1, v2, v3, intersectionPoint)); + assertTrue(pickRayB.intersectsQuadPlanar(v0, v1, v2, v3, intersectionPoint)); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle2.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle2.java index 74cb987..353813f 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle2.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle2.java @@ -1,120 +1,120 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestRectangle2 {
- @Test
- public void testGetSet() {
- final Rectangle2 rect1 = new Rectangle2();
- assertTrue(0 == rect1.getX());
- assertTrue(0 == rect1.getY());
- assertTrue(0 == rect1.getWidth());
- assertTrue(0 == rect1.getHeight());
-
- final Rectangle2 rect2 = new Rectangle2(2, 3, 4, 5);
- assertTrue(2 == rect2.getX());
- assertTrue(3 == rect2.getY());
- assertTrue(4 == rect2.getWidth());
- assertTrue(5 == rect2.getHeight());
-
- rect1.set(rect2);
- assertTrue(2 == rect1.getX());
- assertTrue(3 == rect1.getY());
- assertTrue(4 == rect1.getWidth());
- assertTrue(5 == rect1.getHeight());
-
- final Rectangle2 rect3 = new Rectangle2(rect1);
- assertTrue(2 == rect3.getX());
- assertTrue(3 == rect3.getY());
- assertTrue(4 == rect3.getWidth());
- assertTrue(5 == rect3.getHeight());
-
- rect1.set(5, 0, 10, 15);
- assertTrue(5 == rect1.getX());
- assertTrue(0 == rect1.getY());
- assertTrue(10 == rect1.getWidth());
- assertTrue(15 == rect1.getHeight());
-
- rect1.setX(4);
- assertTrue(4 == rect1.getX());
- rect1.setY(42);
- assertTrue(42 == rect1.getY());
- rect1.setWidth(50);
- assertTrue(50 == rect1.getWidth());
- rect1.setHeight(100);
- assertTrue(100 == rect1.getHeight());
- }
-
- @Test
- public void testClone() {
- final Rectangle2 rect1 = new Rectangle2();
- final Rectangle2 rect2 = rect1.clone();
- assertEquals(rect1, rect2);
- assertNotSame(rect1, rect2);
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Rectangle2 rect1 = new Rectangle2(1, 2, 0, 0);
- final Rectangle2 rect2 = new Rectangle2(1, 2, 0, 0);
- final Rectangle2 rect3 = new Rectangle2(2, 2, 0, 0);
-
- assertTrue(rect1.hashCode() == rect2.hashCode());
- assertTrue(rect1.hashCode() != rect3.hashCode());
- }
-
- @Test
- public void testEquals() {
- final Rectangle2 rect1 = new Rectangle2(1, 2, 3, 4);
- final Rectangle2 rect2 = new Rectangle2(1, 0, 0, 0);
- final Rectangle2 rect3 = new Rectangle2(1, 2, 0, 0);
- final Rectangle2 rect4 = new Rectangle2(1, 2, 3, 0);
- final Rectangle2 rect5 = new Rectangle2(1, 2, 3, 4);
-
- // couple of equals validity tests
- assertEquals(rect1, rect1);
- assertFalse(rect1.equals(null));
- assertFalse(rect1.equals(new Vector2()));
-
- assertFalse(rect1.equals(rect2));
- assertFalse(rect1.equals(rect3));
- assertFalse(rect1.equals(rect4));
- assertTrue(rect1.equals(rect5));
- }
-
- @Test
- public void testIntersect() {
- final Rectangle2 rect1 = new Rectangle2(0, 0, 10, 10);
- final Rectangle2 rect2 = new Rectangle2(5, 5, 10, 10);
-
- Rectangle2 intersection = rect1.intersect(rect2, Rectangle2.fetchTempInstance());
- assertTrue(5 == intersection.getX());
- assertTrue(5 == intersection.getY());
- assertTrue(5 == intersection.getWidth());
- assertTrue(5 == intersection.getHeight());
- Rectangle2.releaseTempInstance(intersection);
- assertNotNull(rect1.intersect(rect2, null));
-
- intersection = Rectangle2.intersect(rect1, rect2, Rectangle2.fetchTempInstance());
- assertTrue(5 == intersection.getX());
- assertTrue(5 == intersection.getY());
- assertTrue(5 == intersection.getWidth());
- assertTrue(5 == intersection.getHeight());
- Rectangle2.releaseTempInstance(intersection);
- assertNotNull(Rectangle2.intersect(rect1, rect2, null));
-
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestRectangle2 { + @Test + public void testGetSet() { + final Rectangle2 rect1 = new Rectangle2(); + assertTrue(0 == rect1.getX()); + assertTrue(0 == rect1.getY()); + assertTrue(0 == rect1.getWidth()); + assertTrue(0 == rect1.getHeight()); + + final Rectangle2 rect2 = new Rectangle2(2, 3, 4, 5); + assertTrue(2 == rect2.getX()); + assertTrue(3 == rect2.getY()); + assertTrue(4 == rect2.getWidth()); + assertTrue(5 == rect2.getHeight()); + + rect1.set(rect2); + assertTrue(2 == rect1.getX()); + assertTrue(3 == rect1.getY()); + assertTrue(4 == rect1.getWidth()); + assertTrue(5 == rect1.getHeight()); + + final Rectangle2 rect3 = new Rectangle2(rect1); + assertTrue(2 == rect3.getX()); + assertTrue(3 == rect3.getY()); + assertTrue(4 == rect3.getWidth()); + assertTrue(5 == rect3.getHeight()); + + rect1.set(5, 0, 10, 15); + assertTrue(5 == rect1.getX()); + assertTrue(0 == rect1.getY()); + assertTrue(10 == rect1.getWidth()); + assertTrue(15 == rect1.getHeight()); + + rect1.setX(4); + assertTrue(4 == rect1.getX()); + rect1.setY(42); + assertTrue(42 == rect1.getY()); + rect1.setWidth(50); + assertTrue(50 == rect1.getWidth()); + rect1.setHeight(100); + assertTrue(100 == rect1.getHeight()); + } + + @Test + public void testClone() { + final Rectangle2 rect1 = new Rectangle2(); + final Rectangle2 rect2 = rect1.clone(); + assertEquals(rect1, rect2); + assertNotSame(rect1, rect2); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Rectangle2 rect1 = new Rectangle2(1, 2, 0, 0); + final Rectangle2 rect2 = new Rectangle2(1, 2, 0, 0); + final Rectangle2 rect3 = new Rectangle2(2, 2, 0, 0); + + assertTrue(rect1.hashCode() == rect2.hashCode()); + assertTrue(rect1.hashCode() != rect3.hashCode()); + } + + @Test + public void testEquals() { + final Rectangle2 rect1 = new Rectangle2(1, 2, 3, 4); + final Rectangle2 rect2 = new Rectangle2(1, 0, 0, 0); + final Rectangle2 rect3 = new Rectangle2(1, 2, 0, 0); + final Rectangle2 rect4 = new Rectangle2(1, 2, 3, 0); + final Rectangle2 rect5 = new Rectangle2(1, 2, 3, 4); + + // couple of equals validity tests + assertEquals(rect1, rect1); + assertFalse(rect1.equals(null)); + assertFalse(rect1.equals(new Vector2())); + + assertFalse(rect1.equals(rect2)); + assertFalse(rect1.equals(rect3)); + assertFalse(rect1.equals(rect4)); + assertTrue(rect1.equals(rect5)); + } + + @Test + public void testIntersect() { + final Rectangle2 rect1 = new Rectangle2(0, 0, 10, 10); + final Rectangle2 rect2 = new Rectangle2(5, 5, 10, 10); + + Rectangle2 intersection = rect1.intersect(rect2, Rectangle2.fetchTempInstance()); + assertTrue(5 == intersection.getX()); + assertTrue(5 == intersection.getY()); + assertTrue(5 == intersection.getWidth()); + assertTrue(5 == intersection.getHeight()); + Rectangle2.releaseTempInstance(intersection); + assertNotNull(rect1.intersect(rect2, null)); + + intersection = Rectangle2.intersect(rect1, rect2, Rectangle2.fetchTempInstance()); + assertTrue(5 == intersection.getX()); + assertTrue(5 == intersection.getY()); + assertTrue(5 == intersection.getWidth()); + assertTrue(5 == intersection.getHeight()); + Rectangle2.releaseTempInstance(intersection); + assertNotNull(Rectangle2.intersect(rect1, rect2, null)); + + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle3.java index 0a98953..8206045 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestRectangle3.java @@ -1,102 +1,102 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestRectangle3 {
-
- @Test
- public void testGetSet() {
- final Rectangle3 rect = new Rectangle3();
- assertEquals(Vector3.ZERO, rect.getA());
- assertEquals(Vector3.ZERO, rect.getB());
- assertEquals(Vector3.ZERO, rect.getC());
-
- rect.setA(Vector3.ONE);
- rect.setB(Vector3.UNIT_X);
- rect.setC(Vector3.UNIT_Z);
- assertEquals(Vector3.ONE, rect.getA());
- assertEquals(Vector3.UNIT_X, rect.getB());
- assertEquals(Vector3.UNIT_Z, rect.getC());
-
- final Rectangle3 rect2 = new Rectangle3(rect);
- assertEquals(Vector3.ONE, rect2.getA());
- assertEquals(Vector3.UNIT_X, rect2.getB());
- assertEquals(Vector3.UNIT_Z, rect2.getC());
-
- final Rectangle3 rect3 = new Rectangle3(Vector3.NEG_ONE, Vector3.UNIT_Z, Vector3.NEG_UNIT_Y);
- assertEquals(Vector3.NEG_ONE, rect3.getA());
- assertEquals(Vector3.UNIT_Z, rect3.getB());
- assertEquals(Vector3.NEG_UNIT_Y, rect3.getC());
- }
-
- @Test
- public void testEquals() {
- // couple of equals validity tests
- final Rectangle3 rect1 = new Rectangle3();
- assertEquals(rect1, rect1);
- assertFalse(rect1.equals(null));
- assertFalse(rect1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Rectangle3 rect2 = Rectangle3.fetchTempInstance();
- rect2.set(rect1);
- assertEquals(rect1, rect2);
- assertNotSame(rect1, rect2);
- Rectangle3.releaseTempInstance(rect2);
-
- // cover more of equals
- assertTrue(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.ZERO, Vector3.ZERO)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.ZERO, Vector3.UNIT_X)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.UNIT_X, Vector3.UNIT_X)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.UNIT_X, Vector3.ZERO)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.ZERO, Vector3.ZERO)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.ZERO, Vector3.UNIT_X)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.ZERO)));
- assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.UNIT_X)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Rectangle3 rect1 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X);
- final Rectangle3 rect2 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X);
- final Rectangle3 rect3 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_Z);
-
- assertTrue(rect1.hashCode() == rect2.hashCode());
- assertTrue(rect1.hashCode() != rect3.hashCode());
- }
-
- @Test
- public void testClone() {
- final Rectangle3 rect1 = new Rectangle3();
- final Rectangle3 rect2 = rect1.clone();
- assertEquals(rect1, rect2);
- assertNotSame(rect1, rect2);
- }
-
- @Test
- public void testRandom() {
- MathUtils.setRandomSeed(0);
- final Rectangle3 rect1 = new Rectangle3();
- final Vector3 store = rect1.random(null);
- assertEquals(new Vector3(0.0, 0.0, 0.0), store);
-
- rect1.setA(new Vector3(1, 0, 0));
- rect1.setB(new Vector3(1, 1, 0));
- rect1.setC(new Vector3(0, 1, 0));
- rect1.random(store);
- assertEquals(new Vector3(0.39365482330322266, 0.8468815684318542, 0.0), store);
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestRectangle3 { + + @Test + public void testGetSet() { + final Rectangle3 rect = new Rectangle3(); + assertEquals(Vector3.ZERO, rect.getA()); + assertEquals(Vector3.ZERO, rect.getB()); + assertEquals(Vector3.ZERO, rect.getC()); + + rect.setA(Vector3.ONE); + rect.setB(Vector3.UNIT_X); + rect.setC(Vector3.UNIT_Z); + assertEquals(Vector3.ONE, rect.getA()); + assertEquals(Vector3.UNIT_X, rect.getB()); + assertEquals(Vector3.UNIT_Z, rect.getC()); + + final Rectangle3 rect2 = new Rectangle3(rect); + assertEquals(Vector3.ONE, rect2.getA()); + assertEquals(Vector3.UNIT_X, rect2.getB()); + assertEquals(Vector3.UNIT_Z, rect2.getC()); + + final Rectangle3 rect3 = new Rectangle3(Vector3.NEG_ONE, Vector3.UNIT_Z, Vector3.NEG_UNIT_Y); + assertEquals(Vector3.NEG_ONE, rect3.getA()); + assertEquals(Vector3.UNIT_Z, rect3.getB()); + assertEquals(Vector3.NEG_UNIT_Y, rect3.getC()); + } + + @Test + public void testEquals() { + // couple of equals validity tests + final Rectangle3 rect1 = new Rectangle3(); + assertEquals(rect1, rect1); + assertFalse(rect1.equals(null)); + assertFalse(rect1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Rectangle3 rect2 = Rectangle3.fetchTempInstance(); + rect2.set(rect1); + assertEquals(rect1, rect2); + assertNotSame(rect1, rect2); + Rectangle3.releaseTempInstance(rect2); + + // cover more of equals + assertTrue(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.ZERO, Vector3.ZERO))); + assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.ZERO, Vector3.UNIT_X))); + assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.UNIT_X, Vector3.UNIT_X))); + assertFalse(rect1.equals(new Rectangle3(Vector3.ZERO, Vector3.UNIT_X, Vector3.ZERO))); + assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.ZERO, Vector3.ZERO))); + assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.ZERO, Vector3.UNIT_X))); + assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.ZERO))); + assertFalse(rect1.equals(new Rectangle3(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.UNIT_X))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Rectangle3 rect1 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X); + final Rectangle3 rect2 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X); + final Rectangle3 rect3 = new Rectangle3(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_Z); + + assertTrue(rect1.hashCode() == rect2.hashCode()); + assertTrue(rect1.hashCode() != rect3.hashCode()); + } + + @Test + public void testClone() { + final Rectangle3 rect1 = new Rectangle3(); + final Rectangle3 rect2 = rect1.clone(); + assertEquals(rect1, rect2); + assertNotSame(rect1, rect2); + } + + @Test + public void testRandom() { + MathUtils.setRandomSeed(0); + final Rectangle3 rect1 = new Rectangle3(); + final Vector3 store = rect1.random(null); + assertEquals(new Vector3(0.0, 0.0, 0.0), store); + + rect1.setA(new Vector3(1, 0, 0)); + rect1.setB(new Vector3(1, 1, 0)); + rect1.setC(new Vector3(0, 1, 0)); + rect1.random(store); + assertEquals(new Vector3(0.39365482330322266, 0.8468815684318542, 0.0), store); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestRing.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestRing.java index b6120ab..f4db455 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestRing.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestRing.java @@ -1,113 +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;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestRing {
-
- @Test
- public void testGetSet() {
- final Ring ring = new Ring();
- assertEquals(Vector3.ZERO, ring.getCenter());
- assertEquals(Vector3.UNIT_Y, ring.getUp());
- assertTrue(ring.getInnerRadius() == 0.0);
- assertTrue(ring.getOuterRadius() == 1.0);
-
- ring.setCenter(Vector3.ONE);
- ring.setUp(Vector3.UNIT_X);
- ring.setInnerRadius(1.5);
- ring.setOuterRadius(3.0);
- assertEquals(Vector3.ONE, ring.getCenter());
- assertEquals(Vector3.UNIT_X, ring.getUp());
- assertTrue(ring.getInnerRadius() == 1.5);
- assertTrue(ring.getOuterRadius() == 3.0);
-
- final Ring ring2 = new Ring(ring);
- assertEquals(Vector3.ONE, ring2.getCenter());
- assertEquals(Vector3.UNIT_X, ring2.getUp());
- assertTrue(ring2.getInnerRadius() == 1.5);
- assertTrue(ring2.getOuterRadius() == 3.0);
-
- final Ring ring3 = new Ring(Vector3.NEG_ONE, Vector3.UNIT_Z, 12.0, 42.0);
- assertEquals(Vector3.NEG_ONE, ring3.getCenter());
- assertEquals(Vector3.UNIT_Z, ring3.getUp());
- assertTrue(ring3.getInnerRadius() == 12.0);
- assertTrue(ring3.getOuterRadius() == 42.0);
- }
-
- @Test
- public void testValid() {
- assertTrue(Ring.isValid(new Ring()));
- assertFalse(Ring.isValid(null));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, Double.NaN)));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, Double.POSITIVE_INFINITY)));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, Double.NaN, 1.0)));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, Double.NEGATIVE_INFINITY, 1.0)));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, new Vector3(Double.NaN, 0, 0), 0.0, 1.0)));
- assertFalse(Ring.isValid(new Ring(Vector3.ZERO, new Vector3(Double.POSITIVE_INFINITY, 0, 0), 0.0, 1.0)));
- assertFalse(Ring.isValid(new Ring(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Y, 0.0, 1.0)));
- assertFalse(Ring.isValid(new Ring(new Vector3(Double.NEGATIVE_INFINITY, 0, 0), Vector3.UNIT_Y, 0.0, 1.0)));
-
- // couple of equals validity tests
- final Ring ring1 = new Ring();
- assertEquals(ring1, ring1);
- assertFalse(ring1.equals(null));
- assertFalse(ring1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Ring ring2 = Ring.fetchTempInstance();
- ring2.set(ring1);
- assertEquals(ring1, ring2);
- assertNotSame(ring1, ring2);
- Ring.releaseTempInstance(ring2);
-
- // cover more of equals
- assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, -1.0, 2.0)));
- assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, -1.0, 1.0)));
- assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, 0.0, 1.0)));
- assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_Y, 0.0, 1.0)));
- assertTrue(ring1.equals(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 1.0)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Ring ring1 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 2.0);
- final Ring ring2 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 2.0);
- final Ring ring3 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 3.0);
-
- assertTrue(ring1.hashCode() == ring2.hashCode());
- assertTrue(ring1.hashCode() != ring3.hashCode());
- }
-
- @Test
- public void testClone() {
- final Ring ring1 = new Ring();
- final Ring ring2 = ring1.clone();
- assertEquals(ring1, ring2);
- assertNotSame(ring1, ring2);
- }
-
- @Test
- public void testRandom() {
- MathUtils.setRandomSeed(0);
- final Ring ring1 = new Ring();
- final Vector3 store = ring1.random(null);
- assertEquals(new Vector3(0.7454530390475868, 0.0, -0.4186496466746111), store);
-
- ring1.setUp(Vector3.UNIT_X);
- ring1.random(store);
- assertEquals(new Vector3(0.0, 0.30386186434027496, -0.3849731927481824), store);
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestRing { + + @Test + public void testGetSet() { + final Ring ring = new Ring(); + assertEquals(Vector3.ZERO, ring.getCenter()); + assertEquals(Vector3.UNIT_Y, ring.getUp()); + assertTrue(ring.getInnerRadius() == 0.0); + assertTrue(ring.getOuterRadius() == 1.0); + + ring.setCenter(Vector3.ONE); + ring.setUp(Vector3.UNIT_X); + ring.setInnerRadius(1.5); + ring.setOuterRadius(3.0); + assertEquals(Vector3.ONE, ring.getCenter()); + assertEquals(Vector3.UNIT_X, ring.getUp()); + assertTrue(ring.getInnerRadius() == 1.5); + assertTrue(ring.getOuterRadius() == 3.0); + + final Ring ring2 = new Ring(ring); + assertEquals(Vector3.ONE, ring2.getCenter()); + assertEquals(Vector3.UNIT_X, ring2.getUp()); + assertTrue(ring2.getInnerRadius() == 1.5); + assertTrue(ring2.getOuterRadius() == 3.0); + + final Ring ring3 = new Ring(Vector3.NEG_ONE, Vector3.UNIT_Z, 12.0, 42.0); + assertEquals(Vector3.NEG_ONE, ring3.getCenter()); + assertEquals(Vector3.UNIT_Z, ring3.getUp()); + assertTrue(ring3.getInnerRadius() == 12.0); + assertTrue(ring3.getOuterRadius() == 42.0); + } + + @Test + public void testValid() { + assertTrue(Ring.isValid(new Ring())); + assertFalse(Ring.isValid(null)); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, Double.NaN))); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, Double.POSITIVE_INFINITY))); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, Double.NaN, 1.0))); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, Vector3.UNIT_Y, Double.NEGATIVE_INFINITY, 1.0))); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, new Vector3(Double.NaN, 0, 0), 0.0, 1.0))); + assertFalse(Ring.isValid(new Ring(Vector3.ZERO, new Vector3(Double.POSITIVE_INFINITY, 0, 0), 0.0, 1.0))); + assertFalse(Ring.isValid(new Ring(new Vector3(Double.NaN, 0, 0), Vector3.UNIT_Y, 0.0, 1.0))); + assertFalse(Ring.isValid(new Ring(new Vector3(Double.NEGATIVE_INFINITY, 0, 0), Vector3.UNIT_Y, 0.0, 1.0))); + + // couple of equals validity tests + final Ring ring1 = new Ring(); + assertEquals(ring1, ring1); + assertFalse(ring1.equals(null)); + assertFalse(ring1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Ring ring2 = Ring.fetchTempInstance(); + ring2.set(ring1); + assertEquals(ring1, ring2); + assertNotSame(ring1, ring2); + Ring.releaseTempInstance(ring2); + + // cover more of equals + assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, -1.0, 2.0))); + assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, -1.0, 1.0))); + assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_X, 0.0, 1.0))); + assertFalse(ring1.equals(new Ring(Vector3.UNIT_X, Vector3.UNIT_Y, 0.0, 1.0))); + assertTrue(ring1.equals(new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 1.0))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Ring ring1 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 2.0); + final Ring ring2 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 2.0); + final Ring ring3 = new Ring(Vector3.ZERO, Vector3.UNIT_Y, 0.0, 3.0); + + assertTrue(ring1.hashCode() == ring2.hashCode()); + assertTrue(ring1.hashCode() != ring3.hashCode()); + } + + @Test + public void testClone() { + final Ring ring1 = new Ring(); + final Ring ring2 = ring1.clone(); + assertEquals(ring1, ring2); + assertNotSame(ring1, ring2); + } + + @Test + public void testRandom() { + MathUtils.setRandomSeed(0); + final Ring ring1 = new Ring(); + final Vector3 store = ring1.random(null); + assertEquals(new Vector3(0.7454530390475868, 0.0, -0.4186496466746111), store); + + ring1.setUp(Vector3.UNIT_X); + ring1.random(store); + assertEquals(new Vector3(0.0, 0.30386186434027496, -0.3849731927481824), store); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestTransform.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestTransform.java index 310e70f..b47c1c3 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestTransform.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestTransform.java @@ -1,424 +1,424 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import java.nio.DoubleBuffer;
-import java.nio.FloatBuffer;
-
-import org.junit.Test;
-
-public class TestTransform {
-
- @Test
- public void testGetSet() {
- final Transform trans = new Transform();
- assertEquals(Transform.IDENTITY, trans);
-
- final Transform immutable = new Transform(new Matrix3().applyRotationX(MathUtils.QUARTER_PI), new Vector3(0,
- -1, -2), new Vector3(1, 2, 3), true, true, true);
- assertTrue(true == immutable.isIdentity());
- assertTrue(true == immutable.isRotationMatrix());
- assertTrue(true == immutable.isUniformScale());
- assertEquals(new Matrix3().applyRotationX(MathUtils.QUARTER_PI), immutable.getMatrix());
- assertEquals(new Vector3(0, -1, -2), immutable.getScale());
- assertEquals(new Vector3(1, 2, 3), immutable.getTranslation());
-
- final Transform trans2 = new Transform(immutable);
- assertEquals(immutable, trans2);
- trans2.updateFlags(false);
-
- trans.set(immutable);
- assertEquals(Transform.IDENTITY, trans); // because of shortcut flags.
-
- trans.set(trans2);
- assertEquals(trans2, trans);
-
- trans.setIdentity();
- assertEquals(Transform.IDENTITY, trans);
-
- final double a = MathUtils.QUARTER_PI;
- trans.setRotation(new Quaternion().fromAngleAxis(a, Vector3.UNIT_Y));
-
- assertEquals(new Matrix3( //
- Math.cos(a), 0, Math.sin(a), //
- 0, 1, 0, //
- -Math.sin(a), 0, Math.cos(a)), trans.getMatrix());
-
- trans2.setRotation(new Matrix3().fromAngleAxis(a, Vector3.UNIT_Y));
- assertEquals(trans.getMatrix(), trans2.getMatrix());
-
- trans.setScale(1.0);
- assertEquals(Vector3.ONE, trans.getScale());
-
- trans.setScale(new Vector3(1, 2, 3));
- assertEquals(new Vector3(1, 2, 3), trans.getScale());
-
- trans.setScale(-1, 5, -3);
- assertEquals(new Vector3(-1, 5, -3), trans.getScale());
-
- trans.setTranslation(new Vector3(10, 20, 30));
- assertEquals(new Vector3(10, 20, 30), trans.getTranslation());
-
- trans.setTranslation(-10, 50, -30);
- assertEquals(new Vector3(-10, 50, -30), trans.getTranslation());
-
- trans.setIdentity();
- trans.setRotation(new Matrix3().fromAngleAxis(a, Vector3.UNIT_Y));
- trans.setScale(2, 3, 4);
- trans.setTranslation(5, 10, 15);
-
- final Matrix4 mat4 = trans.getHomogeneousMatrix(null);
- assertEquals(new Matrix4( //
- 2 * Math.cos(a), 2 * 0, 2 * Math.sin(a), 5, //
- 3 * 0, 3 * 1, 3 * 0, 10, //
- 4 * -Math.sin(a), 4 * 0, 4 * Math.cos(a), 15, //
- 0, 0, 0, 1), mat4);
-
- trans2.fromHomogeneousMatrix(mat4);
- trans2.getHomogeneousMatrix(mat4);
- assertEquals(new Matrix4( //
- 2 * Math.cos(a), 2 * 0, 2 * Math.sin(a), 5, //
- 3 * 0, 3 * 1, 3 * 0, 10, //
- 4 * -Math.sin(a), 4 * 0, 4 * Math.cos(a), 15, //
- 0, 0, 0, 1), mat4);
-
- trans.setIdentity();
- trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8));
- trans.setTranslation(10, 11, 12);
- trans.getHomogeneousMatrix(mat4);
- assertEquals(new Matrix4( //
- 0, 1, 2, 10, //
- 3, 4, 5, 11, //
- 6, 7, 8, 12, //
- 0, 0, 0, 1), mat4);
-
- }
-
- @Test(expected = TransformException.class)
- public void testFailScale1A() {
- final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false);
- trans.setScale(Vector3.ONE);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testFailScale1B() {
- final Transform trans = new Transform();
- trans.setScale(Vector3.ZERO);
- }
-
- @Test(expected = TransformException.class)
- public void testFailScale2A() {
- final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false);
- trans.setScale(1, 1, 1);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testFailScale2B() {
- final Transform trans = new Transform();
- trans.setScale(0, 0, 0);
- }
-
- @Test(expected = TransformException.class)
- public void testFailScale3A() {
- final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false);
- trans.setScale(1);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testFailScale3B() {
- final Transform trans = new Transform();
- trans.setScale(0);
- }
-
- @Test
- public void testTranslate() {
- final Transform trans = new Transform();
- trans.translate(1, 3, 5);
- assertEquals(new Vector3(1, 3, 5), trans.getTranslation());
- trans.translate(trans.getTranslation().negate(null));
- assertEquals(Vector3.ZERO, trans.getTranslation());
-
- trans.translate(new Vector3(1, 3, 5));
- assertEquals(new Vector3(1, 3, 5), trans.getTranslation());
- trans.translate(-1, -3, -5);
- assertEquals(Vector3.ZERO, trans.getTranslation());
- }
-
- @Test
- public void testApplyVector3() {
- final Transform trans = new Transform().setRotation(new Matrix3().applyRotationX(MathUtils.HALF_PI)).translate(
- 1, 2, 3);
- final Vector3 vec3 = new Vector3(0, 1, 0);
-
- final Vector3 result = trans.applyForward(vec3, null);
- assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON);
- trans.applyForward(vec3, result);
- assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON);
- trans.applyForward(vec3);
- assertTrue(Math.abs(new Vector3(1, 2, 4).distance(vec3)) <= MathUtils.EPSILON);
-
- vec3.set(0, 1, 1);
- final Vector3 result2 = trans.applyForwardVector(vec3, null);
- assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result2)) <= MathUtils.EPSILON);
- trans.applyForwardVector(vec3, result2);
- assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result2)) <= MathUtils.EPSILON);
- trans.applyForwardVector(vec3);
- assertTrue(Math.abs(new Vector3(0, -1, 1).distance(vec3)) <= MathUtils.EPSILON);
-
- vec3.set(0, 1, 0);
- final Vector3 result3 = trans.applyInverse(vec3, null);
- assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(result3)) <= MathUtils.EPSILON);
- trans.applyInverse(vec3, result3);
- assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(result3)) <= MathUtils.EPSILON);
- trans.applyInverse(vec3);
- assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(vec3)) <= MathUtils.EPSILON);
-
- vec3.set(0, 1, 1);
- final Vector3 result4 = trans.applyInverseVector(vec3, null);
- assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result4)) <= MathUtils.EPSILON);
- trans.applyInverseVector(vec3, result4);
- assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result4)) <= MathUtils.EPSILON);
- trans.applyInverseVector(vec3);
- assertTrue(Math.abs(new Vector3(0, 1, -1).distance(vec3)) <= MathUtils.EPSILON);
-
- trans.setRotation(new Matrix3().applyRotationY(MathUtils.PI)).translate(2, 3, -1);
-
- vec3.set(1, 2, 3).normalizeLocal();
- final Vector3 orig = new Vector3(vec3);
- trans.applyForward(vec3);
- trans.applyInverse(vec3);
- assertTrue(Math.abs(orig.distance(vec3)) <= 10 * MathUtils.EPSILON); // accumulated error
-
- vec3.set(orig);
- trans.applyForwardVector(vec3);
- trans.applyInverseVector(vec3);
- assertTrue(Math.abs(orig.distance(vec3)) <= 10 * MathUtils.EPSILON); // accumulated error
-
- vec3.set(orig);
- trans.setIdentity();
- trans.applyForward(vec3);
- assertEquals(orig, vec3);
- trans.applyForwardVector(vec3);
- assertEquals(orig, vec3);
- trans.applyInverse(vec3);
- assertEquals(orig, vec3);
- trans.applyInverseVector(vec3);
- assertEquals(orig, vec3);
- }
-
- @Test(expected = NullPointerException.class)
- public void testApplyFail1() {
- final Transform trans = new Transform();
- trans.applyForward(null);
- }
-
- @Test(expected = NullPointerException.class)
- public void testApplyFail2() {
- final Transform trans = new Transform();
- trans.applyForwardVector(null);
- }
-
- @Test(expected = NullPointerException.class)
- public void testApplyFail3() {
- final Transform trans = new Transform();
- trans.applyInverse(null);
- }
-
- @Test(expected = NullPointerException.class)
- public void testApplyFail4() {
- final Transform trans = new Transform();
- trans.applyInverseVector(null);
- }
-
- @Test
- public void testMultiply() {
- final Transform trans1 = new Transform();
- final Transform trans2 = new Transform();
- assertEquals(Transform.IDENTITY, trans1.multiply(trans2, null));
-
- trans1.setTranslation(1, 2, 3);
- final Transform trans3 = trans1.multiply(trans2, null);
- assertEquals(trans1, trans3);
-
- trans2.setTranslation(-1, -2, -3);
- trans1.multiply(trans2, trans3);
- assertEquals(Transform.IDENTITY, trans3);
- assertTrue(trans3.isRotationMatrix());
- assertTrue(trans3.isIdentity());
- assertTrue(trans3.isUniformScale());
-
- trans2.setScale(1, 2, 1);
- trans1.multiply(trans2, trans3);
- assertEquals(new Transform().setScale(1, 2, 1), trans3);
- assertTrue(trans3.isRotationMatrix());
- assertFalse(trans3.isIdentity());
- assertFalse(trans3.isUniformScale());
-
- trans1.setScale(1, 2, 1);
- trans1.multiply(trans2, trans3);
- assertEquals(new Transform().setRotation(new Matrix3(1, 0, 0, 0, 4, 0, 0, 0, 1)).setTranslation(0, -2, 0),
- trans3);
- assertFalse(trans3.isRotationMatrix());
- assertFalse(trans3.isIdentity());
- assertFalse(trans3.isUniformScale());
- }
-
- @Test
- public void testInvert() {
- final Transform trans1 = new Transform();
- trans1.setRotation(new Matrix3().applyRotationZ(3 * MathUtils.QUARTER_PI));
- final Transform trans2 = trans1.invert(null);
- assertEquals(Transform.IDENTITY, trans1.multiply(trans2, null));
-
- trans1.setIdentity().invert(trans1);
- assertEquals(Transform.IDENTITY, trans1);
- }
-
- @Test
- public void testClone() {
- final Transform trans1 = new Transform();
- final Transform trans2 = trans1.clone();
- assertEquals(trans1, trans2);
- assertNotSame(trans1, trans2);
- }
-
- @Test
- public void testValid() {
- final Transform trans = new Transform();
- assertTrue(Transform.isValid(trans));
- trans.setIdentity();
- trans.setRotation(new Matrix3(Double.NaN, 0, 0, 0, 0, 0, 0, 0, 0));
- assertFalse(Transform.isValid(trans));
- trans.setIdentity();
- trans.setScale(Double.NaN, 0, 0);
- assertFalse(Transform.isValid(trans));
- trans.setScale(Double.NaN);
- assertFalse(Transform.isValid(trans));
- trans.setIdentity();
- trans.setTranslation(Double.NaN, 0, 0);
- assertFalse(Transform.isValid(trans));
-
- trans.setIdentity();
- assertTrue(Transform.isValid(trans));
-
- assertFalse(Transform.isValid(null));
-
- // couple of equals validity tests
- assertEquals(trans, trans);
- assertTrue(trans.strictEquals(trans));
- assertFalse(trans.equals(null));
- assertFalse(trans.strictEquals(null));
- assertFalse(trans.equals(new Vector2()));
- assertFalse(trans.strictEquals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Transform transTemp = Transform.fetchTempInstance();
- transTemp.set(trans);
- assertEquals(trans, transTemp);
- assertNotSame(trans, transTemp);
- Transform.releaseTempInstance(transTemp);
-
- // cover more of equals
- trans.setScale(1, 2, 3);
- trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8));
- trans.setTranslation(1, 2, 3);
- final Transform comp = new Transform();
- final Matrix3 mat3 = new Matrix3(-1, -1, -1, -1, -1, -1, -1, -1, -1);
- comp.setScale(-1, -1, -1);
- comp.setRotation(mat3);
- comp.setTranslation(-1, -1, -1);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- for (int i = 0; i < 8; i++) {
- mat3.setValue(i / 3, i % 3, i);
- comp.setRotation(mat3);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- }
- // test translation
- trans.setRotation(Matrix3.IDENTITY);
- comp.setRotation(Matrix3.IDENTITY);
- comp.setTranslation(1, -1, -1);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- comp.setTranslation(1, 2, -1);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- comp.setTranslation(1, 2, 3);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
-
- // test scale
- comp.setScale(1, -1, -1);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- comp.setScale(1, 2, -1);
- assertFalse(trans.equals(comp));
- assertFalse(trans.strictEquals(comp));
- comp.setScale(1, 2, 3);
- assertTrue(trans.equals(comp));
- assertTrue(trans.strictEquals(comp));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Transform trans1 = new Transform().setTranslation(1, 2, 3);
- final Transform trans2 = new Transform().setTranslation(1, 2, 3);
- final Transform trans3 = new Transform().setTranslation(1, 2, 0);
-
- assertTrue(trans1.hashCode() == trans2.hashCode());
- assertTrue(trans1.hashCode() != trans3.hashCode());
- }
-
- @Test
- public void testGLApplyMatrix() {
- final Transform trans = new Transform();
-
- // non-rotational
- trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8));
- trans.setTranslation(10, 11, 12);
- final DoubleBuffer db = DoubleBuffer.allocate(16);
- trans.getGLApplyMatrix(db);
- for (final double val : new double[] { 0, 3, 6, 0, 1, 4, 7, 0, 2, 5, 8, 0, 10, 11, 12, 1 }) {
- assertTrue(val == db.get());
- }
- final FloatBuffer fb = FloatBuffer.allocate(16);
- trans.getGLApplyMatrix(fb);
- for (final float val : new float[] { 0, 3, 6, 0, 1, 4, 7, 0, 2, 5, 8, 0, 10, 11, 12, 1 }) {
- assertTrue(val == fb.get());
- }
-
- // rotational
- final double a = MathUtils.QUARTER_PI;
- trans.setRotation(new Matrix3().applyRotationY(a));
- trans.setTranslation(10, 11, 12);
- trans.setScale(2, 3, 4);
- db.rewind();
- trans.getGLApplyMatrix(db);
- for (final double val : new double[] { 2 * Math.cos(a), 2 * 0, 2 * -Math.sin(a), 0, //
- 3 * 0, 3 * 1, 3 * 0, 0, //
- 4 * Math.sin(a), 4 * 0, 4 * Math.cos(a), 0, //
- 10, 11, 12, 1 }) {
- assertTrue(val == db.get());
- }
- fb.rewind();
- trans.getGLApplyMatrix(fb);
- for (final float val : new float[] { (float) (2 * Math.cos(a)), 2 * 0, (float) (2 * -Math.sin(a)), 0, //
- 3 * 0, 3 * 1, 3 * 0, 0, //
- (float) (4 * Math.sin(a)), 4 * 0, (float) (4 * Math.cos(a)), 0, //
- 10, 11, 12, 1 }) {
- assertTrue(val == fb.get());
- }
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; + +import org.junit.Test; + +public class TestTransform { + + @Test + public void testGetSet() { + final Transform trans = new Transform(); + assertEquals(Transform.IDENTITY, trans); + + final Transform immutable = new Transform(new Matrix3().applyRotationX(MathUtils.QUARTER_PI), new Vector3(0, + -1, -2), new Vector3(1, 2, 3), true, true, true); + assertTrue(true == immutable.isIdentity()); + assertTrue(true == immutable.isRotationMatrix()); + assertTrue(true == immutable.isUniformScale()); + assertEquals(new Matrix3().applyRotationX(MathUtils.QUARTER_PI), immutable.getMatrix()); + assertEquals(new Vector3(0, -1, -2), immutable.getScale()); + assertEquals(new Vector3(1, 2, 3), immutable.getTranslation()); + + final Transform trans2 = new Transform(immutable); + assertEquals(immutable, trans2); + trans2.updateFlags(false); + + trans.set(immutable); + assertEquals(Transform.IDENTITY, trans); // because of shortcut flags. + + trans.set(trans2); + assertEquals(trans2, trans); + + trans.setIdentity(); + assertEquals(Transform.IDENTITY, trans); + + final double a = MathUtils.QUARTER_PI; + trans.setRotation(new Quaternion().fromAngleAxis(a, Vector3.UNIT_Y)); + + assertEquals(new Matrix3( // + Math.cos(a), 0, Math.sin(a), // + 0, 1, 0, // + -Math.sin(a), 0, Math.cos(a)), trans.getMatrix()); + + trans2.setRotation(new Matrix3().fromAngleAxis(a, Vector3.UNIT_Y)); + assertEquals(trans.getMatrix(), trans2.getMatrix()); + + trans.setScale(1.0); + assertEquals(Vector3.ONE, trans.getScale()); + + trans.setScale(new Vector3(1, 2, 3)); + assertEquals(new Vector3(1, 2, 3), trans.getScale()); + + trans.setScale(-1, 5, -3); + assertEquals(new Vector3(-1, 5, -3), trans.getScale()); + + trans.setTranslation(new Vector3(10, 20, 30)); + assertEquals(new Vector3(10, 20, 30), trans.getTranslation()); + + trans.setTranslation(-10, 50, -30); + assertEquals(new Vector3(-10, 50, -30), trans.getTranslation()); + + trans.setIdentity(); + trans.setRotation(new Matrix3().fromAngleAxis(a, Vector3.UNIT_Y)); + trans.setScale(2, 3, 4); + trans.setTranslation(5, 10, 15); + + final Matrix4 mat4 = trans.getHomogeneousMatrix(null); + assertEquals(new Matrix4( // + 2 * Math.cos(a), 2 * 0, 2 * Math.sin(a), 5, // + 3 * 0, 3 * 1, 3 * 0, 10, // + 4 * -Math.sin(a), 4 * 0, 4 * Math.cos(a), 15, // + 0, 0, 0, 1), mat4); + + trans2.fromHomogeneousMatrix(mat4); + trans2.getHomogeneousMatrix(mat4); + assertEquals(new Matrix4( // + 2 * Math.cos(a), 2 * 0, 2 * Math.sin(a), 5, // + 3 * 0, 3 * 1, 3 * 0, 10, // + 4 * -Math.sin(a), 4 * 0, 4 * Math.cos(a), 15, // + 0, 0, 0, 1), mat4); + + trans.setIdentity(); + trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8)); + trans.setTranslation(10, 11, 12); + trans.getHomogeneousMatrix(mat4); + assertEquals(new Matrix4( // + 0, 1, 2, 10, // + 3, 4, 5, 11, // + 6, 7, 8, 12, // + 0, 0, 0, 1), mat4); + + } + + @Test(expected = TransformException.class) + public void testFailScale1A() { + final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false); + trans.setScale(Vector3.ONE); + } + + @Test(expected = IllegalArgumentException.class) + public void testFailScale1B() { + final Transform trans = new Transform(); + trans.setScale(Vector3.ZERO); + } + + @Test(expected = TransformException.class) + public void testFailScale2A() { + final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false); + trans.setScale(1, 1, 1); + } + + @Test(expected = IllegalArgumentException.class) + public void testFailScale2B() { + final Transform trans = new Transform(); + trans.setScale(0, 0, 0); + } + + @Test(expected = TransformException.class) + public void testFailScale3A() { + final Transform trans = new Transform(new Matrix3(), new Vector3(), new Vector3(), false, false, false); + trans.setScale(1); + } + + @Test(expected = IllegalArgumentException.class) + public void testFailScale3B() { + final Transform trans = new Transform(); + trans.setScale(0); + } + + @Test + public void testTranslate() { + final Transform trans = new Transform(); + trans.translate(1, 3, 5); + assertEquals(new Vector3(1, 3, 5), trans.getTranslation()); + trans.translate(trans.getTranslation().negate(null)); + assertEquals(Vector3.ZERO, trans.getTranslation()); + + trans.translate(new Vector3(1, 3, 5)); + assertEquals(new Vector3(1, 3, 5), trans.getTranslation()); + trans.translate(-1, -3, -5); + assertEquals(Vector3.ZERO, trans.getTranslation()); + } + + @Test + public void testApplyVector3() { + final Transform trans = new Transform().setRotation(new Matrix3().applyRotationX(MathUtils.HALF_PI)).translate( + 1, 2, 3); + final Vector3 vec3 = new Vector3(0, 1, 0); + + final Vector3 result = trans.applyForward(vec3, null); + assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON); + trans.applyForward(vec3, result); + assertTrue(Math.abs(new Vector3(1, 2, 4).distance(result)) <= MathUtils.EPSILON); + trans.applyForward(vec3); + assertTrue(Math.abs(new Vector3(1, 2, 4).distance(vec3)) <= MathUtils.EPSILON); + + vec3.set(0, 1, 1); + final Vector3 result2 = trans.applyForwardVector(vec3, null); + assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result2)) <= MathUtils.EPSILON); + trans.applyForwardVector(vec3, result2); + assertTrue(Math.abs(new Vector3(0, -1, 1).distance(result2)) <= MathUtils.EPSILON); + trans.applyForwardVector(vec3); + assertTrue(Math.abs(new Vector3(0, -1, 1).distance(vec3)) <= MathUtils.EPSILON); + + vec3.set(0, 1, 0); + final Vector3 result3 = trans.applyInverse(vec3, null); + assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(result3)) <= MathUtils.EPSILON); + trans.applyInverse(vec3, result3); + assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(result3)) <= MathUtils.EPSILON); + trans.applyInverse(vec3); + assertTrue(Math.abs(new Vector3(-1, -3, 1).distance(vec3)) <= MathUtils.EPSILON); + + vec3.set(0, 1, 1); + final Vector3 result4 = trans.applyInverseVector(vec3, null); + assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result4)) <= MathUtils.EPSILON); + trans.applyInverseVector(vec3, result4); + assertTrue(Math.abs(new Vector3(0, 1, -1).distance(result4)) <= MathUtils.EPSILON); + trans.applyInverseVector(vec3); + assertTrue(Math.abs(new Vector3(0, 1, -1).distance(vec3)) <= MathUtils.EPSILON); + + trans.setRotation(new Matrix3().applyRotationY(MathUtils.PI)).translate(2, 3, -1); + + vec3.set(1, 2, 3).normalizeLocal(); + final Vector3 orig = new Vector3(vec3); + trans.applyForward(vec3); + trans.applyInverse(vec3); + assertTrue(Math.abs(orig.distance(vec3)) <= 10 * MathUtils.EPSILON); // accumulated error + + vec3.set(orig); + trans.applyForwardVector(vec3); + trans.applyInverseVector(vec3); + assertTrue(Math.abs(orig.distance(vec3)) <= 10 * MathUtils.EPSILON); // accumulated error + + vec3.set(orig); + trans.setIdentity(); + trans.applyForward(vec3); + assertEquals(orig, vec3); + trans.applyForwardVector(vec3); + assertEquals(orig, vec3); + trans.applyInverse(vec3); + assertEquals(orig, vec3); + trans.applyInverseVector(vec3); + assertEquals(orig, vec3); + } + + @Test(expected = NullPointerException.class) + public void testApplyFail1() { + final Transform trans = new Transform(); + trans.applyForward(null); + } + + @Test(expected = NullPointerException.class) + public void testApplyFail2() { + final Transform trans = new Transform(); + trans.applyForwardVector(null); + } + + @Test(expected = NullPointerException.class) + public void testApplyFail3() { + final Transform trans = new Transform(); + trans.applyInverse(null); + } + + @Test(expected = NullPointerException.class) + public void testApplyFail4() { + final Transform trans = new Transform(); + trans.applyInverseVector(null); + } + + @Test + public void testMultiply() { + final Transform trans1 = new Transform(); + final Transform trans2 = new Transform(); + assertEquals(Transform.IDENTITY, trans1.multiply(trans2, null)); + + trans1.setTranslation(1, 2, 3); + final Transform trans3 = trans1.multiply(trans2, null); + assertEquals(trans1, trans3); + + trans2.setTranslation(-1, -2, -3); + trans1.multiply(trans2, trans3); + assertEquals(Transform.IDENTITY, trans3); + assertTrue(trans3.isRotationMatrix()); + assertTrue(trans3.isIdentity()); + assertTrue(trans3.isUniformScale()); + + trans2.setScale(1, 2, 1); + trans1.multiply(trans2, trans3); + assertEquals(new Transform().setScale(1, 2, 1), trans3); + assertTrue(trans3.isRotationMatrix()); + assertFalse(trans3.isIdentity()); + assertFalse(trans3.isUniformScale()); + + trans1.setScale(1, 2, 1); + trans1.multiply(trans2, trans3); + assertEquals(new Transform().setRotation(new Matrix3(1, 0, 0, 0, 4, 0, 0, 0, 1)).setTranslation(0, -2, 0), + trans3); + assertFalse(trans3.isRotationMatrix()); + assertFalse(trans3.isIdentity()); + assertFalse(trans3.isUniformScale()); + } + + @Test + public void testInvert() { + final Transform trans1 = new Transform(); + trans1.setRotation(new Matrix3().applyRotationZ(3 * MathUtils.QUARTER_PI)); + final Transform trans2 = trans1.invert(null); + assertEquals(Transform.IDENTITY, trans1.multiply(trans2, null)); + + trans1.setIdentity().invert(trans1); + assertEquals(Transform.IDENTITY, trans1); + } + + @Test + public void testClone() { + final Transform trans1 = new Transform(); + final Transform trans2 = trans1.clone(); + assertEquals(trans1, trans2); + assertNotSame(trans1, trans2); + } + + @Test + public void testValid() { + final Transform trans = new Transform(); + assertTrue(Transform.isValid(trans)); + trans.setIdentity(); + trans.setRotation(new Matrix3(Double.NaN, 0, 0, 0, 0, 0, 0, 0, 0)); + assertFalse(Transform.isValid(trans)); + trans.setIdentity(); + trans.setScale(Double.NaN, 0, 0); + assertFalse(Transform.isValid(trans)); + trans.setScale(Double.NaN); + assertFalse(Transform.isValid(trans)); + trans.setIdentity(); + trans.setTranslation(Double.NaN, 0, 0); + assertFalse(Transform.isValid(trans)); + + trans.setIdentity(); + assertTrue(Transform.isValid(trans)); + + assertFalse(Transform.isValid(null)); + + // couple of equals validity tests + assertEquals(trans, trans); + assertTrue(trans.strictEquals(trans)); + assertFalse(trans.equals(null)); + assertFalse(trans.strictEquals(null)); + assertFalse(trans.equals(new Vector2())); + assertFalse(trans.strictEquals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Transform transTemp = Transform.fetchTempInstance(); + transTemp.set(trans); + assertEquals(trans, transTemp); + assertNotSame(trans, transTemp); + Transform.releaseTempInstance(transTemp); + + // cover more of equals + trans.setScale(1, 2, 3); + trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8)); + trans.setTranslation(1, 2, 3); + final Transform comp = new Transform(); + final Matrix3 mat3 = new Matrix3(-1, -1, -1, -1, -1, -1, -1, -1, -1); + comp.setScale(-1, -1, -1); + comp.setRotation(mat3); + comp.setTranslation(-1, -1, -1); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + for (int i = 0; i < 8; i++) { + mat3.setValue(i / 3, i % 3, i); + comp.setRotation(mat3); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + } + // test translation + trans.setRotation(Matrix3.IDENTITY); + comp.setRotation(Matrix3.IDENTITY); + comp.setTranslation(1, -1, -1); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + comp.setTranslation(1, 2, -1); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + comp.setTranslation(1, 2, 3); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + + // test scale + comp.setScale(1, -1, -1); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + comp.setScale(1, 2, -1); + assertFalse(trans.equals(comp)); + assertFalse(trans.strictEquals(comp)); + comp.setScale(1, 2, 3); + assertTrue(trans.equals(comp)); + assertTrue(trans.strictEquals(comp)); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Transform trans1 = new Transform().setTranslation(1, 2, 3); + final Transform trans2 = new Transform().setTranslation(1, 2, 3); + final Transform trans3 = new Transform().setTranslation(1, 2, 0); + + assertTrue(trans1.hashCode() == trans2.hashCode()); + assertTrue(trans1.hashCode() != trans3.hashCode()); + } + + @Test + public void testGLApplyMatrix() { + final Transform trans = new Transform(); + + // non-rotational + trans.setRotation(new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8)); + trans.setTranslation(10, 11, 12); + final DoubleBuffer db = DoubleBuffer.allocate(16); + trans.getGLApplyMatrix(db); + for (final double val : new double[] { 0, 3, 6, 0, 1, 4, 7, 0, 2, 5, 8, 0, 10, 11, 12, 1 }) { + assertTrue(val == db.get()); + } + final FloatBuffer fb = FloatBuffer.allocate(16); + trans.getGLApplyMatrix(fb); + for (final float val : new float[] { 0, 3, 6, 0, 1, 4, 7, 0, 2, 5, 8, 0, 10, 11, 12, 1 }) { + assertTrue(val == fb.get()); + } + + // rotational + final double a = MathUtils.QUARTER_PI; + trans.setRotation(new Matrix3().applyRotationY(a)); + trans.setTranslation(10, 11, 12); + trans.setScale(2, 3, 4); + db.rewind(); + trans.getGLApplyMatrix(db); + for (final double val : new double[] { 2 * Math.cos(a), 2 * 0, 2 * -Math.sin(a), 0, // + 3 * 0, 3 * 1, 3 * 0, 0, // + 4 * Math.sin(a), 4 * 0, 4 * Math.cos(a), 0, // + 10, 11, 12, 1 }) { + assertTrue(val == db.get()); + } + fb.rewind(); + trans.getGLApplyMatrix(fb); + for (final float val : new float[] { (float) (2 * Math.cos(a)), 2 * 0, (float) (2 * -Math.sin(a)), 0, // + 3 * 0, 3 * 1, 3 * 0, 0, // + (float) (4 * Math.sin(a)), 4 * 0, (float) (4 * Math.cos(a)), 0, // + 10, 11, 12, 1 }) { + assertTrue(val == fb.get()); + } + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestTriangle.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestTriangle.java index b59bc37..fbba4c4 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestTriangle.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestTriangle.java @@ -1,166 +1,166 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestTriangle {
-
- @Test
- public void testGetSet() {
- final Triangle tri1 = new Triangle();
- assertEquals(Vector3.ZERO, tri1.getA());
- assertEquals(Vector3.ZERO, tri1.getB());
- assertEquals(Vector3.ZERO, tri1.getC());
- assertTrue(tri1.getIndex() == 0);
-
- tri1.setA(Vector3.NEG_ONE);
- tri1.setB(Vector3.UNIT_X);
- tri1.setC(Vector3.UNIT_Z);
- tri1.setIndex(1);
- assertEquals(Vector3.NEG_ONE, tri1.getA());
- assertEquals(Vector3.UNIT_X, tri1.getB());
- assertEquals(Vector3.UNIT_Z, tri1.getC());
- assertTrue(tri1.getIndex() == 1);
-
- final Triangle tri2 = new Triangle(tri1);
- assertEquals(Vector3.NEG_ONE, tri2.getA());
- assertEquals(Vector3.UNIT_X, tri2.getB());
- assertEquals(Vector3.UNIT_Z, tri2.getC());
- assertTrue(tri2.getIndex() == 1);
-
- final Triangle tri3 = new Triangle(Vector3.ONE, Vector3.UNIT_Y, Vector3.NEG_ONE);
- assertEquals(Vector3.ONE, tri3.getA());
- assertEquals(Vector3.UNIT_Y, tri3.getB());
- assertEquals(Vector3.NEG_ONE, tri3.getC());
- assertTrue(tri3.getIndex() == 0);
-
- final Triangle tri4 = new Triangle(Vector3.ONE, Vector3.UNIT_Y, Vector3.NEG_ONE, 42);
- assertEquals(Vector3.ONE, tri4.getA());
- assertEquals(Vector3.UNIT_Y, tri4.getB());
- assertEquals(Vector3.NEG_ONE, tri4.getC());
- assertTrue(tri4.getIndex() == 42);
-
- tri2.set(0, Vector3.UNIT_X);
- tri2.set(1, Vector3.UNIT_Y);
- tri2.set(2, Vector3.UNIT_Z);
-
- // catch a few expected exceptions
- try {
- tri2.get(3);
- fail("get(3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- tri2.get(-1);
- fail("get(-1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- tri2.set(-1, Vector3.ZERO);
- fail("set(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- tri2.set(3, Vector3.ZERO);
- fail("set(3, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
-
- // shouldn't have changed
- assertEquals(Vector3.UNIT_X, tri2.get(0));
- assertEquals(Vector3.UNIT_Y, tri2.get(1));
- assertEquals(Vector3.UNIT_Z, tri2.get(2));
- }
-
- @Test
- public void testEquals() {
- // couple of equals validity tests
- final Triangle tri1 = new Triangle();
- assertEquals(tri1, tri1);
- assertFalse(tri1.equals(null));
- assertFalse(tri1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Triangle tri2 = Triangle.fetchTempInstance();
- tri2.set(tri1);
- assertEquals(tri1, tri2);
- assertNotSame(tri1, tri2);
- Triangle.releaseTempInstance(tri2);
-
- // cover more of equals
- assertTrue(tri1.equals(new Triangle(Vector3.ZERO, Vector3.ZERO, Vector3.ZERO)));
- assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.ZERO, Vector3.UNIT_X)));
- assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.UNIT_X, Vector3.UNIT_X)));
- assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.UNIT_X, Vector3.ZERO)));
- assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.ZERO, Vector3.ZERO)));
- assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.ZERO, Vector3.UNIT_X)));
- assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.ZERO)));
- assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.UNIT_X)));
- }
-
- @Test
- public void testValid() {
- final Triangle vec1 = new Triangle();
- final Triangle vec2 = new Triangle(new Vector3(0, 0, Double.NaN), Vector3.ZERO, Vector3.ZERO);
- final Triangle vec3 = new Triangle(Vector3.ZERO, new Vector3(0, 0, Double.NaN), Vector3.ZERO);
- final Triangle vec4 = new Triangle(Vector3.ZERO, Vector3.ZERO, new Vector3(0, 0, Double.NaN));
-
- assertTrue(Triangle.isValid(vec1));
- assertFalse(Triangle.isValid(vec2));
- assertFalse(Triangle.isValid(vec3));
- assertFalse(Triangle.isValid(vec4));
-
- vec4.setC(Vector3.ZERO);
- assertTrue(Triangle.isValid(vec4));
-
- assertFalse(Triangle.isValid(null));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.NEG_ONE, 1);
- final Triangle tri2 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.NEG_ONE, 1);
- final Triangle tri3 = new Triangle(Vector3.ZERO, Vector3.UNIT_Z, Vector3.NEG_ONE, 2);
-
- assertTrue(tri1.hashCode() == tri2.hashCode());
- assertTrue(tri1.hashCode() != tri3.hashCode());
- }
-
- @Test
- public void testClone() {
- final Triangle tri1 = new Triangle();
- final Triangle tri2 = tri1.clone();
- assertEquals(tri1, tri2);
- assertNotSame(tri1, tri2);
- }
-
- @Test
- public void testCenter() {
- final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X, 0);
- assertEquals(new Vector3(1 / 3., 1 / 3., 0), tri1.getCenter()); // dirty
- assertEquals(new Vector3(1 / 3., 1 / 3., 0), tri1.getCenter()); // clean
- tri1.setA(Vector3.ONE);
- assertEquals(new Vector3(2 / 3., 2 / 3., 1 / 3.), tri1.getCenter()); // dirty, but with existing center
- }
-
- @Test
- public void testNormal() {
- final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X, 0);
- assertEquals(new Vector3(0, 0, -1), tri1.getNormal()); // dirty
- assertEquals(new Vector3(0, 0, -1), tri1.getNormal()); // clean
- tri1.setB(Vector3.UNIT_Z);
- assertEquals(new Vector3(0, 1, 0), tri1.getNormal()); // dirty, but with existing normal
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestTriangle { + + @Test + public void testGetSet() { + final Triangle tri1 = new Triangle(); + assertEquals(Vector3.ZERO, tri1.getA()); + assertEquals(Vector3.ZERO, tri1.getB()); + assertEquals(Vector3.ZERO, tri1.getC()); + assertTrue(tri1.getIndex() == 0); + + tri1.setA(Vector3.NEG_ONE); + tri1.setB(Vector3.UNIT_X); + tri1.setC(Vector3.UNIT_Z); + tri1.setIndex(1); + assertEquals(Vector3.NEG_ONE, tri1.getA()); + assertEquals(Vector3.UNIT_X, tri1.getB()); + assertEquals(Vector3.UNIT_Z, tri1.getC()); + assertTrue(tri1.getIndex() == 1); + + final Triangle tri2 = new Triangle(tri1); + assertEquals(Vector3.NEG_ONE, tri2.getA()); + assertEquals(Vector3.UNIT_X, tri2.getB()); + assertEquals(Vector3.UNIT_Z, tri2.getC()); + assertTrue(tri2.getIndex() == 1); + + final Triangle tri3 = new Triangle(Vector3.ONE, Vector3.UNIT_Y, Vector3.NEG_ONE); + assertEquals(Vector3.ONE, tri3.getA()); + assertEquals(Vector3.UNIT_Y, tri3.getB()); + assertEquals(Vector3.NEG_ONE, tri3.getC()); + assertTrue(tri3.getIndex() == 0); + + final Triangle tri4 = new Triangle(Vector3.ONE, Vector3.UNIT_Y, Vector3.NEG_ONE, 42); + assertEquals(Vector3.ONE, tri4.getA()); + assertEquals(Vector3.UNIT_Y, tri4.getB()); + assertEquals(Vector3.NEG_ONE, tri4.getC()); + assertTrue(tri4.getIndex() == 42); + + tri2.set(0, Vector3.UNIT_X); + tri2.set(1, Vector3.UNIT_Y); + tri2.set(2, Vector3.UNIT_Z); + + // catch a few expected exceptions + try { + tri2.get(3); + fail("get(3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + tri2.get(-1); + fail("get(-1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + tri2.set(-1, Vector3.ZERO); + fail("set(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + tri2.set(3, Vector3.ZERO); + fail("set(3, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + + // shouldn't have changed + assertEquals(Vector3.UNIT_X, tri2.get(0)); + assertEquals(Vector3.UNIT_Y, tri2.get(1)); + assertEquals(Vector3.UNIT_Z, tri2.get(2)); + } + + @Test + public void testEquals() { + // couple of equals validity tests + final Triangle tri1 = new Triangle(); + assertEquals(tri1, tri1); + assertFalse(tri1.equals(null)); + assertFalse(tri1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Triangle tri2 = Triangle.fetchTempInstance(); + tri2.set(tri1); + assertEquals(tri1, tri2); + assertNotSame(tri1, tri2); + Triangle.releaseTempInstance(tri2); + + // cover more of equals + assertTrue(tri1.equals(new Triangle(Vector3.ZERO, Vector3.ZERO, Vector3.ZERO))); + assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.ZERO, Vector3.UNIT_X))); + assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.UNIT_X, Vector3.UNIT_X))); + assertFalse(tri1.equals(new Triangle(Vector3.ZERO, Vector3.UNIT_X, Vector3.ZERO))); + assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.ZERO, Vector3.ZERO))); + assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.ZERO, Vector3.UNIT_X))); + assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.ZERO))); + assertFalse(tri1.equals(new Triangle(Vector3.UNIT_X, Vector3.UNIT_X, Vector3.UNIT_X))); + } + + @Test + public void testValid() { + final Triangle vec1 = new Triangle(); + final Triangle vec2 = new Triangle(new Vector3(0, 0, Double.NaN), Vector3.ZERO, Vector3.ZERO); + final Triangle vec3 = new Triangle(Vector3.ZERO, new Vector3(0, 0, Double.NaN), Vector3.ZERO); + final Triangle vec4 = new Triangle(Vector3.ZERO, Vector3.ZERO, new Vector3(0, 0, Double.NaN)); + + assertTrue(Triangle.isValid(vec1)); + assertFalse(Triangle.isValid(vec2)); + assertFalse(Triangle.isValid(vec3)); + assertFalse(Triangle.isValid(vec4)); + + vec4.setC(Vector3.ZERO); + assertTrue(Triangle.isValid(vec4)); + + assertFalse(Triangle.isValid(null)); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.NEG_ONE, 1); + final Triangle tri2 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.NEG_ONE, 1); + final Triangle tri3 = new Triangle(Vector3.ZERO, Vector3.UNIT_Z, Vector3.NEG_ONE, 2); + + assertTrue(tri1.hashCode() == tri2.hashCode()); + assertTrue(tri1.hashCode() != tri3.hashCode()); + } + + @Test + public void testClone() { + final Triangle tri1 = new Triangle(); + final Triangle tri2 = tri1.clone(); + assertEquals(tri1, tri2); + assertNotSame(tri1, tri2); + } + + @Test + public void testCenter() { + final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X, 0); + assertEquals(new Vector3(1 / 3., 1 / 3., 0), tri1.getCenter()); // dirty + assertEquals(new Vector3(1 / 3., 1 / 3., 0), tri1.getCenter()); // clean + tri1.setA(Vector3.ONE); + assertEquals(new Vector3(2 / 3., 2 / 3., 1 / 3.), tri1.getCenter()); // dirty, but with existing center + } + + @Test + public void testNormal() { + final Triangle tri1 = new Triangle(Vector3.ZERO, Vector3.UNIT_Y, Vector3.UNIT_X, 0); + assertEquals(new Vector3(0, 0, -1), tri1.getNormal()); // dirty + assertEquals(new Vector3(0, 0, -1), tri1.getNormal()); // clean + tri1.setB(Vector3.UNIT_Z); + assertEquals(new Vector3(0, 1, 0), tri1.getNormal()); // dirty, but with existing normal + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestValidatingTransform.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestValidatingTransform.java index 7dab55d..6821220 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestValidatingTransform.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestValidatingTransform.java @@ -1,151 +1,151 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestValidatingTransform {
-
- @Test
- public void testConstructor() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- assertEquals(Transform.IDENTITY, vt1);
-
- vt1.translate(0, 1, 2);
- vt1.setRotation(new Matrix3().fromAngleAxis(Math.PI, Vector3.UNIT_X));
-
- final ValidatingTransform vt2 = new ValidatingTransform(vt1);
- assertEquals(vt1, vt2);
- }
-
- @Test(expected = InvalidTransformException.class)
- public void failConstructor() {
- final Transform bad = new Transform();
- bad.translate(Double.NaN, 1, 2);
- new ValidatingTransform(Transform.IDENTITY); // good
- new ValidatingTransform(bad); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetRotationReadOnlyMatrix3() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- final Matrix3 rotation = new Matrix3();
- vt1.setRotation(rotation); // good
- rotation.setM00(Double.NaN);
- vt1.setRotation(rotation); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetRotationReadOnlyQuaternion() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- final Quaternion rotation = new Quaternion();
- vt1.setRotation(rotation); // good
- rotation.setX(Double.NaN);
- vt1.setRotation(rotation); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetTranslationReadOnlyVector3() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setTranslation(new Vector3(0, 0, 1)); // good
- vt1.setTranslation(new Vector3(0, 0, Double.NaN)); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetTranslationDoubleDoubleDouble() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setTranslation(0, 0, 1); // good
- vt1.setTranslation(0, 0, Double.NaN); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetScaleReadOnlyVector3() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setScale(new Vector3(1, 1, 1)); // good
- vt1.setScale(new Vector3(1, 1, Double.NaN)); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetScaleDoubleDoubleDouble() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setScale(0, 0, 1); // good
- vt1.setScale(0, 0, Double.NaN); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSetScaleDouble() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setScale(1); // good
- vt1.setScale(Double.NaN); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testSet() {
- final Transform bad = new Transform();
- bad.translate(Double.NaN, 1, 2);
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.set(Transform.IDENTITY); // good
- vt1.set(bad); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testTranslateDoubleDoubleDouble() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.translate(1, 2, 3); // good
- vt1.translate(0, 0, Double.NaN); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testTranslateReadOnlyVector3() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.translate(new Vector3(1, 2, 3)); // good
- vt1.translate(new Vector3(0, 0, Double.NaN)); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testMultiply() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.multiply(Transform.IDENTITY, null); // good
- final Transform bad = new Transform();
- bad.translate(Double.NaN, 1, 2);
- vt1.multiply(bad, null); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testInvert() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- vt1.setScale(2);
- vt1.invert(null); // good
- // a little chicanery to get around other checks.
- ((Vector3) vt1.getScale()).setX(0);
- vt1.invert(null); // bad
- }
-
- @Test(expected = InvalidTransformException.class)
- public void testFromHomogeneousMatrix() {
- final ValidatingTransform vt1 = new ValidatingTransform();
- final Matrix4 matrix = new Matrix4();
- vt1.fromHomogeneousMatrix(matrix); // good
- matrix.setM00(Double.NaN);
- vt1.fromHomogeneousMatrix(matrix); // bad
- }
-
- @Test
- public void testClone() {
- final ValidatingTransform trans1 = new ValidatingTransform();
- final ValidatingTransform trans2 = trans1.clone();
- assertEquals(trans1, trans2);
- assertNotSame(trans1, trans2);
- }
-
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestValidatingTransform { + + @Test + public void testConstructor() { + final ValidatingTransform vt1 = new ValidatingTransform(); + assertEquals(Transform.IDENTITY, vt1); + + vt1.translate(0, 1, 2); + vt1.setRotation(new Matrix3().fromAngleAxis(Math.PI, Vector3.UNIT_X)); + + final ValidatingTransform vt2 = new ValidatingTransform(vt1); + assertEquals(vt1, vt2); + } + + @Test(expected = InvalidTransformException.class) + public void failConstructor() { + final Transform bad = new Transform(); + bad.translate(Double.NaN, 1, 2); + new ValidatingTransform(Transform.IDENTITY); // good + new ValidatingTransform(bad); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetRotationReadOnlyMatrix3() { + final ValidatingTransform vt1 = new ValidatingTransform(); + final Matrix3 rotation = new Matrix3(); + vt1.setRotation(rotation); // good + rotation.setM00(Double.NaN); + vt1.setRotation(rotation); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetRotationReadOnlyQuaternion() { + final ValidatingTransform vt1 = new ValidatingTransform(); + final Quaternion rotation = new Quaternion(); + vt1.setRotation(rotation); // good + rotation.setX(Double.NaN); + vt1.setRotation(rotation); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetTranslationReadOnlyVector3() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setTranslation(new Vector3(0, 0, 1)); // good + vt1.setTranslation(new Vector3(0, 0, Double.NaN)); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetTranslationDoubleDoubleDouble() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setTranslation(0, 0, 1); // good + vt1.setTranslation(0, 0, Double.NaN); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetScaleReadOnlyVector3() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setScale(new Vector3(1, 1, 1)); // good + vt1.setScale(new Vector3(1, 1, Double.NaN)); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetScaleDoubleDoubleDouble() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setScale(0, 0, 1); // good + vt1.setScale(0, 0, Double.NaN); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSetScaleDouble() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setScale(1); // good + vt1.setScale(Double.NaN); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testSet() { + final Transform bad = new Transform(); + bad.translate(Double.NaN, 1, 2); + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.set(Transform.IDENTITY); // good + vt1.set(bad); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testTranslateDoubleDoubleDouble() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.translate(1, 2, 3); // good + vt1.translate(0, 0, Double.NaN); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testTranslateReadOnlyVector3() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.translate(new Vector3(1, 2, 3)); // good + vt1.translate(new Vector3(0, 0, Double.NaN)); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testMultiply() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.multiply(Transform.IDENTITY, null); // good + final Transform bad = new Transform(); + bad.translate(Double.NaN, 1, 2); + vt1.multiply(bad, null); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testInvert() { + final ValidatingTransform vt1 = new ValidatingTransform(); + vt1.setScale(2); + vt1.invert(null); // good + // a little chicanery to get around other checks. + ((Vector3) vt1.getScale()).setX(0); + vt1.invert(null); // bad + } + + @Test(expected = InvalidTransformException.class) + public void testFromHomogeneousMatrix() { + final ValidatingTransform vt1 = new ValidatingTransform(); + final Matrix4 matrix = new Matrix4(); + vt1.fromHomogeneousMatrix(matrix); // good + matrix.setM00(Double.NaN); + vt1.fromHomogeneousMatrix(matrix); // bad + } + + @Test + public void testClone() { + final ValidatingTransform trans1 = new ValidatingTransform(); + final ValidatingTransform trans2 = trans1.clone(); + assertEquals(trans1, trans2); + assertNotSame(trans1, trans2); + } + +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector2.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector2.java index 6ba3b7c..2df1de8 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector2.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector2.java @@ -1,376 +1,376 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestVector2 {
-
- @Test
- public void testAdd() {
- final Vector2 vec1 = new Vector2();
- final Vector2 vec2 = new Vector2(Vector2.ONE);
-
- vec1.addLocal(1, 2);
- assertEquals(new Vector2(1, 2), vec1);
- vec1.addLocal(-1, -2);
- assertEquals(Vector2.ZERO, vec1);
-
- vec1.zero();
- vec1.addLocal(vec2);
- assertEquals(Vector2.ONE, vec1);
-
- vec1.zero();
- final Vector2 vec3 = vec1.add(vec2, new Vector2());
- assertEquals(Vector2.ZERO, vec1);
- assertEquals(Vector2.ONE, vec3);
-
- final Vector2 vec4 = vec1.add(1, 0, null);
- assertEquals(Vector2.ZERO, vec1);
- assertEquals(Vector2.UNIT_X, vec4);
- }
-
- @Test
- public void testSubtract() {
- final Vector2 vec1 = new Vector2();
- final Vector2 vec2 = new Vector2(Vector2.ONE);
-
- vec1.subtractLocal(1, 2);
- assertEquals(new Vector2(-1, -2), vec1);
- vec1.subtractLocal(-1, -2);
- assertEquals(Vector2.ZERO, vec1);
-
- vec1.zero();
- vec1.subtractLocal(vec2);
- assertEquals(Vector2.NEG_ONE, vec1);
-
- vec1.zero();
- final Vector2 vec3 = vec1.subtract(vec2, new Vector2());
- assertEquals(Vector2.ZERO, vec1);
- assertEquals(Vector2.NEG_ONE, vec3);
-
- final Vector2 vec4 = vec1.subtract(1, 0, null);
- assertEquals(Vector2.ZERO, vec1);
- assertEquals(Vector2.NEG_UNIT_X, vec4);
- }
-
- @Test
- public void testGetSet() {
- final Vector2 vec1 = new Vector2();
- vec1.setX(0);
- assertTrue(vec1.getX() == 0.0);
- vec1.setX(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getX() == Double.POSITIVE_INFINITY);
- vec1.setX(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY);
-
- vec1.setY(0);
- assertTrue(vec1.getY() == 0.0);
- vec1.setY(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getY() == Double.POSITIVE_INFINITY);
- vec1.setY(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY);
-
- vec1.set(Math.PI, Math.PI);
- assertTrue(vec1.getXf() == (float) Math.PI);
- assertTrue(vec1.getYf() == (float) Math.PI);
-
- final Vector2 vec2 = new Vector2();
- vec2.set(vec1);
- assertEquals(vec1, vec2);
-
- vec1.setValue(0, 0);
- vec1.setValue(1, 0);
- assertEquals(Vector2.ZERO, vec1);
-
- // catch a few expected exceptions
- try {
- vec2.getValue(2);
- fail("getValue(2) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.getValue(-1);
- fail("getValue(-1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(-1, 0);
- fail("setValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(2, 0);
- fail("setValue(2, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered vec2
- assertEquals(new Vector2(Math.PI, Math.PI), vec2);
- }
-
- @Test
- public void testPolarAngle() {
- final Vector2 vec1 = new Vector2();
- assertTrue(0.0 == vec1.getPolarAngle());
-
- vec1.set(1.0, 0.0); // 0
- assertTrue(Math.abs(0 - vec1.getPolarAngle()) <= MathUtils.EPSILON);
-
- vec1.set(0.0, 1.0); // -HALF_PI
- assertTrue(Math.abs(-MathUtils.HALF_PI - vec1.getPolarAngle()) <= MathUtils.EPSILON);
-
- vec1.set(-1.0, 0.0); // -PI
- assertTrue(Math.abs(-MathUtils.PI - vec1.getPolarAngle()) <= MathUtils.EPSILON);
-
- vec1.set(0, -1.0); // HALF_PI
- assertTrue(Math.abs(MathUtils.HALF_PI - vec1.getPolarAngle()) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testToArray() {
- final Vector2 vec1 = new Vector2();
- vec1.set(Math.PI, Double.MAX_VALUE);
- final double[] array = vec1.toArray(null);
- final double[] array2 = vec1.toArray(new double[2]);
- assertNotNull(array);
- assertTrue(array.length == 2);
- assertTrue(array[0] == Math.PI);
- assertTrue(array[1] == Double.MAX_VALUE);
- assertNotNull(array2);
- assertTrue(array2.length == 2);
- assertTrue(array2[0] == Math.PI);
- assertTrue(array2[1] == Double.MAX_VALUE);
-
- try {
- vec1.toArray(new double[1]);
- fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException.");
- } catch (final ArrayIndexOutOfBoundsException e) {
- }
- }
-
- @Test
- public void testMultiply() {
- final Vector2 vec1 = new Vector2(1, -1);
- final Vector2 vec2 = vec1.multiply(2.0, null);
- final Vector2 vec2B = vec1.multiply(2.0, new Vector2());
- assertEquals(new Vector2(2.0, -2.0), vec2);
- assertEquals(new Vector2(2.0, -2.0), vec2B);
-
- vec2.multiplyLocal(0.5);
- assertEquals(new Vector2(1.0, -1.0), vec2);
-
- final Vector2 vec3 = vec1.multiply(vec2, null);
- final Vector2 vec3B = vec1.multiply(vec2, new Vector2());
- assertEquals(Vector2.ONE, vec3);
- assertEquals(Vector2.ONE, vec3B);
-
- final Vector2 vec4 = vec1.multiply(2, 3, null);
- final Vector2 vec4B = vec1.multiply(2, 3, new Vector2());
- assertEquals(new Vector2(2, -3), vec4);
- assertEquals(new Vector2(2, -3), vec4B);
-
- vec1.multiplyLocal(0.5, 0.5);
- assertEquals(new Vector2(0.5, -0.5), vec1);
-
- vec1.multiplyLocal(vec2);
- assertEquals(new Vector2(0.5, 0.5), vec1);
- }
-
- @Test
- public void testDivide() {
- final Vector2 vec1 = new Vector2(1, -1);
- final Vector2 vec2 = vec1.divide(2.0, null);
- final Vector2 vec2B = vec1.divide(2.0, new Vector2());
- assertEquals(new Vector2(0.5, -0.5), vec2);
- assertEquals(new Vector2(0.5, -0.5), vec2B);
-
- vec2.divideLocal(0.5);
- assertEquals(new Vector2(1.0, -1.0), vec2);
-
- final Vector2 vec3 = vec1.divide(vec2, null);
- final Vector2 vec3B = vec1.divide(vec2, new Vector2());
- assertEquals(Vector2.ONE, vec3);
- assertEquals(Vector2.ONE, vec3B);
-
- final Vector2 vec4 = vec1.divide(2, 3, null);
- final Vector2 vec4B = vec1.divide(2, 3, new Vector2());
- assertEquals(new Vector2(1 / 2., -1 / 3.), vec4);
- assertEquals(new Vector2(1 / 2., -1 / 3.), vec4B);
-
- vec1.divideLocal(0.5, 0.5);
- assertEquals(new Vector2(2, -2), vec1);
-
- vec1.divideLocal(vec2);
- assertEquals(new Vector2(2, 2), vec1);
- }
-
- @Test
- public void testScaleAdd() {
- final Vector2 vec1 = new Vector2(1, 1);
- final Vector2 vec2 = vec1.scaleAdd(2.0, new Vector2(1, 2), null);
- final Vector2 vec2B = vec1.scaleAdd(2.0, new Vector2(1, 2), new Vector2());
- assertEquals(new Vector2(3.0, 4.0), vec2);
- assertEquals(new Vector2(3.0, 4.0), vec2B);
-
- vec1.scaleAddLocal(2.0, new Vector2(1, 2));
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNegate() {
- final Vector2 vec1 = new Vector2(2, 1);
- final Vector2 vec2 = vec1.negate(null);
- assertEquals(new Vector2(-2, -1), vec2);
-
- vec1.negateLocal();
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNormalize() {
- final Vector2 vec1 = new Vector2(2, 1);
- assertTrue(vec1.length() == Math.sqrt(5));
-
- final Vector2 vec2 = vec1.normalize(null);
- final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1);
- assertEquals(new Vector2(2 * invLength, 1 * invLength), vec2);
-
- vec1.normalizeLocal();
- assertEquals(new Vector2(2 * invLength, 1 * invLength), vec1);
-
- vec1.zero();
- vec1.normalize(vec2);
- assertEquals(vec1, vec2);
-
- // ensure no exception thrown
- vec1.normalizeLocal();
- vec1.normalize(null);
- }
-
- @Test
- public void testDistance() {
- final Vector2 vec1 = new Vector2(0, 0);
- assertTrue(3.0 == vec1.distance(0, 3));
- assertTrue(4.0 == vec1.distance(4, 0));
-
- final Vector2 vec2 = new Vector2(1, 1);
- assertTrue(Math.sqrt(2) == vec1.distance(vec2));
- }
-
- @Test
- public void testLerp() {
- final Vector2 vec1 = new Vector2(8, 3);
- final Vector2 vec2 = new Vector2(2, 1);
- assertEquals(new Vector2(5, 2), vec1.lerp(vec2, 0.5, null));
- assertEquals(new Vector2(5, 2), vec1.lerp(vec2, 0.5, new Vector2()));
- assertEquals(new Vector2(5, 2), Vector2.lerp(vec1, vec2, 0.5, null));
- assertEquals(new Vector2(5, 2), Vector2.lerp(vec1, vec2, 0.5, new Vector2()));
-
- vec1.set(14, 5);
- vec1.lerpLocal(vec2, 0.25);
- assertEquals(new Vector2(11, 4), vec1);
-
- vec1.set(15, 7);
- final Vector2 vec3 = new Vector2(-1, -1);
- vec3.lerpLocal(vec1, vec2, 0.5);
- assertEquals(new Vector2(8.5, 4.0), vec3);
- }
-
- @Test
- public void testRotate() {
- final Vector2 vec1 = new Vector2(1, 0);
- final Vector2 vec2 = vec1.rotateAroundOrigin(MathUtils.HALF_PI, true, null);
- final Vector2 vec2B = vec1.rotateAroundOrigin(MathUtils.HALF_PI, false, new Vector2());
- assertEquals(new Vector2(0, -1), vec2);
- assertEquals(new Vector2(0, 1), vec2B);
- vec2.rotateAroundOriginLocal(MathUtils.HALF_PI, false);
- assertEquals(new Vector2(1, 0), vec2);
- vec2.rotateAroundOriginLocal(MathUtils.PI, true);
- assertTrue(Math.abs(vec2.getX() - -1) <= MathUtils.EPSILON);
- assertTrue(Math.abs(vec2.getY() - 0) <= MathUtils.EPSILON);
- }
-
- @Test
- public void testAngle() {
- final Vector2 vec1 = new Vector2(1, 0);
- assertTrue(MathUtils.HALF_PI == vec1.angleBetween(new Vector2(0, 1)));
- assertTrue(-MathUtils.HALF_PI == vec1.angleBetween(new Vector2(0, -1)));
-
- assertTrue(MathUtils.HALF_PI == vec1.smallestAngleBetween(new Vector2(0, -1)));
- }
-
- @Test
- public void testDot() {
- final Vector2 vec1 = new Vector2(7, 2);
- assertTrue(23.0 == vec1.dot(3, 1));
-
- assertTrue(-5.0 == vec1.dot(new Vector2(-1, 1)));
- }
-
- @Test
- public void testClone() {
- final Vector2 vec1 = new Vector2(0, 0);
- final Vector2 vec2 = vec1.clone();
- assertEquals(vec1, vec2);
- assertNotSame(vec1, vec2);
- }
-
- @Test
- public void testValid() {
- final Vector2 vec1 = new Vector2(0, 0);
- final Vector2 vec2 = new Vector2(Double.POSITIVE_INFINITY, 0);
- final Vector2 vec3 = new Vector2(0, Double.NEGATIVE_INFINITY);
- final Vector2 vec4 = new Vector2(Double.NaN, 0);
- final Vector2 vec5 = new Vector2(0, Double.NaN);
-
- assertTrue(Vector2.isValid(vec1));
- assertFalse(Vector2.isValid(vec2));
- assertFalse(Vector2.isValid(vec3));
- assertFalse(Vector2.isValid(vec4));
- assertFalse(Vector2.isValid(vec5));
-
- vec5.zero();
- assertTrue(Vector2.isValid(vec5));
-
- assertFalse(Vector2.isValid(null));
-
- // couple of equals validity tests
- assertEquals(vec1, vec1);
- assertFalse(vec1.equals(null));
- assertFalse(vec1.equals(new Vector3()));
-
- // throw in a couple pool accesses for coverage
- final Vector2 vec6 = Vector2.fetchTempInstance();
- vec6.set(vec1);
- assertEquals(vec1, vec6);
- assertNotSame(vec1, vec6);
- Vector2.releaseTempInstance(vec6);
-
- // cover more of equals
- vec1.set(0, 1);
- assertFalse(vec1.equals(new Vector2(0, 2)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Vector2 vec1 = new Vector2(1, 2);
- final Vector2 vec2 = new Vector2(1, 2);
- final Vector2 vec3 = new Vector2(2, 2);
-
- assertTrue(vec1.hashCode() == vec2.hashCode());
- assertTrue(vec1.hashCode() != vec3.hashCode());
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestVector2 { + + @Test + public void testAdd() { + final Vector2 vec1 = new Vector2(); + final Vector2 vec2 = new Vector2(Vector2.ONE); + + vec1.addLocal(1, 2); + assertEquals(new Vector2(1, 2), vec1); + vec1.addLocal(-1, -2); + assertEquals(Vector2.ZERO, vec1); + + vec1.zero(); + vec1.addLocal(vec2); + assertEquals(Vector2.ONE, vec1); + + vec1.zero(); + final Vector2 vec3 = vec1.add(vec2, new Vector2()); + assertEquals(Vector2.ZERO, vec1); + assertEquals(Vector2.ONE, vec3); + + final Vector2 vec4 = vec1.add(1, 0, null); + assertEquals(Vector2.ZERO, vec1); + assertEquals(Vector2.UNIT_X, vec4); + } + + @Test + public void testSubtract() { + final Vector2 vec1 = new Vector2(); + final Vector2 vec2 = new Vector2(Vector2.ONE); + + vec1.subtractLocal(1, 2); + assertEquals(new Vector2(-1, -2), vec1); + vec1.subtractLocal(-1, -2); + assertEquals(Vector2.ZERO, vec1); + + vec1.zero(); + vec1.subtractLocal(vec2); + assertEquals(Vector2.NEG_ONE, vec1); + + vec1.zero(); + final Vector2 vec3 = vec1.subtract(vec2, new Vector2()); + assertEquals(Vector2.ZERO, vec1); + assertEquals(Vector2.NEG_ONE, vec3); + + final Vector2 vec4 = vec1.subtract(1, 0, null); + assertEquals(Vector2.ZERO, vec1); + assertEquals(Vector2.NEG_UNIT_X, vec4); + } + + @Test + public void testGetSet() { + final Vector2 vec1 = new Vector2(); + vec1.setX(0); + assertTrue(vec1.getX() == 0.0); + vec1.setX(Double.POSITIVE_INFINITY); + assertTrue(vec1.getX() == Double.POSITIVE_INFINITY); + vec1.setX(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY); + + vec1.setY(0); + assertTrue(vec1.getY() == 0.0); + vec1.setY(Double.POSITIVE_INFINITY); + assertTrue(vec1.getY() == Double.POSITIVE_INFINITY); + vec1.setY(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY); + + vec1.set(Math.PI, Math.PI); + assertTrue(vec1.getXf() == (float) Math.PI); + assertTrue(vec1.getYf() == (float) Math.PI); + + final Vector2 vec2 = new Vector2(); + vec2.set(vec1); + assertEquals(vec1, vec2); + + vec1.setValue(0, 0); + vec1.setValue(1, 0); + assertEquals(Vector2.ZERO, vec1); + + // catch a few expected exceptions + try { + vec2.getValue(2); + fail("getValue(2) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.getValue(-1); + fail("getValue(-1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(-1, 0); + fail("setValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(2, 0); + fail("setValue(2, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered vec2 + assertEquals(new Vector2(Math.PI, Math.PI), vec2); + } + + @Test + public void testPolarAngle() { + final Vector2 vec1 = new Vector2(); + assertTrue(0.0 == vec1.getPolarAngle()); + + vec1.set(1.0, 0.0); // 0 + assertTrue(Math.abs(0 - vec1.getPolarAngle()) <= MathUtils.EPSILON); + + vec1.set(0.0, 1.0); // -HALF_PI + assertTrue(Math.abs(-MathUtils.HALF_PI - vec1.getPolarAngle()) <= MathUtils.EPSILON); + + vec1.set(-1.0, 0.0); // -PI + assertTrue(Math.abs(-MathUtils.PI - vec1.getPolarAngle()) <= MathUtils.EPSILON); + + vec1.set(0, -1.0); // HALF_PI + assertTrue(Math.abs(MathUtils.HALF_PI - vec1.getPolarAngle()) <= MathUtils.EPSILON); + } + + @Test + public void testToArray() { + final Vector2 vec1 = new Vector2(); + vec1.set(Math.PI, Double.MAX_VALUE); + final double[] array = vec1.toArray(null); + final double[] array2 = vec1.toArray(new double[2]); + assertNotNull(array); + assertTrue(array.length == 2); + assertTrue(array[0] == Math.PI); + assertTrue(array[1] == Double.MAX_VALUE); + assertNotNull(array2); + assertTrue(array2.length == 2); + assertTrue(array2[0] == Math.PI); + assertTrue(array2[1] == Double.MAX_VALUE); + + try { + vec1.toArray(new double[1]); + fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException."); + } catch (final ArrayIndexOutOfBoundsException e) { + } + } + + @Test + public void testMultiply() { + final Vector2 vec1 = new Vector2(1, -1); + final Vector2 vec2 = vec1.multiply(2.0, null); + final Vector2 vec2B = vec1.multiply(2.0, new Vector2()); + assertEquals(new Vector2(2.0, -2.0), vec2); + assertEquals(new Vector2(2.0, -2.0), vec2B); + + vec2.multiplyLocal(0.5); + assertEquals(new Vector2(1.0, -1.0), vec2); + + final Vector2 vec3 = vec1.multiply(vec2, null); + final Vector2 vec3B = vec1.multiply(vec2, new Vector2()); + assertEquals(Vector2.ONE, vec3); + assertEquals(Vector2.ONE, vec3B); + + final Vector2 vec4 = vec1.multiply(2, 3, null); + final Vector2 vec4B = vec1.multiply(2, 3, new Vector2()); + assertEquals(new Vector2(2, -3), vec4); + assertEquals(new Vector2(2, -3), vec4B); + + vec1.multiplyLocal(0.5, 0.5); + assertEquals(new Vector2(0.5, -0.5), vec1); + + vec1.multiplyLocal(vec2); + assertEquals(new Vector2(0.5, 0.5), vec1); + } + + @Test + public void testDivide() { + final Vector2 vec1 = new Vector2(1, -1); + final Vector2 vec2 = vec1.divide(2.0, null); + final Vector2 vec2B = vec1.divide(2.0, new Vector2()); + assertEquals(new Vector2(0.5, -0.5), vec2); + assertEquals(new Vector2(0.5, -0.5), vec2B); + + vec2.divideLocal(0.5); + assertEquals(new Vector2(1.0, -1.0), vec2); + + final Vector2 vec3 = vec1.divide(vec2, null); + final Vector2 vec3B = vec1.divide(vec2, new Vector2()); + assertEquals(Vector2.ONE, vec3); + assertEquals(Vector2.ONE, vec3B); + + final Vector2 vec4 = vec1.divide(2, 3, null); + final Vector2 vec4B = vec1.divide(2, 3, new Vector2()); + assertEquals(new Vector2(1 / 2., -1 / 3.), vec4); + assertEquals(new Vector2(1 / 2., -1 / 3.), vec4B); + + vec1.divideLocal(0.5, 0.5); + assertEquals(new Vector2(2, -2), vec1); + + vec1.divideLocal(vec2); + assertEquals(new Vector2(2, 2), vec1); + } + + @Test + public void testScaleAdd() { + final Vector2 vec1 = new Vector2(1, 1); + final Vector2 vec2 = vec1.scaleAdd(2.0, new Vector2(1, 2), null); + final Vector2 vec2B = vec1.scaleAdd(2.0, new Vector2(1, 2), new Vector2()); + assertEquals(new Vector2(3.0, 4.0), vec2); + assertEquals(new Vector2(3.0, 4.0), vec2B); + + vec1.scaleAddLocal(2.0, new Vector2(1, 2)); + assertEquals(vec2, vec1); + } + + @Test + public void testNegate() { + final Vector2 vec1 = new Vector2(2, 1); + final Vector2 vec2 = vec1.negate(null); + assertEquals(new Vector2(-2, -1), vec2); + + vec1.negateLocal(); + assertEquals(vec2, vec1); + } + + @Test + public void testNormalize() { + final Vector2 vec1 = new Vector2(2, 1); + assertTrue(vec1.length() == Math.sqrt(5)); + + final Vector2 vec2 = vec1.normalize(null); + final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1); + assertEquals(new Vector2(2 * invLength, 1 * invLength), vec2); + + vec1.normalizeLocal(); + assertEquals(new Vector2(2 * invLength, 1 * invLength), vec1); + + vec1.zero(); + vec1.normalize(vec2); + assertEquals(vec1, vec2); + + // ensure no exception thrown + vec1.normalizeLocal(); + vec1.normalize(null); + } + + @Test + public void testDistance() { + final Vector2 vec1 = new Vector2(0, 0); + assertTrue(3.0 == vec1.distance(0, 3)); + assertTrue(4.0 == vec1.distance(4, 0)); + + final Vector2 vec2 = new Vector2(1, 1); + assertTrue(Math.sqrt(2) == vec1.distance(vec2)); + } + + @Test + public void testLerp() { + final Vector2 vec1 = new Vector2(8, 3); + final Vector2 vec2 = new Vector2(2, 1); + assertEquals(new Vector2(5, 2), vec1.lerp(vec2, 0.5, null)); + assertEquals(new Vector2(5, 2), vec1.lerp(vec2, 0.5, new Vector2())); + assertEquals(new Vector2(5, 2), Vector2.lerp(vec1, vec2, 0.5, null)); + assertEquals(new Vector2(5, 2), Vector2.lerp(vec1, vec2, 0.5, new Vector2())); + + vec1.set(14, 5); + vec1.lerpLocal(vec2, 0.25); + assertEquals(new Vector2(11, 4), vec1); + + vec1.set(15, 7); + final Vector2 vec3 = new Vector2(-1, -1); + vec3.lerpLocal(vec1, vec2, 0.5); + assertEquals(new Vector2(8.5, 4.0), vec3); + } + + @Test + public void testRotate() { + final Vector2 vec1 = new Vector2(1, 0); + final Vector2 vec2 = vec1.rotateAroundOrigin(MathUtils.HALF_PI, true, null); + final Vector2 vec2B = vec1.rotateAroundOrigin(MathUtils.HALF_PI, false, new Vector2()); + assertEquals(new Vector2(0, -1), vec2); + assertEquals(new Vector2(0, 1), vec2B); + vec2.rotateAroundOriginLocal(MathUtils.HALF_PI, false); + assertEquals(new Vector2(1, 0), vec2); + vec2.rotateAroundOriginLocal(MathUtils.PI, true); + assertTrue(Math.abs(vec2.getX() - -1) <= MathUtils.EPSILON); + assertTrue(Math.abs(vec2.getY() - 0) <= MathUtils.EPSILON); + } + + @Test + public void testAngle() { + final Vector2 vec1 = new Vector2(1, 0); + assertTrue(MathUtils.HALF_PI == vec1.angleBetween(new Vector2(0, 1))); + assertTrue(-MathUtils.HALF_PI == vec1.angleBetween(new Vector2(0, -1))); + + assertTrue(MathUtils.HALF_PI == vec1.smallestAngleBetween(new Vector2(0, -1))); + } + + @Test + public void testDot() { + final Vector2 vec1 = new Vector2(7, 2); + assertTrue(23.0 == vec1.dot(3, 1)); + + assertTrue(-5.0 == vec1.dot(new Vector2(-1, 1))); + } + + @Test + public void testClone() { + final Vector2 vec1 = new Vector2(0, 0); + final Vector2 vec2 = vec1.clone(); + assertEquals(vec1, vec2); + assertNotSame(vec1, vec2); + } + + @Test + public void testValid() { + final Vector2 vec1 = new Vector2(0, 0); + final Vector2 vec2 = new Vector2(Double.POSITIVE_INFINITY, 0); + final Vector2 vec3 = new Vector2(0, Double.NEGATIVE_INFINITY); + final Vector2 vec4 = new Vector2(Double.NaN, 0); + final Vector2 vec5 = new Vector2(0, Double.NaN); + + assertTrue(Vector2.isValid(vec1)); + assertFalse(Vector2.isValid(vec2)); + assertFalse(Vector2.isValid(vec3)); + assertFalse(Vector2.isValid(vec4)); + assertFalse(Vector2.isValid(vec5)); + + vec5.zero(); + assertTrue(Vector2.isValid(vec5)); + + assertFalse(Vector2.isValid(null)); + + // couple of equals validity tests + assertEquals(vec1, vec1); + assertFalse(vec1.equals(null)); + assertFalse(vec1.equals(new Vector3())); + + // throw in a couple pool accesses for coverage + final Vector2 vec6 = Vector2.fetchTempInstance(); + vec6.set(vec1); + assertEquals(vec1, vec6); + assertNotSame(vec1, vec6); + Vector2.releaseTempInstance(vec6); + + // cover more of equals + vec1.set(0, 1); + assertFalse(vec1.equals(new Vector2(0, 2))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Vector2 vec1 = new Vector2(1, 2); + final Vector2 vec2 = new Vector2(1, 2); + final Vector2 vec3 = new Vector2(2, 2); + + assertTrue(vec1.hashCode() == vec2.hashCode()); + assertTrue(vec1.hashCode() != vec3.hashCode()); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector3.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector3.java index 8bf4bfa..9146fc6 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector3.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector3.java @@ -1,405 +1,405 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestVector3 {
-
- @Test
- public void testAdd() {
- final Vector3 vec1 = new Vector3();
- final Vector3 vec2 = new Vector3(Vector3.ONE);
-
- vec1.addLocal(1, 2, 3);
- assertEquals(new Vector3(1, 2, 3), vec1);
- vec1.addLocal(-1, -2, -3);
- assertEquals(Vector3.ZERO, vec1);
-
- vec1.zero();
- vec1.addLocal(vec2);
- assertEquals(Vector3.ONE, vec1);
-
- vec1.zero();
- final Vector3 vec3 = vec1.add(vec2, new Vector3());
- assertEquals(Vector3.ZERO, vec1);
- assertEquals(Vector3.ONE, vec3);
-
- final Vector3 vec4 = vec1.add(1, 0, 0, null);
- assertEquals(Vector3.ZERO, vec1);
- assertEquals(Vector3.UNIT_X, vec4);
- }
-
- @Test
- public void testSubtract() {
- final Vector3 vec1 = new Vector3();
- final Vector3 vec2 = new Vector3(Vector3.ONE);
-
- vec1.subtractLocal(1, 2, 3);
- assertEquals(new Vector3(-1, -2, -3), vec1);
- vec1.subtractLocal(-1, -2, -3);
- assertEquals(Vector3.ZERO, vec1);
-
- vec1.zero();
- vec1.subtractLocal(vec2);
- assertEquals(Vector3.NEG_ONE, vec1);
-
- vec1.zero();
- final Vector3 vec3 = vec1.subtract(vec2, new Vector3());
- assertEquals(Vector3.ZERO, vec1);
- assertEquals(Vector3.NEG_ONE, vec3);
-
- final Vector3 vec4 = vec1.subtract(1, 0, 0, null);
- assertEquals(Vector3.ZERO, vec1);
- assertEquals(Vector3.NEG_UNIT_X, vec4);
- }
-
- @Test
- public void testGetSet() {
- final Vector3 vec1 = new Vector3();
- vec1.setX(0);
- assertTrue(vec1.getX() == 0.0);
- vec1.setX(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getX() == Double.POSITIVE_INFINITY);
- vec1.setX(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY);
-
- vec1.setY(0);
- assertTrue(vec1.getY() == 0.0);
- vec1.setY(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getY() == Double.POSITIVE_INFINITY);
- vec1.setY(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY);
-
- vec1.setZ(0);
- assertTrue(vec1.getZ() == 0.0);
- vec1.setZ(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getZ() == Double.POSITIVE_INFINITY);
- vec1.setZ(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getZ() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(2) == Double.NEGATIVE_INFINITY);
-
- vec1.set(Math.PI, Math.PI, Math.PI);
- assertTrue(vec1.getXf() == (float) Math.PI);
- assertTrue(vec1.getYf() == (float) Math.PI);
- assertTrue(vec1.getZf() == (float) Math.PI);
-
- final Vector3 vec2 = new Vector3();
- vec2.set(vec1);
- assertEquals(vec1, vec2);
-
- vec1.setValue(0, 0);
- vec1.setValue(1, 0);
- vec1.setValue(2, 0);
- assertEquals(Vector3.ZERO, vec1);
-
- // catch a few expected exceptions
- try {
- vec2.getValue(3);
- fail("getValue(3) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.getValue(-1);
- fail("getValue(-1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(-1, 0);
- fail("setValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(3, 0);
- fail("setValue(3, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered vec2
- assertEquals(new Vector3(Math.PI, Math.PI, Math.PI), vec2);
- }
-
- @Test
- public void testToArray() {
- final Vector3 vec1 = new Vector3();
- vec1.set(Math.PI, Double.MAX_VALUE, 42);
- final double[] array = vec1.toArray(null);
- final double[] array2 = vec1.toArray(new double[3]);
- assertNotNull(array);
- assertTrue(array.length == 3);
- assertTrue(array[0] == Math.PI);
- assertTrue(array[1] == Double.MAX_VALUE);
- assertTrue(array[2] == 42);
- assertNotNull(array2);
- assertTrue(array2.length == 3);
- assertTrue(array2[0] == Math.PI);
- assertTrue(array2[1] == Double.MAX_VALUE);
- assertTrue(array2[2] == 42);
-
- try {
- vec1.toArray(new double[1]);
- fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException.");
- } catch (final ArrayIndexOutOfBoundsException e) {
- }
-
- final float[] farray = vec1.toFloatArray(null);
- final float[] farray2 = vec1.toFloatArray(new float[3]);
- assertNotNull(farray);
- assertTrue(farray.length == 3);
- assertTrue(farray[0] == (float) Math.PI);
- assertTrue(farray[1] == (float) Double.MAX_VALUE);
- assertTrue(farray[2] == 42f);
- assertNotNull(farray2);
- assertTrue(farray2.length == 3);
- assertTrue(farray2[0] == (float) Math.PI);
- assertTrue(farray2[1] == (float) Double.MAX_VALUE);
- assertTrue(farray2[2] == 42f);
-
- try {
- vec1.toFloatArray(new float[1]);
- fail("toFloatArray(d[1]) should have thrown ArrayIndexOutOfBoundsException.");
- } catch (final ArrayIndexOutOfBoundsException e) {
- }
- }
-
- @Test
- public void testMultiply() {
- final Vector3 vec1 = new Vector3(1, -1, 2);
- final Vector3 vec2 = vec1.multiply(2.0, null);
- final Vector3 vec2B = vec1.multiply(2.0, new Vector3());
- assertEquals(new Vector3(2.0, -2.0, 4.0), vec2);
- assertEquals(new Vector3(2.0, -2.0, 4.0), vec2B);
-
- vec2.multiplyLocal(0.5);
- assertEquals(new Vector3(1.0, -1.0, 2.0), vec2);
-
- final Vector3 vec3 = vec1.multiply(vec2, null);
- final Vector3 vec3B = vec1.multiply(vec2, new Vector3());
- assertEquals(new Vector3(1, 1, 4), vec3);
- assertEquals(new Vector3(1, 1, 4), vec3B);
-
- final Vector3 vec4 = vec1.multiply(2, 3, 2, null);
- final Vector3 vec4B = vec1.multiply(2, 3, 2, new Vector3());
- assertEquals(new Vector3(2, -3, 4), vec4);
- assertEquals(new Vector3(2, -3, 4), vec4B);
-
- vec1.multiplyLocal(0.5, 0.5, 0.5);
- assertEquals(new Vector3(0.5, -0.5, 1.0), vec1);
-
- vec1.multiplyLocal(vec2);
- assertEquals(new Vector3(0.5, 0.5, 2.0), vec1);
- }
-
- @Test
- public void testDivide() {
- final Vector3 vec1 = new Vector3(1, -1, 2);
- final Vector3 vec2 = vec1.divide(2.0, null);
- final Vector3 vec2B = vec1.divide(2.0, new Vector3());
- assertEquals(new Vector3(0.5, -0.5, 1.0), vec2);
- assertEquals(new Vector3(0.5, -0.5, 1.0), vec2B);
-
- vec2.divideLocal(0.5);
- assertEquals(new Vector3(1.0, -1.0, 2.0), vec2);
-
- final Vector3 vec3 = vec1.divide(vec2, null);
- final Vector3 vec3B = vec1.divide(vec2, new Vector3());
- assertEquals(Vector3.ONE, vec3);
- assertEquals(Vector3.ONE, vec3B);
-
- final Vector3 vec4 = vec1.divide(2, 3, 4, null);
- final Vector3 vec4B = vec1.divide(2, 3, 4, new Vector3());
- assertEquals(new Vector3(0.5, -1 / 3., 0.5), vec4);
- assertEquals(new Vector3(0.5, -1 / 3., 0.5), vec4B);
-
- vec1.divideLocal(0.5, 0.5, 0.5);
- assertEquals(new Vector3(2, -2, 4), vec1);
-
- vec1.divideLocal(vec2);
- assertEquals(new Vector3(2, 2, 2), vec1);
- }
-
- @Test
- public void testScaleAdd() {
- final Vector3 vec1 = new Vector3(1, 1, 1);
- final Vector3 vec2 = vec1.scaleAdd(2.0, new Vector3(1, 2, 3), null);
- final Vector3 vec2B = vec1.scaleAdd(2.0, new Vector3(1, 2, 3), new Vector3());
- assertEquals(new Vector3(3.0, 4.0, 5.0), vec2);
- assertEquals(new Vector3(3.0, 4.0, 5.0), vec2B);
-
- vec1.scaleAddLocal(2.0, new Vector3(1, 2, 3));
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNegate() {
- final Vector3 vec1 = new Vector3(3, 2, -1);
- final Vector3 vec2 = vec1.negate(null);
- assertEquals(new Vector3(-3, -2, 1), vec2);
-
- vec1.negateLocal();
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNormalize() {
- final Vector3 vec1 = new Vector3(2, 1, 3);
- assertTrue(vec1.length() == Math.sqrt(14));
-
- final Vector3 vec2 = vec1.normalize(null);
- final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1 + 3 * 3);
- assertEquals(new Vector3(2 * invLength, 1 * invLength, 3 * invLength), vec2);
-
- vec1.normalizeLocal();
- assertEquals(new Vector3(2 * invLength, 1 * invLength, 3 * invLength), vec1);
-
- vec1.zero();
- vec1.normalize(vec2);
- assertEquals(vec1, vec2);
-
- // ensure no exception thrown
- vec1.normalizeLocal();
- vec1.normalize(null);
- }
-
- @Test
- public void testDistance() {
- final Vector3 vec1 = new Vector3(0, 0, 0);
- assertTrue(4.0 == vec1.distance(4, 0, 0));
- assertTrue(3.0 == vec1.distance(0, 3, 0));
- assertTrue(2.0 == vec1.distance(0, 0, 2));
-
- final Vector3 vec2 = new Vector3(1, 1, 1);
- assertTrue(Math.sqrt(3) == vec1.distance(vec2));
- }
-
- @Test
- public void testLerp() {
- final Vector3 vec1 = new Vector3(8, 3, -2);
- final Vector3 vec2 = new Vector3(2, 1, 0);
- assertEquals(new Vector3(5, 2, -1), vec1.lerp(vec2, 0.5, null));
- assertEquals(new Vector3(5, 2, -1), vec1.lerp(vec2, 0.5, new Vector3()));
- assertEquals(new Vector3(5, 2, -1), Vector3.lerp(vec1, vec2, 0.5, null));
- assertEquals(new Vector3(5, 2, -1), Vector3.lerp(vec1, vec2, 0.5, new Vector3()));
-
- vec1.set(14, 5, 4);
- vec1.lerpLocal(vec2, 0.25);
- assertEquals(new Vector3(11, 4, 3), vec1);
-
- vec1.set(15, 7, 6);
- final Vector3 vec3 = new Vector3(-1, -1, -1);
- vec3.lerpLocal(vec1, vec2, 0.5);
- assertEquals(new Vector3(8.5, 4.0, 3.0), vec3);
-
- // coverage
- assertEquals(vec1.lerp(vec1, .25, null), vec1);
- assertEquals(vec2.lerpLocal(vec2, .25), vec2);
- assertEquals(vec2.lerpLocal(vec2, vec2, .25), vec2);
- assertEquals(Vector3.lerp(vec1, vec1, .25, null), vec1);
- }
-
- @Test
- public void testCross() {
- final Vector3 vec1 = new Vector3(1, 0, 0);
- final Vector3 vec2 = new Vector3(0, 1, 0);
- assertEquals(Vector3.UNIT_Z, vec1.cross(vec2, null));
- assertEquals(Vector3.UNIT_Z, vec1.cross(vec2, new Vector3()));
-
- assertEquals(Vector3.UNIT_Z, vec1.cross(0, 1, 0, null));
- assertEquals(Vector3.UNIT_Z, vec1.cross(0, 1, 0, new Vector3()));
-
- vec1.crossLocal(vec2);
- assertEquals(Vector3.UNIT_Z, vec1);
- vec2.crossLocal(1, 0, 0);
- assertEquals(Vector3.NEG_UNIT_Z, vec2);
- }
-
- @Test
- public void testAngle() {
- final Vector3 vec1 = new Vector3(1, 0, 0);
-
- assertTrue(MathUtils.HALF_PI == vec1.smallestAngleBetween(new Vector3(0, -1, 0)));
- }
-
- @Test
- public void testDot() {
- final Vector3 vec1 = new Vector3(7, 2, 5);
- assertTrue(33.0 == vec1.dot(3, 1, 2));
-
- assertTrue(-10.0 == vec1.dot(new Vector3(-1, 1, -1)));
- }
-
- @Test
- public void testClone() {
- final Vector3 vec1 = new Vector3(0, 0, 0);
- final Vector3 vec2 = vec1.clone();
- assertEquals(vec1, vec2);
- assertNotSame(vec1, vec2);
- }
-
- @Test
- public void testValid() {
- final Vector3 vec1 = new Vector3(0, 0, 0);
- final Vector3 vec2A = new Vector3(Double.POSITIVE_INFINITY, 0, 0);
- final Vector3 vec2B = new Vector3(0, Double.NEGATIVE_INFINITY, 0);
- final Vector3 vec2C = new Vector3(0, 0, Double.POSITIVE_INFINITY);
- final Vector3 vec3A = new Vector3(Double.NaN, 0, 0);
- final Vector3 vec3B = new Vector3(0, Double.NaN, 0);
- final Vector3 vec3C = new Vector3(0, 0, Double.NaN);
-
- assertTrue(Vector3.isValid(vec1));
- assertFalse(Vector3.isValid(vec2A));
- assertFalse(Vector3.isValid(vec2B));
- assertFalse(Vector3.isValid(vec2C));
- assertFalse(Vector3.isValid(vec3A));
- assertFalse(Vector3.isValid(vec3B));
- assertFalse(Vector3.isValid(vec3C));
-
- assertFalse(Vector3.isInfinite(vec1));
- assertTrue(Vector3.isInfinite(vec2A));
-
- vec3C.zero();
- assertTrue(Vector3.isValid(vec3C));
-
- assertFalse(Vector3.isValid(null));
- assertFalse(Vector3.isInfinite(null));
-
- // couple of equals validity tests
- assertEquals(vec1, vec1);
- assertFalse(vec1.equals(null));
- assertFalse(vec1.equals(new Vector4()));
-
- // throw in a couple pool accesses for coverage
- final Vector3 vec6 = Vector3.fetchTempInstance();
- vec6.set(vec1);
- assertEquals(vec1, vec6);
- assertNotSame(vec1, vec6);
- Vector3.releaseTempInstance(vec6);
-
- // cover more of equals
- vec1.set(0, 1, 2);
- assertFalse(vec1.equals(new Vector3(0, 2, 3)));
- assertFalse(vec1.equals(new Vector3(0, 1, 3)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Vector3 vec1 = new Vector3(1, 2, 3);
- final Vector3 vec2 = new Vector3(1, 2, 3);
- final Vector3 vec3 = new Vector3(2, 2, 2);
-
- assertTrue(vec1.hashCode() == vec2.hashCode());
- assertTrue(vec1.hashCode() != vec3.hashCode());
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestVector3 { + + @Test + public void testAdd() { + final Vector3 vec1 = new Vector3(); + final Vector3 vec2 = new Vector3(Vector3.ONE); + + vec1.addLocal(1, 2, 3); + assertEquals(new Vector3(1, 2, 3), vec1); + vec1.addLocal(-1, -2, -3); + assertEquals(Vector3.ZERO, vec1); + + vec1.zero(); + vec1.addLocal(vec2); + assertEquals(Vector3.ONE, vec1); + + vec1.zero(); + final Vector3 vec3 = vec1.add(vec2, new Vector3()); + assertEquals(Vector3.ZERO, vec1); + assertEquals(Vector3.ONE, vec3); + + final Vector3 vec4 = vec1.add(1, 0, 0, null); + assertEquals(Vector3.ZERO, vec1); + assertEquals(Vector3.UNIT_X, vec4); + } + + @Test + public void testSubtract() { + final Vector3 vec1 = new Vector3(); + final Vector3 vec2 = new Vector3(Vector3.ONE); + + vec1.subtractLocal(1, 2, 3); + assertEquals(new Vector3(-1, -2, -3), vec1); + vec1.subtractLocal(-1, -2, -3); + assertEquals(Vector3.ZERO, vec1); + + vec1.zero(); + vec1.subtractLocal(vec2); + assertEquals(Vector3.NEG_ONE, vec1); + + vec1.zero(); + final Vector3 vec3 = vec1.subtract(vec2, new Vector3()); + assertEquals(Vector3.ZERO, vec1); + assertEquals(Vector3.NEG_ONE, vec3); + + final Vector3 vec4 = vec1.subtract(1, 0, 0, null); + assertEquals(Vector3.ZERO, vec1); + assertEquals(Vector3.NEG_UNIT_X, vec4); + } + + @Test + public void testGetSet() { + final Vector3 vec1 = new Vector3(); + vec1.setX(0); + assertTrue(vec1.getX() == 0.0); + vec1.setX(Double.POSITIVE_INFINITY); + assertTrue(vec1.getX() == Double.POSITIVE_INFINITY); + vec1.setX(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY); + + vec1.setY(0); + assertTrue(vec1.getY() == 0.0); + vec1.setY(Double.POSITIVE_INFINITY); + assertTrue(vec1.getY() == Double.POSITIVE_INFINITY); + vec1.setY(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY); + + vec1.setZ(0); + assertTrue(vec1.getZ() == 0.0); + vec1.setZ(Double.POSITIVE_INFINITY); + assertTrue(vec1.getZ() == Double.POSITIVE_INFINITY); + vec1.setZ(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getZ() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(2) == Double.NEGATIVE_INFINITY); + + vec1.set(Math.PI, Math.PI, Math.PI); + assertTrue(vec1.getXf() == (float) Math.PI); + assertTrue(vec1.getYf() == (float) Math.PI); + assertTrue(vec1.getZf() == (float) Math.PI); + + final Vector3 vec2 = new Vector3(); + vec2.set(vec1); + assertEquals(vec1, vec2); + + vec1.setValue(0, 0); + vec1.setValue(1, 0); + vec1.setValue(2, 0); + assertEquals(Vector3.ZERO, vec1); + + // catch a few expected exceptions + try { + vec2.getValue(3); + fail("getValue(3) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.getValue(-1); + fail("getValue(-1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(-1, 0); + fail("setValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(3, 0); + fail("setValue(3, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered vec2 + assertEquals(new Vector3(Math.PI, Math.PI, Math.PI), vec2); + } + + @Test + public void testToArray() { + final Vector3 vec1 = new Vector3(); + vec1.set(Math.PI, Double.MAX_VALUE, 42); + final double[] array = vec1.toArray(null); + final double[] array2 = vec1.toArray(new double[3]); + assertNotNull(array); + assertTrue(array.length == 3); + assertTrue(array[0] == Math.PI); + assertTrue(array[1] == Double.MAX_VALUE); + assertTrue(array[2] == 42); + assertNotNull(array2); + assertTrue(array2.length == 3); + assertTrue(array2[0] == Math.PI); + assertTrue(array2[1] == Double.MAX_VALUE); + assertTrue(array2[2] == 42); + + try { + vec1.toArray(new double[1]); + fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException."); + } catch (final ArrayIndexOutOfBoundsException e) { + } + + final float[] farray = vec1.toFloatArray(null); + final float[] farray2 = vec1.toFloatArray(new float[3]); + assertNotNull(farray); + assertTrue(farray.length == 3); + assertTrue(farray[0] == (float) Math.PI); + assertTrue(farray[1] == (float) Double.MAX_VALUE); + assertTrue(farray[2] == 42f); + assertNotNull(farray2); + assertTrue(farray2.length == 3); + assertTrue(farray2[0] == (float) Math.PI); + assertTrue(farray2[1] == (float) Double.MAX_VALUE); + assertTrue(farray2[2] == 42f); + + try { + vec1.toFloatArray(new float[1]); + fail("toFloatArray(d[1]) should have thrown ArrayIndexOutOfBoundsException."); + } catch (final ArrayIndexOutOfBoundsException e) { + } + } + + @Test + public void testMultiply() { + final Vector3 vec1 = new Vector3(1, -1, 2); + final Vector3 vec2 = vec1.multiply(2.0, null); + final Vector3 vec2B = vec1.multiply(2.0, new Vector3()); + assertEquals(new Vector3(2.0, -2.0, 4.0), vec2); + assertEquals(new Vector3(2.0, -2.0, 4.0), vec2B); + + vec2.multiplyLocal(0.5); + assertEquals(new Vector3(1.0, -1.0, 2.0), vec2); + + final Vector3 vec3 = vec1.multiply(vec2, null); + final Vector3 vec3B = vec1.multiply(vec2, new Vector3()); + assertEquals(new Vector3(1, 1, 4), vec3); + assertEquals(new Vector3(1, 1, 4), vec3B); + + final Vector3 vec4 = vec1.multiply(2, 3, 2, null); + final Vector3 vec4B = vec1.multiply(2, 3, 2, new Vector3()); + assertEquals(new Vector3(2, -3, 4), vec4); + assertEquals(new Vector3(2, -3, 4), vec4B); + + vec1.multiplyLocal(0.5, 0.5, 0.5); + assertEquals(new Vector3(0.5, -0.5, 1.0), vec1); + + vec1.multiplyLocal(vec2); + assertEquals(new Vector3(0.5, 0.5, 2.0), vec1); + } + + @Test + public void testDivide() { + final Vector3 vec1 = new Vector3(1, -1, 2); + final Vector3 vec2 = vec1.divide(2.0, null); + final Vector3 vec2B = vec1.divide(2.0, new Vector3()); + assertEquals(new Vector3(0.5, -0.5, 1.0), vec2); + assertEquals(new Vector3(0.5, -0.5, 1.0), vec2B); + + vec2.divideLocal(0.5); + assertEquals(new Vector3(1.0, -1.0, 2.0), vec2); + + final Vector3 vec3 = vec1.divide(vec2, null); + final Vector3 vec3B = vec1.divide(vec2, new Vector3()); + assertEquals(Vector3.ONE, vec3); + assertEquals(Vector3.ONE, vec3B); + + final Vector3 vec4 = vec1.divide(2, 3, 4, null); + final Vector3 vec4B = vec1.divide(2, 3, 4, new Vector3()); + assertEquals(new Vector3(0.5, -1 / 3., 0.5), vec4); + assertEquals(new Vector3(0.5, -1 / 3., 0.5), vec4B); + + vec1.divideLocal(0.5, 0.5, 0.5); + assertEquals(new Vector3(2, -2, 4), vec1); + + vec1.divideLocal(vec2); + assertEquals(new Vector3(2, 2, 2), vec1); + } + + @Test + public void testScaleAdd() { + final Vector3 vec1 = new Vector3(1, 1, 1); + final Vector3 vec2 = vec1.scaleAdd(2.0, new Vector3(1, 2, 3), null); + final Vector3 vec2B = vec1.scaleAdd(2.0, new Vector3(1, 2, 3), new Vector3()); + assertEquals(new Vector3(3.0, 4.0, 5.0), vec2); + assertEquals(new Vector3(3.0, 4.0, 5.0), vec2B); + + vec1.scaleAddLocal(2.0, new Vector3(1, 2, 3)); + assertEquals(vec2, vec1); + } + + @Test + public void testNegate() { + final Vector3 vec1 = new Vector3(3, 2, -1); + final Vector3 vec2 = vec1.negate(null); + assertEquals(new Vector3(-3, -2, 1), vec2); + + vec1.negateLocal(); + assertEquals(vec2, vec1); + } + + @Test + public void testNormalize() { + final Vector3 vec1 = new Vector3(2, 1, 3); + assertTrue(vec1.length() == Math.sqrt(14)); + + final Vector3 vec2 = vec1.normalize(null); + final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1 + 3 * 3); + assertEquals(new Vector3(2 * invLength, 1 * invLength, 3 * invLength), vec2); + + vec1.normalizeLocal(); + assertEquals(new Vector3(2 * invLength, 1 * invLength, 3 * invLength), vec1); + + vec1.zero(); + vec1.normalize(vec2); + assertEquals(vec1, vec2); + + // ensure no exception thrown + vec1.normalizeLocal(); + vec1.normalize(null); + } + + @Test + public void testDistance() { + final Vector3 vec1 = new Vector3(0, 0, 0); + assertTrue(4.0 == vec1.distance(4, 0, 0)); + assertTrue(3.0 == vec1.distance(0, 3, 0)); + assertTrue(2.0 == vec1.distance(0, 0, 2)); + + final Vector3 vec2 = new Vector3(1, 1, 1); + assertTrue(Math.sqrt(3) == vec1.distance(vec2)); + } + + @Test + public void testLerp() { + final Vector3 vec1 = new Vector3(8, 3, -2); + final Vector3 vec2 = new Vector3(2, 1, 0); + assertEquals(new Vector3(5, 2, -1), vec1.lerp(vec2, 0.5, null)); + assertEquals(new Vector3(5, 2, -1), vec1.lerp(vec2, 0.5, new Vector3())); + assertEquals(new Vector3(5, 2, -1), Vector3.lerp(vec1, vec2, 0.5, null)); + assertEquals(new Vector3(5, 2, -1), Vector3.lerp(vec1, vec2, 0.5, new Vector3())); + + vec1.set(14, 5, 4); + vec1.lerpLocal(vec2, 0.25); + assertEquals(new Vector3(11, 4, 3), vec1); + + vec1.set(15, 7, 6); + final Vector3 vec3 = new Vector3(-1, -1, -1); + vec3.lerpLocal(vec1, vec2, 0.5); + assertEquals(new Vector3(8.5, 4.0, 3.0), vec3); + + // coverage + assertEquals(vec1.lerp(vec1, .25, null), vec1); + assertEquals(vec2.lerpLocal(vec2, .25), vec2); + assertEquals(vec2.lerpLocal(vec2, vec2, .25), vec2); + assertEquals(Vector3.lerp(vec1, vec1, .25, null), vec1); + } + + @Test + public void testCross() { + final Vector3 vec1 = new Vector3(1, 0, 0); + final Vector3 vec2 = new Vector3(0, 1, 0); + assertEquals(Vector3.UNIT_Z, vec1.cross(vec2, null)); + assertEquals(Vector3.UNIT_Z, vec1.cross(vec2, new Vector3())); + + assertEquals(Vector3.UNIT_Z, vec1.cross(0, 1, 0, null)); + assertEquals(Vector3.UNIT_Z, vec1.cross(0, 1, 0, new Vector3())); + + vec1.crossLocal(vec2); + assertEquals(Vector3.UNIT_Z, vec1); + vec2.crossLocal(1, 0, 0); + assertEquals(Vector3.NEG_UNIT_Z, vec2); + } + + @Test + public void testAngle() { + final Vector3 vec1 = new Vector3(1, 0, 0); + + assertTrue(MathUtils.HALF_PI == vec1.smallestAngleBetween(new Vector3(0, -1, 0))); + } + + @Test + public void testDot() { + final Vector3 vec1 = new Vector3(7, 2, 5); + assertTrue(33.0 == vec1.dot(3, 1, 2)); + + assertTrue(-10.0 == vec1.dot(new Vector3(-1, 1, -1))); + } + + @Test + public void testClone() { + final Vector3 vec1 = new Vector3(0, 0, 0); + final Vector3 vec2 = vec1.clone(); + assertEquals(vec1, vec2); + assertNotSame(vec1, vec2); + } + + @Test + public void testValid() { + final Vector3 vec1 = new Vector3(0, 0, 0); + final Vector3 vec2A = new Vector3(Double.POSITIVE_INFINITY, 0, 0); + final Vector3 vec2B = new Vector3(0, Double.NEGATIVE_INFINITY, 0); + final Vector3 vec2C = new Vector3(0, 0, Double.POSITIVE_INFINITY); + final Vector3 vec3A = new Vector3(Double.NaN, 0, 0); + final Vector3 vec3B = new Vector3(0, Double.NaN, 0); + final Vector3 vec3C = new Vector3(0, 0, Double.NaN); + + assertTrue(Vector3.isValid(vec1)); + assertFalse(Vector3.isValid(vec2A)); + assertFalse(Vector3.isValid(vec2B)); + assertFalse(Vector3.isValid(vec2C)); + assertFalse(Vector3.isValid(vec3A)); + assertFalse(Vector3.isValid(vec3B)); + assertFalse(Vector3.isValid(vec3C)); + + assertFalse(Vector3.isInfinite(vec1)); + assertTrue(Vector3.isInfinite(vec2A)); + + vec3C.zero(); + assertTrue(Vector3.isValid(vec3C)); + + assertFalse(Vector3.isValid(null)); + assertFalse(Vector3.isInfinite(null)); + + // couple of equals validity tests + assertEquals(vec1, vec1); + assertFalse(vec1.equals(null)); + assertFalse(vec1.equals(new Vector4())); + + // throw in a couple pool accesses for coverage + final Vector3 vec6 = Vector3.fetchTempInstance(); + vec6.set(vec1); + assertEquals(vec1, vec6); + assertNotSame(vec1, vec6); + Vector3.releaseTempInstance(vec6); + + // cover more of equals + vec1.set(0, 1, 2); + assertFalse(vec1.equals(new Vector3(0, 2, 3))); + assertFalse(vec1.equals(new Vector3(0, 1, 3))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Vector3 vec1 = new Vector3(1, 2, 3); + final Vector3 vec2 = new Vector3(1, 2, 3); + final Vector3 vec3 = new Vector3(2, 2, 2); + + assertTrue(vec1.hashCode() == vec2.hashCode()); + assertTrue(vec1.hashCode() != vec3.hashCode()); + } +} diff --git a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector4.java b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector4.java index 21c1b42..98d39de 100644 --- a/ardor3d-math/src/test/java/com/ardor3d/math/TestVector4.java +++ b/ardor3d-math/src/test/java/com/ardor3d/math/TestVector4.java @@ -1,377 +1,377 @@ -/**
- * 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 static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class TestVector4 {
-
- @Test
- public void testAdd() {
- final Vector4 vec1 = new Vector4();
- final Vector4 vec2 = new Vector4(Vector4.ONE);
-
- vec1.addLocal(1, 2, 3, 4);
- assertEquals(new Vector4(1, 2, 3, 4), vec1);
- vec1.addLocal(-1, -2, -3, -4);
- assertEquals(Vector4.ZERO, vec1);
-
- vec1.zero();
- vec1.addLocal(vec2);
- assertEquals(Vector4.ONE, vec1);
-
- vec1.zero();
- final Vector4 vec3 = vec1.add(vec2, new Vector4());
- assertEquals(Vector4.ZERO, vec1);
- assertEquals(Vector4.ONE, vec3);
-
- final Vector4 vec4 = vec1.add(0, 0, 0, 1, null);
- assertEquals(Vector4.ZERO, vec1);
- assertEquals(Vector4.UNIT_W, vec4);
- }
-
- @Test
- public void testSubtract() {
- final Vector4 vec1 = new Vector4();
- final Vector4 vec2 = new Vector4(Vector4.ONE);
-
- vec1.subtractLocal(1, 2, 3, 4);
- assertEquals(new Vector4(-1, -2, -3, -4), vec1);
- vec1.subtractLocal(-1, -2, -3, -4);
- assertEquals(Vector4.ZERO, vec1);
-
- vec1.zero();
- vec1.subtractLocal(vec2);
- assertEquals(Vector4.NEG_ONE, vec1);
-
- vec1.zero();
- final Vector4 vec3 = vec1.subtract(vec2, new Vector4());
- assertEquals(Vector4.ZERO, vec1);
- assertEquals(Vector4.NEG_ONE, vec3);
-
- final Vector4 vec4 = vec1.subtract(0, 0, 0, 1, null);
- assertEquals(Vector4.ZERO, vec1);
- assertEquals(Vector4.NEG_UNIT_W, vec4);
- }
-
- @Test
- public void testGetSet() {
- final Vector4 vec1 = new Vector4();
- vec1.setX(0);
- assertTrue(vec1.getX() == 0.0);
- vec1.setX(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getX() == Double.POSITIVE_INFINITY);
- vec1.setX(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY);
-
- vec1.setY(0);
- assertTrue(vec1.getY() == 0.0);
- vec1.setY(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getY() == Double.POSITIVE_INFINITY);
- vec1.setY(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY);
-
- vec1.setZ(0);
- assertTrue(vec1.getZ() == 0.0);
- vec1.setZ(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getZ() == Double.POSITIVE_INFINITY);
- vec1.setZ(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getZ() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(2) == Double.NEGATIVE_INFINITY);
-
- vec1.setW(0);
- assertTrue(vec1.getW() == 0.0);
- vec1.setW(Double.POSITIVE_INFINITY);
- assertTrue(vec1.getW() == Double.POSITIVE_INFINITY);
- vec1.setW(Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getW() == Double.NEGATIVE_INFINITY);
- assertTrue(vec1.getValue(3) == Double.NEGATIVE_INFINITY);
-
- vec1.set(Math.PI, Math.PI, Math.PI, Math.PI);
- assertTrue(vec1.getXf() == (float) Math.PI);
- assertTrue(vec1.getYf() == (float) Math.PI);
- assertTrue(vec1.getZf() == (float) Math.PI);
- assertTrue(vec1.getWf() == (float) Math.PI);
-
- final Vector4 vec2 = new Vector4();
- vec2.set(vec1);
- assertEquals(vec1, vec2);
-
- vec1.setValue(0, 0);
- vec1.setValue(1, 0);
- vec1.setValue(2, 0);
- vec1.setValue(3, 0);
- assertEquals(Vector4.ZERO, vec1);
-
- // catch a few expected exceptions
- try {
- vec2.getValue(4);
- fail("getValue(4) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.getValue(-1);
- fail("getValue(-1) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(-1, 0);
- fail("setValue(-1, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- try {
- vec2.setValue(4, 0);
- fail("setValue(4, 0) should have thrown IllegalArgumentException.");
- } catch (final IllegalArgumentException e) {
- }
- // above exceptions shouldn't have altered vec2
- assertEquals(new Vector4(Math.PI, Math.PI, Math.PI, Math.PI), vec2);
- }
-
- @Test
- public void testToArray() {
- final Vector4 vec1 = new Vector4();
- vec1.set(Math.PI, Double.MAX_VALUE, 42, -1);
- final double[] array = vec1.toArray(null);
- final double[] array2 = vec1.toArray(new double[4]);
- assertNotNull(array);
- assertTrue(array.length == 4);
- assertTrue(array[0] == Math.PI);
- assertTrue(array[1] == Double.MAX_VALUE);
- assertTrue(array[2] == 42);
- assertTrue(array[3] == -1);
- assertNotNull(array2);
- assertTrue(array2.length == 4);
- assertTrue(array2[0] == Math.PI);
- assertTrue(array2[1] == Double.MAX_VALUE);
- assertTrue(array2[2] == 42);
- assertTrue(array2[3] == -1);
-
- try {
- vec1.toArray(new double[1]);
- fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException.");
- } catch (final ArrayIndexOutOfBoundsException e) {
- }
- }
-
- @Test
- public void testMultiply() {
- final Vector4 vec1 = new Vector4(1, -1, 2, -2);
- final Vector4 vec2 = vec1.multiply(2.0, null);
- final Vector4 vec2B = vec1.multiply(2.0, new Vector4());
- assertEquals(new Vector4(2.0, -2.0, 4.0, -4.0), vec2);
- assertEquals(new Vector4(2.0, -2.0, 4.0, -4.0), vec2B);
-
- vec2.multiplyLocal(0.5);
- assertEquals(new Vector4(1.0, -1.0, 2.0, -2.0), vec2);
-
- final Vector4 vec3 = vec1.multiply(vec2, null);
- final Vector4 vec3B = vec1.multiply(vec2, new Vector4());
- assertEquals(new Vector4(1, 1, 4, 4), vec3);
- assertEquals(new Vector4(1, 1, 4, 4), vec3B);
-
- final Vector4 vec4 = vec1.multiply(2, 3, 2, 3, null);
- final Vector4 vec4B = vec1.multiply(2, 3, 2, 3, new Vector4());
- assertEquals(new Vector4(2, -3, 4, -6), vec4);
- assertEquals(new Vector4(2, -3, 4, -6), vec4B);
-
- vec1.multiplyLocal(0.5, 0.5, 0.5, 0.5);
- assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec1);
-
- vec1.multiplyLocal(vec2);
- assertEquals(new Vector4(0.5, 0.5, 2.0, 2.0), vec1);
- }
-
- @Test
- public void testDivide() {
- final Vector4 vec1 = new Vector4(1, -1, 2, -2);
- final Vector4 vec2 = vec1.divide(2.0, null);
- final Vector4 vec2B = vec1.divide(2.0, new Vector4());
- assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec2);
- assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec2B);
-
- vec2.divideLocal(0.5);
- assertEquals(new Vector4(1.0, -1.0, 2.0, -2.0), vec2);
-
- final Vector4 vec3 = vec1.divide(vec2, null);
- final Vector4 vec3B = vec1.divide(vec2, new Vector4());
- assertEquals(Vector4.ONE, vec3);
- assertEquals(Vector4.ONE, vec3B);
-
- final Vector4 vec4 = vec1.divide(2, 3, 4, 5, null);
- final Vector4 vec4B = vec1.divide(2, 3, 4, 5, new Vector4());
- assertEquals(new Vector4(0.5, -1 / 3., 0.5, -0.4), vec4);
- assertEquals(new Vector4(0.5, -1 / 3., 0.5, -0.4), vec4B);
-
- vec1.divideLocal(0.5, 0.5, 0.5, 0.5);
- assertEquals(new Vector4(2, -2, 4, -4), vec1);
-
- vec1.divideLocal(vec2);
- assertEquals(new Vector4(2, 2, 2, 2), vec1);
- }
-
- @Test
- public void testScaleAdd() {
- final Vector4 vec1 = new Vector4(1, 1, 1, 1);
- final Vector4 vec2 = vec1.scaleAdd(2.0, new Vector4(1, 2, 3, 4), null);
- final Vector4 vec2B = vec1.scaleAdd(2.0, new Vector4(1, 2, 3, 4), new Vector4());
- assertEquals(new Vector4(3.0, 4.0, 5.0, 6.0), vec2);
- assertEquals(new Vector4(3.0, 4.0, 5.0, 6.0), vec2B);
-
- vec1.scaleAddLocal(2.0, new Vector4(1, 2, 3, 4));
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNegate() {
- final Vector4 vec1 = new Vector4(3, 2, -1, 1);
- final Vector4 vec2 = vec1.negate(null);
- assertEquals(new Vector4(-3, -2, 1, -1), vec2);
-
- vec1.negateLocal();
- assertEquals(vec2, vec1);
- }
-
- @Test
- public void testNormalize() {
- final Vector4 vec1 = new Vector4(2, 1, 3, -1);
- assertTrue(vec1.length() == Math.sqrt(15));
-
- final Vector4 vec2 = vec1.normalize(null);
- final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1 + 3 * 3 + -1 * -1);
- assertEquals(new Vector4(2 * invLength, 1 * invLength, 3 * invLength, -1 * invLength), vec2);
-
- vec1.normalizeLocal();
- assertEquals(new Vector4(2 * invLength, 1 * invLength, 3 * invLength, -1 * invLength), vec1);
-
- vec1.zero();
- vec1.normalize(vec2);
- assertEquals(vec1, vec2);
-
- // ensure no exception thrown
- vec1.normalizeLocal();
- vec1.normalize(null);
- }
-
- @Test
- public void testDistance() {
- final Vector4 vec1 = new Vector4(0, 0, 0, 0);
- assertTrue(4.0 == vec1.distance(4, 0, 0, 0));
- assertTrue(3.0 == vec1.distance(0, 3, 0, 0));
- assertTrue(2.0 == vec1.distance(0, 0, 2, 0));
- assertTrue(1.0 == vec1.distance(0, 0, 0, 1));
-
- final Vector4 vec2 = new Vector4(1, 1, 1, 1);
- assertTrue(Math.sqrt(4) == vec1.distance(vec2));
- }
-
- @Test
- public void testLerp() {
- final Vector4 vec1 = new Vector4(8, 3, -2, 2);
- final Vector4 vec2 = new Vector4(2, 1, 0, -2);
- assertEquals(new Vector4(5, 2, -1, 0), vec1.lerp(vec2, 0.5, null));
- assertEquals(new Vector4(5, 2, -1, 0), vec1.lerp(vec2, 0.5, new Vector4()));
- assertEquals(new Vector4(5, 2, -1, 0), Vector4.lerp(vec1, vec2, 0.5, null));
- assertEquals(new Vector4(5, 2, -1, 0), Vector4.lerp(vec1, vec2, 0.5, new Vector4()));
-
- vec1.set(14, 5, 4, 2);
- vec1.lerpLocal(vec2, 0.25);
- assertEquals(new Vector4(11, 4, 3, 1), vec1);
-
- vec1.set(15, 7, 6, 8);
- final Vector4 vec3 = new Vector4(-1, -1, -1, -1);
- vec3.lerpLocal(vec1, vec2, 0.5);
- assertEquals(new Vector4(8.5, 4.0, 3.0, 3.0), vec3);
-
- // coverage
- assertEquals(vec1.lerp(vec1, .25, null), vec1);
- assertEquals(vec2.lerpLocal(vec2, .25), vec2);
- assertEquals(vec2.lerpLocal(vec2, vec2, .25), vec2);
- assertEquals(Vector4.lerp(vec1, vec1, .25, null), vec1);
- }
-
- @Test
- public void testDot() {
- final Vector4 vec1 = new Vector4(7, 2, 5, -1);
- assertTrue(35.0 == vec1.dot(3, 1, 2, -2));
-
- assertTrue(-11.0 == vec1.dot(new Vector4(-1, 1, -1, 1)));
- }
-
- @Test
- public void testClone() {
- final Vector4 vec1 = new Vector4(0, 0, 0, 0);
- final Vector4 vec2 = vec1.clone();
- assertEquals(vec1, vec2);
- assertNotSame(vec1, vec2);
- }
-
- @Test
- public void testValid() {
- final Vector4 vec1 = new Vector4(0, 0, 0, 0);
- final Vector4 vec2A = new Vector4(Double.POSITIVE_INFINITY, 0, 0, 0);
- final Vector4 vec2B = new Vector4(0, Double.NEGATIVE_INFINITY, 0, 0);
- final Vector4 vec2C = new Vector4(0, 0, Double.POSITIVE_INFINITY, 0);
- final Vector4 vec2D = new Vector4(0, 0, 0, Double.POSITIVE_INFINITY);
- final Vector4 vec3A = new Vector4(Double.NaN, 0, 0, 0);
- final Vector4 vec3B = new Vector4(0, Double.NaN, 0, 0);
- final Vector4 vec3C = new Vector4(0, 0, Double.NaN, 0);
- final Vector4 vec3D = new Vector4(0, 0, 0, Double.NaN);
-
- assertTrue(Vector4.isValid(vec1));
- assertFalse(Vector4.isValid(vec2A));
- assertFalse(Vector4.isValid(vec2B));
- assertFalse(Vector4.isValid(vec2C));
- assertFalse(Vector4.isValid(vec2D));
- assertFalse(Vector4.isValid(vec3A));
- assertFalse(Vector4.isValid(vec3B));
- assertFalse(Vector4.isValid(vec3C));
- assertFalse(Vector4.isValid(vec3D));
-
- vec3C.zero();
- assertTrue(Vector4.isValid(vec3C));
-
- assertFalse(Vector4.isValid(null));
-
- // couple of equals validity tests
- assertEquals(vec1, vec1);
- assertFalse(vec1.equals(null));
- assertFalse(vec1.equals(new Vector2()));
-
- // throw in a couple pool accesses for coverage
- final Vector4 vec6 = Vector4.fetchTempInstance();
- vec6.set(vec1);
- assertEquals(vec1, vec6);
- assertNotSame(vec1, vec6);
- Vector4.releaseTempInstance(vec6);
-
- // cover more of equals
- vec1.set(0, 1, 2, 3);
- assertFalse(vec1.equals(new Vector4(0, 4, 4, 4)));
- assertFalse(vec1.equals(new Vector4(0, 1, 4, 4)));
- assertFalse(vec1.equals(new Vector4(0, 1, 2, 4)));
- }
-
- @Test
- public void testSimpleHash() {
- // Just a simple sanity check.
- final Vector4 vec1 = new Vector4(1, 2, 3, 4);
- final Vector4 vec2 = new Vector4(1, 2, 3, 4);
- final Vector4 vec3 = new Vector4(2, 2, 2, 2);
-
- assertTrue(vec1.hashCode() == vec2.hashCode());
- assertTrue(vec1.hashCode() != vec3.hashCode());
- }
-}
+/** + * 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 static org.junit.Assert.*; + +import org.junit.Test; + +public class TestVector4 { + + @Test + public void testAdd() { + final Vector4 vec1 = new Vector4(); + final Vector4 vec2 = new Vector4(Vector4.ONE); + + vec1.addLocal(1, 2, 3, 4); + assertEquals(new Vector4(1, 2, 3, 4), vec1); + vec1.addLocal(-1, -2, -3, -4); + assertEquals(Vector4.ZERO, vec1); + + vec1.zero(); + vec1.addLocal(vec2); + assertEquals(Vector4.ONE, vec1); + + vec1.zero(); + final Vector4 vec3 = vec1.add(vec2, new Vector4()); + assertEquals(Vector4.ZERO, vec1); + assertEquals(Vector4.ONE, vec3); + + final Vector4 vec4 = vec1.add(0, 0, 0, 1, null); + assertEquals(Vector4.ZERO, vec1); + assertEquals(Vector4.UNIT_W, vec4); + } + + @Test + public void testSubtract() { + final Vector4 vec1 = new Vector4(); + final Vector4 vec2 = new Vector4(Vector4.ONE); + + vec1.subtractLocal(1, 2, 3, 4); + assertEquals(new Vector4(-1, -2, -3, -4), vec1); + vec1.subtractLocal(-1, -2, -3, -4); + assertEquals(Vector4.ZERO, vec1); + + vec1.zero(); + vec1.subtractLocal(vec2); + assertEquals(Vector4.NEG_ONE, vec1); + + vec1.zero(); + final Vector4 vec3 = vec1.subtract(vec2, new Vector4()); + assertEquals(Vector4.ZERO, vec1); + assertEquals(Vector4.NEG_ONE, vec3); + + final Vector4 vec4 = vec1.subtract(0, 0, 0, 1, null); + assertEquals(Vector4.ZERO, vec1); + assertEquals(Vector4.NEG_UNIT_W, vec4); + } + + @Test + public void testGetSet() { + final Vector4 vec1 = new Vector4(); + vec1.setX(0); + assertTrue(vec1.getX() == 0.0); + vec1.setX(Double.POSITIVE_INFINITY); + assertTrue(vec1.getX() == Double.POSITIVE_INFINITY); + vec1.setX(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getX() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(0) == Double.NEGATIVE_INFINITY); + + vec1.setY(0); + assertTrue(vec1.getY() == 0.0); + vec1.setY(Double.POSITIVE_INFINITY); + assertTrue(vec1.getY() == Double.POSITIVE_INFINITY); + vec1.setY(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getY() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(1) == Double.NEGATIVE_INFINITY); + + vec1.setZ(0); + assertTrue(vec1.getZ() == 0.0); + vec1.setZ(Double.POSITIVE_INFINITY); + assertTrue(vec1.getZ() == Double.POSITIVE_INFINITY); + vec1.setZ(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getZ() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(2) == Double.NEGATIVE_INFINITY); + + vec1.setW(0); + assertTrue(vec1.getW() == 0.0); + vec1.setW(Double.POSITIVE_INFINITY); + assertTrue(vec1.getW() == Double.POSITIVE_INFINITY); + vec1.setW(Double.NEGATIVE_INFINITY); + assertTrue(vec1.getW() == Double.NEGATIVE_INFINITY); + assertTrue(vec1.getValue(3) == Double.NEGATIVE_INFINITY); + + vec1.set(Math.PI, Math.PI, Math.PI, Math.PI); + assertTrue(vec1.getXf() == (float) Math.PI); + assertTrue(vec1.getYf() == (float) Math.PI); + assertTrue(vec1.getZf() == (float) Math.PI); + assertTrue(vec1.getWf() == (float) Math.PI); + + final Vector4 vec2 = new Vector4(); + vec2.set(vec1); + assertEquals(vec1, vec2); + + vec1.setValue(0, 0); + vec1.setValue(1, 0); + vec1.setValue(2, 0); + vec1.setValue(3, 0); + assertEquals(Vector4.ZERO, vec1); + + // catch a few expected exceptions + try { + vec2.getValue(4); + fail("getValue(4) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.getValue(-1); + fail("getValue(-1) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(-1, 0); + fail("setValue(-1, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + try { + vec2.setValue(4, 0); + fail("setValue(4, 0) should have thrown IllegalArgumentException."); + } catch (final IllegalArgumentException e) { + } + // above exceptions shouldn't have altered vec2 + assertEquals(new Vector4(Math.PI, Math.PI, Math.PI, Math.PI), vec2); + } + + @Test + public void testToArray() { + final Vector4 vec1 = new Vector4(); + vec1.set(Math.PI, Double.MAX_VALUE, 42, -1); + final double[] array = vec1.toArray(null); + final double[] array2 = vec1.toArray(new double[4]); + assertNotNull(array); + assertTrue(array.length == 4); + assertTrue(array[0] == Math.PI); + assertTrue(array[1] == Double.MAX_VALUE); + assertTrue(array[2] == 42); + assertTrue(array[3] == -1); + assertNotNull(array2); + assertTrue(array2.length == 4); + assertTrue(array2[0] == Math.PI); + assertTrue(array2[1] == Double.MAX_VALUE); + assertTrue(array2[2] == 42); + assertTrue(array2[3] == -1); + + try { + vec1.toArray(new double[1]); + fail("toArray(d[1]) should have thrown ArrayIndexOutOfBoundsException."); + } catch (final ArrayIndexOutOfBoundsException e) { + } + } + + @Test + public void testMultiply() { + final Vector4 vec1 = new Vector4(1, -1, 2, -2); + final Vector4 vec2 = vec1.multiply(2.0, null); + final Vector4 vec2B = vec1.multiply(2.0, new Vector4()); + assertEquals(new Vector4(2.0, -2.0, 4.0, -4.0), vec2); + assertEquals(new Vector4(2.0, -2.0, 4.0, -4.0), vec2B); + + vec2.multiplyLocal(0.5); + assertEquals(new Vector4(1.0, -1.0, 2.0, -2.0), vec2); + + final Vector4 vec3 = vec1.multiply(vec2, null); + final Vector4 vec3B = vec1.multiply(vec2, new Vector4()); + assertEquals(new Vector4(1, 1, 4, 4), vec3); + assertEquals(new Vector4(1, 1, 4, 4), vec3B); + + final Vector4 vec4 = vec1.multiply(2, 3, 2, 3, null); + final Vector4 vec4B = vec1.multiply(2, 3, 2, 3, new Vector4()); + assertEquals(new Vector4(2, -3, 4, -6), vec4); + assertEquals(new Vector4(2, -3, 4, -6), vec4B); + + vec1.multiplyLocal(0.5, 0.5, 0.5, 0.5); + assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec1); + + vec1.multiplyLocal(vec2); + assertEquals(new Vector4(0.5, 0.5, 2.0, 2.0), vec1); + } + + @Test + public void testDivide() { + final Vector4 vec1 = new Vector4(1, -1, 2, -2); + final Vector4 vec2 = vec1.divide(2.0, null); + final Vector4 vec2B = vec1.divide(2.0, new Vector4()); + assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec2); + assertEquals(new Vector4(0.5, -0.5, 1.0, -1.0), vec2B); + + vec2.divideLocal(0.5); + assertEquals(new Vector4(1.0, -1.0, 2.0, -2.0), vec2); + + final Vector4 vec3 = vec1.divide(vec2, null); + final Vector4 vec3B = vec1.divide(vec2, new Vector4()); + assertEquals(Vector4.ONE, vec3); + assertEquals(Vector4.ONE, vec3B); + + final Vector4 vec4 = vec1.divide(2, 3, 4, 5, null); + final Vector4 vec4B = vec1.divide(2, 3, 4, 5, new Vector4()); + assertEquals(new Vector4(0.5, -1 / 3., 0.5, -0.4), vec4); + assertEquals(new Vector4(0.5, -1 / 3., 0.5, -0.4), vec4B); + + vec1.divideLocal(0.5, 0.5, 0.5, 0.5); + assertEquals(new Vector4(2, -2, 4, -4), vec1); + + vec1.divideLocal(vec2); + assertEquals(new Vector4(2, 2, 2, 2), vec1); + } + + @Test + public void testScaleAdd() { + final Vector4 vec1 = new Vector4(1, 1, 1, 1); + final Vector4 vec2 = vec1.scaleAdd(2.0, new Vector4(1, 2, 3, 4), null); + final Vector4 vec2B = vec1.scaleAdd(2.0, new Vector4(1, 2, 3, 4), new Vector4()); + assertEquals(new Vector4(3.0, 4.0, 5.0, 6.0), vec2); + assertEquals(new Vector4(3.0, 4.0, 5.0, 6.0), vec2B); + + vec1.scaleAddLocal(2.0, new Vector4(1, 2, 3, 4)); + assertEquals(vec2, vec1); + } + + @Test + public void testNegate() { + final Vector4 vec1 = new Vector4(3, 2, -1, 1); + final Vector4 vec2 = vec1.negate(null); + assertEquals(new Vector4(-3, -2, 1, -1), vec2); + + vec1.negateLocal(); + assertEquals(vec2, vec1); + } + + @Test + public void testNormalize() { + final Vector4 vec1 = new Vector4(2, 1, 3, -1); + assertTrue(vec1.length() == Math.sqrt(15)); + + final Vector4 vec2 = vec1.normalize(null); + final double invLength = MathUtils.inverseSqrt(2 * 2 + 1 * 1 + 3 * 3 + -1 * -1); + assertEquals(new Vector4(2 * invLength, 1 * invLength, 3 * invLength, -1 * invLength), vec2); + + vec1.normalizeLocal(); + assertEquals(new Vector4(2 * invLength, 1 * invLength, 3 * invLength, -1 * invLength), vec1); + + vec1.zero(); + vec1.normalize(vec2); + assertEquals(vec1, vec2); + + // ensure no exception thrown + vec1.normalizeLocal(); + vec1.normalize(null); + } + + @Test + public void testDistance() { + final Vector4 vec1 = new Vector4(0, 0, 0, 0); + assertTrue(4.0 == vec1.distance(4, 0, 0, 0)); + assertTrue(3.0 == vec1.distance(0, 3, 0, 0)); + assertTrue(2.0 == vec1.distance(0, 0, 2, 0)); + assertTrue(1.0 == vec1.distance(0, 0, 0, 1)); + + final Vector4 vec2 = new Vector4(1, 1, 1, 1); + assertTrue(Math.sqrt(4) == vec1.distance(vec2)); + } + + @Test + public void testLerp() { + final Vector4 vec1 = new Vector4(8, 3, -2, 2); + final Vector4 vec2 = new Vector4(2, 1, 0, -2); + assertEquals(new Vector4(5, 2, -1, 0), vec1.lerp(vec2, 0.5, null)); + assertEquals(new Vector4(5, 2, -1, 0), vec1.lerp(vec2, 0.5, new Vector4())); + assertEquals(new Vector4(5, 2, -1, 0), Vector4.lerp(vec1, vec2, 0.5, null)); + assertEquals(new Vector4(5, 2, -1, 0), Vector4.lerp(vec1, vec2, 0.5, new Vector4())); + + vec1.set(14, 5, 4, 2); + vec1.lerpLocal(vec2, 0.25); + assertEquals(new Vector4(11, 4, 3, 1), vec1); + + vec1.set(15, 7, 6, 8); + final Vector4 vec3 = new Vector4(-1, -1, -1, -1); + vec3.lerpLocal(vec1, vec2, 0.5); + assertEquals(new Vector4(8.5, 4.0, 3.0, 3.0), vec3); + + // coverage + assertEquals(vec1.lerp(vec1, .25, null), vec1); + assertEquals(vec2.lerpLocal(vec2, .25), vec2); + assertEquals(vec2.lerpLocal(vec2, vec2, .25), vec2); + assertEquals(Vector4.lerp(vec1, vec1, .25, null), vec1); + } + + @Test + public void testDot() { + final Vector4 vec1 = new Vector4(7, 2, 5, -1); + assertTrue(35.0 == vec1.dot(3, 1, 2, -2)); + + assertTrue(-11.0 == vec1.dot(new Vector4(-1, 1, -1, 1))); + } + + @Test + public void testClone() { + final Vector4 vec1 = new Vector4(0, 0, 0, 0); + final Vector4 vec2 = vec1.clone(); + assertEquals(vec1, vec2); + assertNotSame(vec1, vec2); + } + + @Test + public void testValid() { + final Vector4 vec1 = new Vector4(0, 0, 0, 0); + final Vector4 vec2A = new Vector4(Double.POSITIVE_INFINITY, 0, 0, 0); + final Vector4 vec2B = new Vector4(0, Double.NEGATIVE_INFINITY, 0, 0); + final Vector4 vec2C = new Vector4(0, 0, Double.POSITIVE_INFINITY, 0); + final Vector4 vec2D = new Vector4(0, 0, 0, Double.POSITIVE_INFINITY); + final Vector4 vec3A = new Vector4(Double.NaN, 0, 0, 0); + final Vector4 vec3B = new Vector4(0, Double.NaN, 0, 0); + final Vector4 vec3C = new Vector4(0, 0, Double.NaN, 0); + final Vector4 vec3D = new Vector4(0, 0, 0, Double.NaN); + + assertTrue(Vector4.isValid(vec1)); + assertFalse(Vector4.isValid(vec2A)); + assertFalse(Vector4.isValid(vec2B)); + assertFalse(Vector4.isValid(vec2C)); + assertFalse(Vector4.isValid(vec2D)); + assertFalse(Vector4.isValid(vec3A)); + assertFalse(Vector4.isValid(vec3B)); + assertFalse(Vector4.isValid(vec3C)); + assertFalse(Vector4.isValid(vec3D)); + + vec3C.zero(); + assertTrue(Vector4.isValid(vec3C)); + + assertFalse(Vector4.isValid(null)); + + // couple of equals validity tests + assertEquals(vec1, vec1); + assertFalse(vec1.equals(null)); + assertFalse(vec1.equals(new Vector2())); + + // throw in a couple pool accesses for coverage + final Vector4 vec6 = Vector4.fetchTempInstance(); + vec6.set(vec1); + assertEquals(vec1, vec6); + assertNotSame(vec1, vec6); + Vector4.releaseTempInstance(vec6); + + // cover more of equals + vec1.set(0, 1, 2, 3); + assertFalse(vec1.equals(new Vector4(0, 4, 4, 4))); + assertFalse(vec1.equals(new Vector4(0, 1, 4, 4))); + assertFalse(vec1.equals(new Vector4(0, 1, 2, 4))); + } + + @Test + public void testSimpleHash() { + // Just a simple sanity check. + final Vector4 vec1 = new Vector4(1, 2, 3, 4); + final Vector4 vec2 = new Vector4(1, 2, 3, 4); + final Vector4 vec3 = new Vector4(2, 2, 2, 2); + + assertTrue(vec1.hashCode() == vec2.hashCode()); + assertTrue(vec1.hashCode() != vec3.hashCode()); + } +} |