/** * Rotate points. * * @param rotate * the rotate */ public void rotatePoints(final Quaternion rotate) { final FloatBuffer vertexBuffer = getVertexBuffer(); final Vector3 store = new Vector3(); for (int x = 0; x < _vertexCount; x++) { BufferUtils.populateFromBuffer(store, vertexBuffer, x); rotate.apply(store, store); BufferUtils.setInBuffer(store, vertexBuffer, x); } }
quat.apply(rotated, rotated); worker.applyRotationZ(MathUtils.PI); worker.applyRotationX(MathUtils.HALF_PI); worker.apply(expected, expected); 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); 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); 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);
/** * Rotate normals. * * @param rotate * the rotate */ public void rotateNormals(final Quaternion rotate) { final FloatBuffer normalBuffer = getNormalBuffer(); final Vector3 store = new Vector3(); for (int x = 0; x < _vertexCount; x++) { BufferUtils.populateFromBuffer(store, normalBuffer, x); rotate.apply(store, store); BufferUtils.setInBuffer(store, normalBuffer, x); } }
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); assertTrue(Math.abs(new Vector3(-1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); assertTrue(Math.abs(new Vector3(0, 1, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); assertTrue(Math.abs(new Vector3(1, 0, 0).distance(store.apply(Vector3.UNIT_X, null))) <= Quaternion.ALLOWED_DEVIANCE); 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); assertTrue(Math.abs(new Vector3(0, -1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); assertTrue(Math.abs(new Vector3(0, 0, 1).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); assertTrue(Math.abs(new Vector3(0, 1, 0).distance(quat.apply(Vector3.UNIT_Y, null))) <= Quaternion.ALLOWED_DEVIANCE); 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); 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);
/** * Rotate normals. * * @param rotate * the rotate */ public void rotateNormals(final Quaternion rotate) { final Vector3 store = new Vector3(); for (int x = 0; x < _vertexCount; x++) { BufferUtils.populateFromBuffer(store, _normalCoords.getBuffer(), x); rotate.apply(store, store); BufferUtils.setInBuffer(store, _normalCoords.getBuffer(), x); } }
/** * Rotate points. * * @param rotate * the rotate */ public void rotatePoints(final Quaternion rotate) { final Vector3 store = new Vector3(); for (int x = 0; x < _vertexCount; x++) { BufferUtils.populateFromBuffer(store, _vertexCoords.getBuffer(), x); rotate.apply(store, store); BufferUtils.setInBuffer(store, _vertexCoords.getBuffer(), x); } }
@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 testApplyToZero() { assertEquals(Vector3.ZERO, new Quaternion().apply(new Vector3(0, 0, 0), null)); }
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); 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); -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); 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);
@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 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); }
@Override public void apply(final double dt, final Particle p, final int index) { final double dtStr = dt * _strength * (_random ? MathUtils.nextRandomFloat() : 1f); p.getPosition().subtract(_line.getOrigin(), _v1); _line.getDirection().cross(_v1, v2); if (v2.length() == 0) { // particle is on the axis return; } v2.normalizeLocal(); if (_type == VT_CYLINDER) { _rot.apply(v2, v2); v2.scaleAdd(dtStr, p.getVelocity(), p.getVelocity()); return; } v2.cross(_line.getDirection(), _v1); _v1.multiplyLocal(_radius); _line.getDirection().scaleAdd(_height, _v1, _v1); _v1.addLocal(_line.getOrigin()); _v1.subtractLocal(p.getPosition()); if (_v1.length() == 0) { // particle is on the ring return; } _v1.normalizeLocal(); _v1.cross(v2, v3); _rot.fromAngleAxis(-_divergence, v2); _rot.apply(v3, v3); v3.scaleAdd(dtStr, p.getVelocity(), p.getVelocity()); }
@Override public void apply(final double dt, final Particle p, final int index) { final double dtStr = dt * _strength * (_random ? MathUtils.nextRandomFloat() : 1f); p.getPosition().subtract(_line.getOrigin(), _v1); _line.getDirection().cross(_v1, v2); if (v2.length() == 0) { // particle is on the axis return; } v2.normalizeLocal(); if (_type == VT_CYLINDER) { _rot.apply(v2, v2); v2.scaleAdd(dtStr, p.getVelocity(), p.getVelocity()); return; } v2.cross(_line.getDirection(), _v1); _v1.multiplyLocal(_radius); _line.getDirection().scaleAdd(_height, _v1, _v1); _v1.addLocal(_line.getOrigin()); _v1.subtractLocal(p.getPosition()); if (_v1.length() == 0) { // particle is on the ring return; } _v1.normalizeLocal(); _v1.cross(v2, v3); _rot.fromAngleAxis(-_divergence, v2); _rot.apply(v3, v3); v3.scaleAdd(dtStr, p.getVelocity(), p.getVelocity()); }
@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 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); }
tempQuat.apply(triModel.get(x), tempVec3); } else { tempVec3.set(triModel.get(x));
tempQuat.apply(triModel.get(x), tempVec3); } else { tempVec3.set(triModel.get(x));