org.joml.Quaternionf Java Examples

@Override
public void update(Timer timer)
{
    // Get the rotation component of the game object's transform.
    Quaternionf rot = getGameObject().getTransform()
                                     .getRotation();

    // Get the amount of time, in seconds, that passed since the timer was started.
    // (At the beginning of the game loop.)
    float t = (float) timer.getElapsedTime();

    // Reset the rotation, and apply the new rotation values to it.
    rot.identity();
    rot.rotateLocalX(t * 2.2369f);
    rot.rotateLocalY(t * 1.4562f);
    rot.rotateLocalZ(t * 0.2123f);
}
 

@Test
public void equals_diffInstance_diffProperties()
{
    Transform3D t1 = new Transform3D();
    t1.setPosition(1, 2, 4);
    t1.setRotation(new Quaternionf(4, 3, 30, 1));
    t1.setSize(13f);

    Transform3D t2 = new Transform3D();
    t2.setPosition(1, 2, 4);
    t2.setRotation(new Quaternionf(4, 3, 2, 1));
    t2.setSize(13f);

    assertNotEquals(t1, t2);
    assertNotEquals(t1.hashCode(), t2.hashCode());
}
 

/**
 * Updates the position of the camera based on the current yaw and pitch. This
 * method will also clamp the yaw and pitch into the acceptable range if
 * required.
 */
public void updatePosition()
{
    yaw %= Math.PI * 2;
    pitch = (float) Math.max(-Math.PI / 2f, Math.min(Math.PI / 2f, pitch));

    Quaternionf rot = camera.getTransform()
                            .getRotation();

    rot.identity()
       .rotateLocalX(pitch)
       .rotateLocalY(yaw);

    camera.getTransform()
          .getPosition()
          .set(0f, 0f, distance)
          .rotate(rot)
          .add(offset);
}
 

@Test
public void defaultProperties()
{
    Camera camera = new Camera(mock(Screen.class));

    assertEquals(0.1f, camera.getNearClip(), 0f);
    assertEquals(1000f, camera.getFarClip(), 0f);
    assertEquals(Math.PI / 2f, camera.getFov(), 0.0001f);

    assertEquals(new Vector3f(), camera.getTransform()
                                       .getPosition());
    assertEquals(new Quaternionf(), camera.getTransform()
                                          .getRotation());
    assertEquals(new Vector3f(1f), camera.getTransform()
                                         .getSize());
}
 

@Test
public void equals_diffInstance_diffProperties()
{
    Transform3D t1 = new Transform3D();
    t1.setPosition(1, 2, 4);
    t1.setRotation(new Quaternionf(4, 3, 30, 1));
    t1.setSize(13f);

    Transform3D t2 = new Transform3D();
    t2.setPosition(1, 2, 4);
    t2.setRotation(new Quaternionf(4, 3, 2, 1));
    t2.setSize(13f);

    assertNotEquals(t1, t2);
    assertNotEquals(t1.hashCode(), t2.hashCode());
}
 

@Test
public void getLocalMatrix()
{
    Transform3D t = new Transform3D();

    t.setPosition(10f, 30f, 50f);
    t.getRotation()
     .rotateLocalX((float) Math.toRadians(90f));
    t.setSize(4f);

    Matrix4f mat = new Matrix4f();
    t.getLocalMatrix(mat);

    Matrix4f mat2 = new Matrix4f();
    mat2.translate(10f, 30f, 50f);
    mat2.rotate(new Quaternionf().rotateLocalX((float) Math.toRadians(90f)));
    mat2.scale(4f);

    Assert.assertEquals(mat2, mat);
}
 

@Override
public void update(Timer timer)
{
    // Get the rotation component of the game object's transform.
    Quaternionf rot = getGameObject().getTransform()
                                     .getRotation();

    // Get the amount of time, in seconds, that passed since the timer was started.
    // (At the beginning of the game loop.)
    float t = (float) timer.getElapsedTime();

    // Reset the rotation, and apply the new rotation values to it.
    rot.identity();
    rot.rotateLocalX(t * 2.2369f);
    rot.rotateLocalY(t * 1.4562f);
    rot.rotateLocalZ(t * 0.2123f);
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public GameItem() {
    selected = false;
    position = new Vector3f();
    scale = 1;
    rotation = new Quaternionf();
    textPos = 0;
    insideFrustum = true;
    disableFrustumCulling = false;
}
 

public static Quaternionf calculateQuaternion(Vector3f vec) {
    Quaternionf orientation = new Quaternionf(vec.x, vec.y, vec.z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public Matrix4f buildModelMatrix(GameItem gameItem) {
    Quaternionf rotation = gameItem.getRotation();
    return modelMatrix.translationRotateScale(
            gameItem.getPosition().x, gameItem.getPosition().y, gameItem.getPosition().z,
            rotation.x, rotation.y, rotation.z, rotation.w,
            gameItem.getScale(), gameItem.getScale(), gameItem.getScale());
}
 

public GameItem() {
    selected = false;
    position = new Vector3f();
    scale = 1;
    rotation = new Quaternionf();
    textPos = 0;
    insideFrustum = true;
    disableFrustumCulling = false;
}
 

@Test
public void default_rotation()
{
    Transform3D t = new Transform3D();

    Quaternionf rot = t.getRotation();
    Assert.assertEquals(0f, rot.x, 0f);
    Assert.assertEquals(0f, rot.y, 0f);
    Assert.assertEquals(0f, rot.z, 0f);
    Assert.assertEquals(1f, rot.w, 0f);
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

@Override public void drag( int x, int y ) {

        if(!sciView.getCamera().getLock().tryLock()) {
            return;
        }

        Vector3f translationVector = new Vector3f((x - lastX) * getDragSpeed(), (y - lastY) * getDragSpeed(), 0);

        ( new Quaternionf( sciView.getCamera().getRotation() ) ).conjugate().transform( translationVector );
        translationVector.y *= -1;
        sciView.getCamera().setPosition( sciView.getCamera().getPosition().add( new Vector3f( translationVector.x(), translationVector.y(), translationVector.z() ) ) );

        sciView.getCamera().getLock().unlock();
    }
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public Matrix4f buildModelMatrix(GameItem gameItem) {
    Quaternionf rotation = gameItem.getRotation();
    return modelMatrix.translationRotateScale(
            gameItem.getPosition().x, gameItem.getPosition().y, gameItem.getPosition().z,
            rotation.x, rotation.y, rotation.z, rotation.w,
            gameItem.getScale(), gameItem.getScale(), gameItem.getScale());
}
 

@Test
public void setRotation_FromQuaternion()
{
    Transform3D t = new Transform3D();
    t.setRotation(new Quaternionf(1, 2, 3, 4));

    Quaternionf rot = t.getRotation();
    Assert.assertEquals(1f, rot.x, 0f);
    Assert.assertEquals(2f, rot.y, 0f);
    Assert.assertEquals(3f, rot.z, 0f);
    Assert.assertEquals(4f, rot.w, 0f);
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

@Test
public void testMutate() {
	final Vector3f xAxis = new Vector3f(1, 0, 0);
	final Vector3f in = new Vector3f(xAxis);
	final Quaternionf q = new Quaternionf(new AxisAngle4f((float) (Math.PI /
		2.0), 0, 0, 1));
	final Vector3f expected = xAxis.rotate(q);

	final Vector3f result = ops.linalg().rotate1(in, q);

	assertSame("Mutate should operate on the input object", in, result);
	assertEquals("Rotation is incorrect", expected, result);
}
 

public Matrix4f buildModelMatrix(GameItem gameItem) {
    Quaternionf rotation = gameItem.getRotation();
    return modelMatrix.translationRotateScale(
            gameItem.getPosition().x, gameItem.getPosition().y, gameItem.getPosition().z,
            rotation.x, rotation.y, rotation.z, rotation.w,
            gameItem.getScale(), gameItem.getScale(), gameItem.getScale());
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public Matrix4f buildModelMatrix(GameItem gameItem) {
    Quaternionf rotation = gameItem.getRotation();
    return modelMatrix.translationRotateScale(
            gameItem.getPosition().x, gameItem.getPosition().y, gameItem.getPosition().z,
            rotation.x, rotation.y, rotation.z, rotation.w,
            gameItem.getScale(), gameItem.getScale(), gameItem.getScale());
}
 

public GameItem() {
    selected = false;
    position = new Vector3f();
    scale = 1;
    rotation = new Quaternionf();
    textPos = 0;
    insideFrustum = true;
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public GameItem() {
    selected = false;
    position = new Vector3f();
    scale = 1;
    rotation = new Quaternionf();
    textPos = 0;
}
 

public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) - (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}
 

public Matrix4f buildModelMatrix(GameItem gameItem) {
    Quaternionf rotation = gameItem.getRotation();
    return modelMatrix.translationRotateScale(
            gameItem.getPosition().x, gameItem.getPosition().y, gameItem.getPosition().z,
            rotation.x, rotation.y, rotation.z, rotation.w,
            gameItem.getScale(), gameItem.getScale(), gameItem.getScale());
}