public Vector3f mult(Vector3f v, Vector3f store) {
        if (store == null) {
            store = new Vector3f();
        }
        if (v.x == 0 && v.y == 0 && v.z == 0) {
            store.set(0, 0, 0);
        } else {
            float vx = v.x, vy = v.y, vz = v.z;
            store.x = w * w * vx + 2 * y * w * vz - 2 * z * w * vy + x * x
                    * vx + 2 * y * x * vy + 2 * z * x * vz - z * z * vx - y
                    * y * vx;
            store.y = 2 * x * y * vx + y * y * vy + 2 * z * y * vz + 2 * w
                    * z * vx - z * z * vy + w * w * vy - 2 * x * w * vz - x
                    * x * vy;
            store.z = 2 * x * z * vx + 2 * y * z * vy + z * z * vz - 2 * w
                    * y * vx - y * y * vz + 2 * w * x * vy - x * x * vz + w
                    * w * vz;
        }
        return store;
    }
Rotates a specified vector and returns the result in another vector. The
current instance is unaffected.

<p>The quaternion is assumed to be normalized (norm=1). No error checking
is performed; the caller must ensure that the norm is approximately equal
to 1.

<p>It is safe for {@code v} and {@code store} to be the same object.

<p>Despite the name, the result differs from the mathematical definition
of vector-quaternion multiplication.

@param v the vector to rotate (not null, unaffected unless it's
    {@code store})
@param store storage for the result, or null for a new Vector3f
@return the rotated vector (either {@code store} or a new Vector3f)
jme3-core/src/main/java/com/jme3/math/Quaternion.java