Java 类javax.vecmath.Quat4f 实例源码

public EntityCrazyCube(World world, Vec3f pos){
        super(world, getModel0(), pos);
        float s=Rand.f()+1;
        scale.set(s, s, s);

//      model.getMaterial(2).getDiffuse().set(177/256F, 0, 177/256F, 1);
//      model.getMaterial(1).getDiffuse().set(0x00C7E7);
//      model.getMaterial(1).getAmbient().set(0x00C7E7).a(1);
//      model.getMaterial(0).getDiffuse().set(0x0000FF);

        float massKg=0.5F*scale.x*scale.y*scale.z;

        if(CAM==null) CAM=this;

        getPhysicsObj().init(massKg, new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), new Vector3f(pos.x, pos.y, pos.z), 0.5F)), new SphereShape(scale.x/2), Vec3f.single(0.9F));
//      getPhysicsObj().init(massKg, new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), new Vector3f(pos.x, pos.y, pos.z), 0.5F)), new BoxShape(new Vector3f(scale.x/2, scale.y/2, scale.z/2)), Vec3f.single(0.9F));
        getPhysicsObj().body.setDamping(0.15F, 0.15F);
        getPhysicsObj().hookPos(this.pos);
        getPhysicsObj().hookRot(rot);
    }

public static Quat4f parseRotation(JsonElement e)
{
    if (e.isJsonArray())
    {
        if (e.getAsJsonArray().get(0).isJsonObject())
        {
            Quat4f ret = new Quat4f(0, 0, 0, 1);
            for (JsonElement a : e.getAsJsonArray())
            {
                ret.mul(parseAxisRotation(a));
            }
            return ret;
        }
        else
        {
            // quaternion
            return new Quat4f(parseFloatArray(e, 4, "Rotation"));
        }
    }
    else if (e.isJsonObject())
    {
        return parseAxisRotation(e);
    }
    else throw new JsonParseException("Rotation: expected array or object, got: " + e);
}

public static Matrix4f mul(Vector3f translation, Quat4f leftRot, Vector3f scale, Quat4f rightRot)
{
    Matrix4f res = new Matrix4f(), t = new Matrix4f();
    res.setIdentity();
    if(leftRot != null)
    {
        t.set(leftRot);
        res.mul(t);
    }
    if(scale != null)
    {
        t.setIdentity();
        t.m00 = scale.x;
        t.m11 = scale.y;
        t.m22 = scale.z;
        res.mul(t);
    }
    if(rightRot != null)
    {
        t.set(rightRot);
        res.mul(t);
    }
    if(translation != null) res.setTranslation(translation);
    return res;
}

public void applyInitTransform(List<Vector3f> helperPoints) {
    float shiftX = shift.getX() + initialShift.getX();
    float shiftY = shift.getY() + initialShift.getY();
    float shiftZ = shift.getZ() + initialShift.getZ();

    Quat4f rotationQuat = new  Quat4f(0,0,0,1) ;
    rotationQuat.mul(rotQuat,initRotQuat);

    for (int i = 0; i < helperPoints.size(); i++) {
        Vector3f vert = new Vector3f();
        vert.setX(helperPoints.get(i).getX());
        vert.setY(helperPoints.get(i).getY());
        vert.setZ(helperPoints.get(i).getZ());

        vert = rotate(vert,rotationQuat);

        helperPoints.get(i).setX(vert.getX() * scale.getX() + shiftX);
        helperPoints.get(i).setY(vert.getY() * scale.getY() + shiftY);
        helperPoints.get(i).setZ(vert.getZ() * scale.getZ() + shiftZ);
    }
}

private Vector3f quaternionToEuler(Quat4f quat) {
    Vector3f p = new Vector3f();

    double sqw = quat.w * quat.w;
    double sqx = quat.x * quat.x;
    double sqy = quat.y * quat.y;
    double sqz = quat.z * quat.z;

    double unit = sqx + sqy + sqz + sqw; 
    double test = quat.x * quat.y + quat.z * quat.w;
    if (test > 0.499 * unit) { // singularity at north pole
        p.y = (float) (2 * Math.atan2(quat.x, quat.w));
        p.z = (float) (Math.PI * 0.5);
        p.x = 0;
    } else if (test < -0.499 * unit) { // singularity at south pole
        p.y = (float) (-2 * (Math.atan2(quat.x, quat.w)));
        p.z = (float) (-Math.PI * 0.5);
        p.x = 0;
    } else {
        p.y = (float) Math.toDegrees((Math.atan2(2 * quat.y * quat.w - 2 * quat.x * quat.z, sqx - sqy - sqz + sqw)));
        p.z = (float) Math.toDegrees((Math.asin(2 * test / unit)));
        p.x = (float) Math.toDegrees((Math.atan2(2 * quat.x * quat.w - 2 * quat.y * quat.z, -sqx + sqy - sqz + sqw)));
    }

    return p;
}

/**
 * Updates position rotation and size of selected model.
 *
 * @param position new position of a model
 * @param rotation new rotation of a model (in case of editing both models
 * from pair(both eyes, ears...) new rotation of right model)
 * @param rotation2 in case of editing both models from pair (both eyes,
 * ears...) new rotation of left model
 * @param size new size of a model
 */
public void updateSelectedPart(Vector3f position, Quat4f rotation, Quat4f rotation2, Vector3f size) {
    if (currentPart != null && (getSelectedPart(1) != null)) {
        if (currentPart.equals(FacePartType.EYES) || currentPart.equals(FacePartType.EYEBROWS) || currentPart.equals(FacePartType.EARS)) {
            if (getSelectedPart(1).getEditMode() == BOTH) {
                updatePositions(getSelectedPart(1), getSelectedPart(2), position, rotation, rotation2, size);
            } else if (getSelectedPart(1).getEditMode() == RIGHT) {
                updatePositions(getSelectedPart(1), null, position, rotation, rotation2, size);
            } else {
                updatePositions(getSelectedPart(2), null, position, rotation, rotation2, size);
            }
        } else {
            updatePositions(getSelectedPart(1), null, position, rotation, rotation2, size);
        }
    }
}

public @Nonnull Quat4f getSignRotate(final @Nonnull TileEntitySign tile) {
    // Vanilla Translate
    final Block block = tile.getBlockType();
    if (block==Blocks.standing_sign) {
        final float f2 = tile.getBlockMetadata()*360f/16f;
        return RotationMath.quatDeg(-f2, 0f, 1f, 0f);
    } else {
        final int j = tile.getBlockMetadata();
        float f3;
        switch (j) {
            case 2:
                f3 = 180f;
                break;
            case 4:
                f3 = 90f;
                break;
            case 5:
                f3 = -90f;
                break;
            default:
                f3 = 0f;
                break;
        }
        return RotationMath.quatDeg(-f3, 0f, 1f, 0f);
    }
}

/**
 * Create a new Quat4f representing the yaw, pitch and roll given(applied in
 * that order).
 *
 * @param pitch
 *            The pitch.
 * @param yaw
 *            The yaw.
 * @param roll
 *            The roll.
 * @return The new Quat4f.
 */
public static Quat4f quatFromEuler(float pitch, float yaw, float roll) {
    Quat4f quat = new Quat4f();
    pitch = (float) Math.toRadians(pitch);
    yaw = (float) Math.toRadians(yaw);
    roll = (float) Math.toRadians(roll);

    final Vector3f coss = new Vector3f();
    coss.x = (float) Math.cos(pitch * 0.5F);
    coss.y = (float) Math.cos(yaw * 0.5F);
    coss.z = (float) Math.cos(roll * 0.5F);
    final Vector3f sins = new Vector3f();
    sins.x = (float) Math.sin(pitch * 0.5F);
    sins.y = (float) Math.sin(yaw * 0.5F);
    sins.z = (float) Math.sin(roll * 0.5F);

    quat.w = coss.x * coss.y * coss.z + sins.x * sins.y * sins.z;
    quat.x = sins.x * coss.y * coss.z + coss.x * sins.y * sins.z;
    quat.y = coss.x * sins.y * coss.z - sins.x * coss.y * sins.z;
    quat.z = coss.x * coss.y * sins.z - sins.x * sins.y * coss.z;
    return quat;
}

public static Quat4f shortestArcQuat(Vector3f v0, Vector3f v1, Quat4f out) {
    Vector3f c = Stack.alloc(Vector3f.class);
    c.cross(v0, v1);
    float d = v0.dot(v1);

    if (d < -1.0 + BulletGlobals.FLT_EPSILON) {
        // just pick any vector
        out.set(0.0f, 1.0f, 0.0f, 0.0f);
        return out;
    }

    float s = (float) Math.sqrt((1.0f + d) * 2.0f);
    float rs = 1.0f / s;

    out.set(c.x * rs, c.y * rs, c.z * rs, s * 0.5f);
    return out;
}

public static void setRotation(Matrix3f dest, Quat4f q) {
    float d = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
    assert (d != 0f);
    float s = 2f / d;
    float xs = q.x * s, ys = q.y * s, zs = q.z * s;
    float wx = q.w * xs, wy = q.w * ys, wz = q.w * zs;
    float xx = q.x * xs, xy = q.x * ys, xz = q.x * zs;
    float yy = q.y * ys, yz = q.y * zs, zz = q.z * zs;
    dest.m00 = 1f - (yy + zz);
    dest.m01 = xy - wz;
    dest.m02 = xz + wy;
    dest.m10 = xy + wz;
    dest.m11 = 1f - (xx + zz);
    dest.m12 = yz - wx;
    dest.m20 = xz - wy;
    dest.m21 = yz + wx;
    dest.m22 = 1f - (xx + yy);
}

@Override
public void init() {
    Engine.scene.sun.direction = vec3(0.0f, -1.0f, 0.0f);
    Engine.scene.sun.color = vec3(1.2f, 1.2f, 1.2f);

    loadTexture("stone_tile.png", false, true);
    loadTexture("stone_tile_normal.png");
    loadTexture("stone_tile_specular.png");
    loadTexture("planks.jpg", false, true);
    loadTexture("planks_specular.jpg");

    planeMesh = Mesh.raw(Primitives.plane(16.0f), true);
    boxMesh = Mesh.raw(Primitives.cube(16.0f), true);
    sphereMesh = ObjLoader.loadFile("sphere.obj");

    Engine.scene.skybox = new Cubemap("sunset");
    Engine.scene.irradiance = new Cubemap("sunset-irradiance");

    Engine.scene.add(new PointLight(vec3(0.0f, 0.0f, 0.0f), vec3(1.0f, 1.0f, 1.0f), 0.42f, 0.2f));

    Engine.scene.add(new MeshSphere(vec3(), new Quat4f(), new SphereShape(1.0f), 1f, sphereMesh, 1f, sphereMaterial));
    Engine.scene.add(new MeshObject(vec3(0.0f, 5.0f, 0.0f), new Quat4f(), new BoxShape(new Vector3f(0.0f, 0.0f, 0.0f)), 0f, boxMesh, 1f, boxMaterial));
    Engine.scene.add(new MeshObject(vec3(0.0f, -10f, 0.0f), new Quat4f(1.0f, 0.0f, 0.0f, 60.0f), new BoxShape(new Vector3f(50f, 0f, 50f)), 0f, planeMesh, 100f,  groundMaterial));

}

@Override
public void update() {
    accum += Engine.deltaTime;

    //spawns cubes and lights, test if accum is a certain length
    if (Input.isButtonDown(1) && accum > 0.1f) {
        Camera cam = Engine.camera;
        MeshObject c = new MeshObject(cam.getPosition(), cam.front.multiply(30), new Quat4f(1.0f, 0.3f, 0.5f, 0f), new BoxShape(new Vector3f(0.5f, 0.5f, 0.5f)), 1f, cubeMesh, 1f, crateMaterial);
        Engine.scene.add(c);
        accum = 0;
    }
    if (Input.isButtonDown(2) && accum > 1f) {
        PointLight p = new PointLight(Engine.camera.getPosition(), vec3(1.0f, 1.0f, 2.0f), 5f, 10f);
        Engine.scene.add(p);

        accum = 0;
    }
}

@Override
public void render(Scene scene, Camera cam) {
    Shader s = getShader("pbr");
    s.bind();

    s.uniformMaterial(this.material);

    Transform trans = new Transform();
    Quat4f q = new Quat4f();
    rb.getMotionState().getWorldTransform(trans);
    trans.getRotation(q);

    Matrix4f mat = new Matrix4f();
    trans.getMatrix(mat);
    s.uniformMat4("model", mat4(mat).scale(this.scale));
    mesh.draw();
}

public boolean makeDomino(float mass, Vector3f inertia, Vector3f loc,
        float angle) {
    if (cntCreated >= numDominoes)
        return false;
    int i = cntCreated++;
    dominoOrigTransform[i] = new Transform(new Matrix4f(new Quat4f(0,
            sin(angle) / (float) Math.sqrt(2), 0, 1), loc, 1.0f));
    DefaultMotionState dominoMotion = new DefaultMotionState(
            dominoOrigTransform[i]);
    RigidBodyConstructionInfo dominoRigidBodyCI = new RigidBodyConstructionInfo(
            mass, dominoMotion, dominoShape, inertia);
    domino[i] = new RigidBody(dominoRigidBodyCI);
    domino[i].setRestitution(0.5f);
    world.addRigidBody(domino[i]);
    return true;
}

private Quat4f yrp2q(float roll, float pitch, float yaw) {

        float halfYaw = yaw * 0.5f;
        float halfPitch = pitch * 0.5f;
        float halfRoll = roll * 0.5f;

        float cosYaw = (float) cos(halfYaw);
        float sinYaw = (float) sin(halfYaw);
        float cosPitch = (float) cos(halfPitch);
        float sinPitch = (float) sin(halfPitch);
        float cosRoll = (float) cos(halfRoll);
        float sinRoll = (float) sin(halfRoll);

        return new Quat4f(sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw, //x
                cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw, //y
                cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw, //z
                cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw); //formerly yzx
    }

public void shootTrimesh(Vector3f destination) {
    if (dynamicsWorld != null) {
        float mass = 4f;
        Transform startTransform = new Transform();
        startTransform.setIdentity();
        Vector3f camPos = getCameraPosition();
        startTransform.origin.set(camPos);

        RigidBody body = localCreateRigidBody(mass, startTransform, trimeshShape);

        Vector3f linVel = new Vector3f(destination.x - camPos.x, destination.y - camPos.y, destination.z - camPos.z);
        linVel.normalize();
        linVel.scale(ShootBoxInitialSpeed * 0.25f);

        Transform tr = new Transform();
        tr.origin.set(camPos);
        tr.setRotation(new Quat4f(0f, 0f, 0f, 1f));
        body.setWorldTransform(tr);

        body.setLinearVelocity(linVel);
        body.setAngularVelocity(new Vector3f(0f, 0f, 0f));
    }
}

public static Quat4f shortestArcQuat(Vector3f v0, Vector3f v1, Quat4f out) {
    Vector3f c = Stack.alloc(Vector3f.class);
    c.cross(v0, v1);
    float d = v0.dot(v1);

    if (d < -1.0 + BulletGlobals.FLT_EPSILON) {
        // just pick any vector
        out.set(0.0f, 1.0f, 0.0f, 0.0f);
        return out;
    }

    float s = (float) Math.sqrt((1.0f + d) * 2.0f);
    float rs = 1.0f / s;

    out.set(c.x * rs, c.y * rs, c.z * rs, s * 0.5f);
    return out;
}

public static void setRotation(Matrix3f dest, Quat4f q) {
    float d = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
    assert (d != 0f);
    float s = 2f / d;
    float xs = q.x * s, ys = q.y * s, zs = q.z * s;
    float wx = q.w * xs, wy = q.w * ys, wz = q.w * zs;
    float xx = q.x * xs, xy = q.x * ys, xz = q.x * zs;
    float yy = q.y * ys, yz = q.y * zs, zz = q.z * zs;
    dest.m00 = 1f - (yy + zz);
    dest.m01 = xy - wz;
    dest.m02 = xz + wy;
    dest.m10 = xy + wz;
    dest.m11 = 1f - (xx + zz);
    dest.m12 = yz - wx;
    dest.m20 = xz - wy;
    dest.m21 = yz + wx;
    dest.m22 = 1f - (xx + yy);
}

public void shootTrimesh(Vector3f destination) {
    if (dynamicsWorld != null) {
        float mass = 4f;
        Transform startTransform = new Transform();
        startTransform.setIdentity();
        Vector3f camPos = getCameraPosition();
        startTransform.origin.set(camPos);

        RigidBody body = localCreateRigidBody(mass, startTransform, trimeshShape);

        Vector3f linVel = new Vector3f(destination.x - camPos.x, destination.y - camPos.y, destination.z - camPos.z);
        linVel.normalize();
        linVel.scale(ShootBoxInitialSpeed * 0.25f);

        Transform tr = new Transform();
        tr.origin.set(camPos);
        tr.setRotation(new Quat4f(0f, 0f, 0f, 1f));
        body.setWorldTransform(tr);

        body.setLinearVelocity(linVel);
        body.setAngularVelocity(new Vector3f(0f, 0f, 0f));
    }
}

public static Quat4f shortestArcQuat(Vector3f v0, Vector3f v1, Quat4f out) {
    Vector3f c = Stack.alloc(Vector3f.class);
    c.cross(v0, v1);
    float d = v0.dot(v1);

    if (d < -1.0 + BulletGlobals.FLT_EPSILON) {
        // just pick any vector
        out.set(0.0f, 1.0f, 0.0f, 0.0f);
        return out;
    }

    float s = (float) Math.sqrt((1.0f + d) * 2.0f);
    float rs = 1.0f / s;

    out.set(c.x * rs, c.y * rs, c.z * rs, s * 0.5f);
    return out;
}

public static void setRotation(Matrix3f dest, Quat4f q) {
    float d = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
    assert (d != 0f);
    float s = 2f / d;
    float xs = q.x * s, ys = q.y * s, zs = q.z * s;
    float wx = q.w * xs, wy = q.w * ys, wz = q.w * zs;
    float xx = q.x * xs, xy = q.x * ys, xz = q.x * zs;
    float yy = q.y * ys, yz = q.y * zs, zz = q.z * zs;
    dest.m00 = 1f - (yy + zz);
    dest.m01 = xy - wz;
    dest.m02 = xz + wy;
    dest.m10 = xy + wz;
    dest.m11 = 1f - (xx + zz);
    dest.m12 = yz - wx;
    dest.m20 = xz - wy;
    dest.m21 = yz + wx;
    dest.m22 = 1f - (xx + yy);
}

/**
 * Builds the appropriate quaternion to rotate around the given orthogonalAxis.
 */
public static Quat4f rotationForAxis(EnumFacing.Axis axis, double degrees)
{
    Quat4f retVal = new Quat4f();
    switch (axis) {
    case X:
        retVal.set(new AxisAngle4d(1, 0, 0, Math.toRadians(degrees)));
        break;
    case Y:
        retVal.set(new AxisAngle4d(0, 1, 0, Math.toRadians(degrees)));
        break;
    case Z:
        retVal.set(new AxisAngle4d(0, 0, 1, Math.toRadians(degrees)));
        break;
    }
    return retVal;
}

/**
 * Takes a {@link Quaternion} and a {@link Vector3f} as input and returns a {@link Matrix4f} that represents the
 * rotation-translation of the passed in arguments.<br>
 * This handles null values as follows:<br>
 * - if rotation is <code>null</code> the upper left 3x3 matrix will be the identity matrix - if translation is
 * <code>null</code> the third column will be the identity vector
 *
 */
public static Matrix4f fromRTS(Quat4f rotation, Vector3f offset, Vector3f scale, Matrix4f out) {
    fromRTS(rotation, offset, 1.0f, out);
    float sX = scale.x, sY = scale.y, sZ = scale.z;
    out.m00 *= sX;
    out.m01 *= sX;
    out.m02 *= sX;

    out.m10 *= sY;
    out.m11 *= sY;
    out.m12 *= sY;

    out.m20 *= sZ;
    out.m21 *= sZ;
    out.m22 *= sZ;
    return out;
}

public static Transform createTransform(Vector3f position, Quaternion rotation) {
    if (position == null) {
        position = new Vector3f(0);
       }

       if (rotation == null) {
        rotation = new Quaternion(new Matrix4f().initIdentity());
       }

    Transform transform = new Transform();

    transform.origin.set(position.getX(), position.getY(), position.getZ());
    transform.basis.set(new Quat4f(rotation.getX(),rotation.getY(),rotation.getZ(),rotation.getW()));

    return transform;
}

public static double staticMethod1(Quat4f q) {
    double angle;

    float dirW = q.w;

    if (q.w * q.w + q.y * q.y > 0.0f) {
        if (q.w > 0.f && q.y < 0.0f)
            dirW *= -1.0f;

        angle = 2.0f * Math.acos(dirW);
    } else {
        angle = 0.0f;
    }

    return angle / 6.283f * 100.f;
}

public void move( float right , float up , float back )
{
    q1.conjugate( orientation );

    Quat4f qright = new Quat4f( 1 , 0 , 0 , 0 );
    Quat4f qup = new Quat4f( 0 , 1 , 0 , 0 );
    Quat4f qback = new Quat4f( 0 , 0 , 1 , 0 );

    qright.mul( q1 );
    qright.mul( orientation , qright );
    qup.mul( q1 );
    qup.mul( orientation , qup );
    qback.mul( q1 );
    qback.mul( orientation , qback );

    position.x += qright.x * right + qup.x * up + qback.x * back;
    position.y += qright.y * right + qup.y * up + qback.y * back;
    position.z += qright.z * right + qup.z * up + qback.z * back;
}

public static double staticMethod1(Quat4f q) {
    double angle;

    float dirW = q.w;

    if (q.w * q.w + q.y * q.y > 0.0f) {
        if (q.w > 0.f && q.y < 0.0f)
            dirW *= -1.0f;

        angle = 2.0f * Math.acos(dirW);
    } else {
        angle = 0.0f;
    }

    return angle / 6.283f * 100.f;
}

public void update(double delta)
{
    Transform out = new Transform();
    out = body.getWorldTransform(out);
    Quat4f rot = new Quat4f(0, 0, 0, 1);
    rot = out.getRotation(rot);
    Quaternion newRot = PhysicsEngine.toJGE(rot);
    Vector3 physicalPos = PhysicsEngine.toJGE(out.origin);
    org.jge.maths.Transform parentTransform = getParent().getTransform().getParent();
    if(parentTransform != null)
    {
        Vector3 parentPos = parentTransform.getTransformedPos();
        physicalPos = physicalPos.sub(parentPos);
        physicalPos = physicalPos.rotate(parentTransform.getTransformedRotation().conjugate());

        newRot = newRot.mul(parentTransform.getTransformedRotation().conjugate());
    }
    this.getParent().getTransform().setPosition(physicalPos);
    this.getParent().getTransform().setRotation(newRot);
}

/**
    * Constructs a new RotPosScalePathInterpolator object that varies the
    * rotation, translation, and scale of the target TransformGroup's 
    * transform.
    * @param alpha the alpha object for this interpolator.
    * @param target the TransformGroup node affected by this interpolator.
    * @param axisOfTransform the transform that specifies the local
    * coordinate system in which this interpolator operates.
    * @param knots an array of knot values that specify interpolation points.
    * @param quats an array of quaternion values at the knots.
    * @param positions an array of position values at the knots.
    * @param scales an array of scale component values at the knots.
    * @exception IllegalArgumentException if the lengths of the
    * knots, quats, positions, and scales arrays are not all the same.
    */
   public RotPosScalePathInterpolator(Alpha alpha,
                   TransformGroup target,
                   Transform3D axisOfTransform,
                   float[] knots,
                   Quat4f[] quats,
                   Point3f[] positions,
                   float[] scales) {
super(alpha, target, axisOfTransform, knots);

if (knots.length != quats.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator1"));

if (knots.length != positions.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator0"));

if (knots.length != scales.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator2"));

setPathArrays(quats, positions, scales);
   }

/**
    * Replaces the existing arrays of knot values, quaternion
    * values, position values, and scale values with the specified arrays.
    * The arrays of knots, quats, positions, and scales are copied
    * into this interpolator object.
    * @param knots a new array of knot values that specify
    * interpolation points.
    * @param quats a new array of quaternion values at the knots.
    * @param positions a new array of position values at the knots.
    * @param scales a new array of scale component values at the knots.
    * @exception IllegalArgumentException if the lengths of the
    * knots, quats, positions, and scales arrays are not all the same.
    *
    * @since Java 3D 1.2
    */
   public void setPathArrays(float[] knots,
              Quat4f[] quats,
              Point3f[] positions,
              float[] scales) {
if (knots.length != quats.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator1"));

if (knots.length != positions.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator0"));

if (knots.length != scales.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosScalePathInterpolator2"));

setKnots(knots);
setPathArrays(quats, positions, scales);
   }

private void setPathArrays(Quat4f[] quats,
               Point3f[] positions,
               float[] scales) {

this.quats = new Quat4f[quats.length];
for(int i = 0; i < quats.length; i++) {
    this.quats[i] = new Quat4f();
    this.quats[i].set(quats[i]);
}

this.positions = new Point3f[positions.length];
for(int i = 0; i < positions.length; i++) {
    this.positions[i] = new Point3f();
    this.positions[i].set(positions[i]);
}

this.scales = new float[scales.length];
for(int i = 0; i < scales.length; i++) {
    this.scales[i] = scales[i];
}
   }

/**
    * Constructs a new interpolator that varies the rotation and translation
    * of the target TransformGroup's transform.
    * @param alpha the alpha object for this interpolator
    * @param target the TransformGroup node affected by this translator
    * @param axisOfTransform the transform that defines the local coordinate
    * system in which this interpolator operates
    * @param knots an array of knot values that specify interpolation points.
    * @param quats an array of quaternion values at the knots.
    * @param positions an array of position values at the knots.
    * @exception IllegalArgumentException if the lengths of the
    * knots, quats, and positions arrays are not all the same.
    */
   public RotPosPathInterpolator(Alpha alpha,
              TransformGroup target,
              Transform3D axisOfTransform,
              float[] knots,
              Quat4f[] quats,
              Point3f[] positions) {
super(alpha, target, axisOfTransform, knots);

if (knots.length != positions.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosPathInterpolator0"));

if (knots.length != quats.length)
    throw new IllegalArgumentException(J3dI18N.getString("RotPosPathInterpolator0"));

setPathArrays(quats, positions);
   }

/**
    * Copies all RotPosPathInterpolator information from
    * <code>originalNode</code> into
    * the current node.  This method is called from the
    * <code>cloneNode</code> method which is, in turn, called by the
    * <code>cloneTree</code> method.<P> 
    *
    * @param originalNode the original node to duplicate.
    * @param forceDuplicate when set to <code>true</code>, causes the
    *  <code>duplicateOnCloneTree</code> flag to be ignored.  When
    *  <code>false</code>, the value of each node's
    *  <code>duplicateOnCloneTree</code> variable determines whether
    *  NodeComponent data is duplicated or copied.
    *
    * @exception RestrictedAccessException if this object is part of a live
    *  or compiled scenegraph.
    *
    * @see Node#duplicateNode
    * @see Node#cloneTree
    * @see NodeComponent#setDuplicateOnCloneTree
    */
   void duplicateAttributes(Node originalNode, boolean forceDuplicate) {
       super.duplicateAttributes(originalNode, forceDuplicate);

RotPosPathInterpolator ri = (RotPosPathInterpolator) originalNode;

       int len = ri.getArrayLengths();

// No API availble to set array size, so explicitly set it here
       positions = new Point3f[len];
       quats = new Quat4f[len];

       Point3f point = new Point3f();
       Quat4f quat = new Quat4f();

       for (int i = 0; i < len; i++) {
           positions[i] = new Point3f();
           ri.getPosition(i, point);
           setPosition(i, point);

           quats[i] = new Quat4f();
           ri.getQuat(i, quat);
           setQuat(i, quat);
       }

   }

private void registerTypeHandlers(ComponentLibrary library) {
    library.registerTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler());
    library.registerTypeHandler(Color4f.class, new Color4fTypeHandler());
    library.registerTypeHandler(Quat4f.class, new Quat4fTypeHandler());
    library.registerTypeHandler(Mesh.class, new AssetTypeHandler(AssetType.MESH, Mesh.class));
    library.registerTypeHandler(Sound.class, new AssetTypeHandler(AssetType.SOUND, Sound.class));
    library.registerTypeHandler(Material.class, new AssetTypeHandler(AssetType.MATERIAL, Material.class));
    library.registerTypeHandler(SkeletalMesh.class, new AssetTypeHandler(AssetType.SKELETON_MESH, SkeletalMesh.class));
    library.registerTypeHandler(MeshAnimation.class, new AssetTypeHandler(AssetType.ANIMATION, MeshAnimation.class));
    library.registerTypeHandler(Vector3f.class, new Vector3fTypeHandler());
    library.registerTypeHandler(Vector2f.class, new Vector2fTypeHandler());
    Vector3iTypeHandler vector3iHandler = new Vector3iTypeHandler();
    library.registerTypeHandler(Vector3i.class, vector3iHandler);
    library.registerTypeHandler(CollisionGroup.class, new CollisionGroupTypeHandler());
    library.registerTypeHandler(Region3i.class, new Region3iTypeHandler(vector3iHandler));
}

private void updateSkeleton(SkeletalMeshComponent skeletalMeshComp, MeshAnimationFrame frameA, MeshAnimationFrame frameB, float interpolationVal) {
    Vector3f newPos = new Vector3f();
    Quat4f newRot = new Quat4f();

    for (int i = 0; i < skeletalMeshComp.animation.getBoneCount(); ++i) {
        EntityRef boneEntity = skeletalMeshComp.boneEntities.get(skeletalMeshComp.animation.getBoneName(i));
        if (boneEntity == null) {
            continue;
        }
        LocationComponent boneLoc = boneEntity.getComponent(LocationComponent.class);
        if (boneLoc != null) {

            newPos.interpolate(frameA.getPosition(i), frameB.getPosition(i), interpolationVal);
            boneLoc.setLocalPosition(newPos);
            newRot.interpolate(frameA.getRotation(i), frameB.getRotation(i), interpolationVal);
            newRot.normalize();
            boneLoc.setLocalRotation(newRot);
            boneEntity.saveComponent(boneLoc);
        }
    }
}

private void renderBoneOrientation(EntityRef boneEntity) {
    LocationComponent loc = boneEntity.getComponent(LocationComponent.class);
    if (loc == null) {
        return;
    }
    glPushMatrix();
    Vector3f worldPosA = loc.getWorldPosition();
    Quat4f worldRot = loc.getWorldRotation();
    Vector3f offset = new Vector3f(0, 0, 0.1f);
    QuaternionUtil.quatRotate(worldRot, offset, offset);
    offset.add(worldPosA);

    glBegin(GL11.GL_LINES);
    glVertex3f(worldPosA.x, worldPosA.y, worldPosA.z);
    glVertex3f(offset.x, offset.y, offset.z);
    glEnd();

    for (EntityRef child : loc.getChildren()) {
        renderBoneOrientation(child);
    }
    glPopMatrix();
}

public List<Vector3f> getVertexPositions(List<Vector3f> bonePositions, List<Quat4f> boneRotations) {
    List<Vector3f> results = Lists.newArrayListWithCapacity(getVertexCount());
    for (int i = 0; i < vertexStartWeights.size(); ++i) {
        Vector3f vertexPos = new Vector3f();
        for (int weightIndexOffset = 0; weightIndexOffset < vertexWeightCounts.get(i); ++weightIndexOffset) {
            int weightIndex = vertexStartWeights.get(i) + weightIndexOffset;
            BoneWeight weight = weights.get(weightIndex);

            Vector3f current = QuaternionUtil.quatRotate(boneRotations.get(weight.getBoneIndex()), weight.getPosition(), new Vector3f());
            current.add(bonePositions.get(weight.getBoneIndex()));
            current.scale(weight.getBias());
            vertexPos.add(current);
        }
        results.add(vertexPos);
    }
    return results;
}

public List<Vector3f> getVertexNormals(List<Vector3f> bonePositions, List<Quat4f> boneRotations) {
    List<Vector3f> results = Lists.newArrayListWithCapacity(getVertexCount());
    for (int i = 0; i < vertexStartWeights.size(); ++i) {
        Vector3f vertexNorm = new Vector3f();
        for (int weightIndexOffset = 0; weightIndexOffset < vertexWeightCounts.get(i); ++weightIndexOffset) {
            int weightIndex = vertexStartWeights.get(i) + weightIndexOffset;
            BoneWeight weight = weights.get(weightIndex);

            Vector3f current = QuaternionUtil.quatRotate(boneRotations.get(weight.getBoneIndex()), weight.getNormal(), new Vector3f());
            current.scale(weight.getBias());
            vertexNorm.add(current);
        }
        results.add(vertexNorm);
    }
    return results;
}

@Command(shortDescription = "Spawns an instance of a prefab in the world")
public void spawnPrefab(@CommandParam(name = "prefabId") String prefabName) {
    Camera camera = CoreRegistry.get(WorldRenderer.class).getActiveCamera();
    Vector3f spawnPos = camera.getPosition();
    Vector3f offset = new Vector3f(camera.getViewingDirection());
    offset.scale(2);
    spawnPos.add(offset);
    Vector3f dir = new Vector3f(camera.getViewingDirection());
    dir.y = 0;
    if (dir.lengthSquared() > 0.001f) {
        dir.normalize();
    } else {
        dir.set(0, 0, 1);
    }
    Quat4f rotation = QuaternionUtil.shortestArcQuat(new Vector3f(0, 0, 1), dir, new Quat4f());

    Prefab prefab = CoreRegistry.get(PrefabManager.class).getPrefab(prefabName);
    if (prefab != null && prefab.getComponent(LocationComponent.class) != null) {
        CoreRegistry.get(EntityManager.class).create(prefab, spawnPos, rotation);
    }
}

public final void readFromStream(DataInputStreamLittleEndian is) throws IOException {
        boneName = is.readString(15);
        boneIndex = -1;
//        for(int i=0;i<vmdFile.boneNames.size();i++) {
//            if (boneName.equals(vmdFile.boneNames.get(i))) {
//                boneIndex = (short)i;
//                break;
//            }
//        }
        boneIndex = (short)vmdFile.boneNames.indexOf(boneName);
        if (boneIndex < 0) {
            vmdFile.boneNames.add(boneName);
//            boneIndex = (short)(vmdFile.boneNames.size() - 1);
            boneIndex = (short)vmdFile.boneNames.indexOf(boneName);
        }
        frameNo = is.readInt();
        location = new Point3f();
        location.x = is.readFloat();
        location.y = is.readFloat();
        location.z = -is.readFloat();
        rotation = new Quat4f(is.readFloat(), is.readFloat(), -is.readFloat(), -is.readFloat());
        int pos = 0;
        while(pos < 64) {
            pos += is.read(interpolation, pos, 64 - pos);
        }
    }