使用java3D和rotpospathInterpolator制作正确的动画

我试图让一个物体在一个正方形中飞过我的场景（这是正确的），但我希望它也朝向它要去的地方

目前的问题是物体会飞，并且在飞行时会旋转（这不是自然现象）。我希望它飞到一个点，然后停下来旋转，然后飞到下一个点，然后再次旋转，依此类推

我试图通过Java3D函数实现这一点： 旋转插补器

这就是我正在做的：

Alpha alphaNave = new Alpha( -1, Alpha.INCREASING_ENABLE, 0,0,6000,0,0,0,0,0 );
TransformGroup target = new TransformGroup();
Transform3D axisOfRotPos = new Transform3D();
float[] alphas = {0.0f, 0.25f, 0.50f, 0.75f, 1.0f};
Quat4f[] quats = new Quat4f[5];
Point3f[] positions = new Point3f[5];

target.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

    quats[0] = new Quat4f(0.0f, 1.0f, 0.0f, (float) Math.toRadians(0));
    quats[1] = new Quat4f(0.0f, 1.0f, 0.0f, (float) Math.toRadians(90));
    quats[2] = new Quat4f(0.0f, 1.0f, 0.0f, (float) Math.toRadians(180));
    quats[3] = new Quat4f(0.0f, 1.0f, 0.0f, (float) Math.toRadians(270));
    quats[4] = quats[0];

    positions[0]= new Point3f( -20.0f,  0.0f, 20.0f);
    positions[1]= new Point3f( -20.0f, 0.0f, -20.0f);
    positions[2]= new Point3f( 20.0f,  0.0f, -20.0f);
    positions[3]= new Point3f( 20.0f,  0.0f, 20.0f);
    positions[4]= positions[0];

RotPosPathInterpolator rotPosPath = new RotPosPathInterpolator(
            alphaNave, target, axisOfRotPos, alphas, quats, positions);

---

首先是简短的旁注：创建四元数时，最后一个分量不是角度。为了创建一个四元数来描述围绕特定轴、围绕特定角度的旋转，最简单的方法是浏览

AxisAngle4f

类

AxisAngle4f a = new AxisAngle4f(0.0f, 1.0f, 0.0f, angleInRadians);
Quat4f q = new Quat4f();
q.set(a);

（不幸的是，没有方便的构造函数来实现这一点。我建议用返回适当四元数的实用方法来包装这三行）

---

关于实际问题：如果我正确理解了你，那么期望的行为是：

（这是根据我在下面添加的创建的）

如果只希望有一个移动（无旋转），则必须在插值路径中插入两个点，其中只有位置更改，但旋转保持不变。类似地，如果只需要旋转，则必须创建两个点，其中只有旋转发生变化，但位置保持不变。当然，您必须始终相应地调整

alpha

值

在本例中，您的路径将由9个点组成。手动添加这些点，并计算所需的

alpha

值是一件麻烦事。我建议为此创建一个小型实用程序类。下面的MCVE允许将点（每个点包括一个位置和一个角度）添加到

InterpolatorData

类，该类随后为插值器提供数据

import java.awt.GraphicsConfiguration;
import java.util.ArrayList;
import java.util.List;

import javax.media.j3d.Alpha;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.RotPosPathInterpolator;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.vecmath.AxisAngle4f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Quat4f;
import javax.vecmath.Vector3d;

import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.SimpleUniverse;

public class RotPosPathInterpolatorTest
{
    public static void main(String[] args) 
    {
        System.setProperty("sun.awt.noerasebackground", "true");

        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);;

        GraphicsConfiguration config = 
            SimpleUniverse.getPreferredConfiguration();
        Canvas3D canvas = new Canvas3D(config);
        frame.getContentPane().add(canvas);
        SimpleUniverse simpleUniverse = new SimpleUniverse(canvas);

        BranchGroup rootBranchGroup = new BranchGroup();
        createContents(rootBranchGroup);

        simpleUniverse.addBranchGraph(rootBranchGroup);

        Transform3D t0 = new Transform3D();
        t0.rotX(Math.toRadians(-45));
        Transform3D t1 = new Transform3D();
        t1.setTranslation(new Vector3d(0,0,10));
        t0.mul(t1);
        simpleUniverse.
            getViewingPlatform().
            getViewPlatformTransform().
            setTransform(t0);

        frame.setSize(400, 400);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    private static class InterpolatorData
    {
        private final List<Point3f> positions = new ArrayList<Point3f>();
        private final List<Quat4f> orientations = new ArrayList<Quat4f>();

        void add(Point3f p, float angleDeg)
        {
            positions.add(p);

            AxisAngle4f a = new AxisAngle4f(
                0.0f, 1.0f, 0.0f, (float) Math.toRadians(angleDeg));
            Quat4f q = new Quat4f();
            q.set(a);
            orientations.add(q);
        }

        Point3f[] getPositions()
        {
            return positions.toArray(new Point3f[0]);
        }

        Quat4f[] getOrientations()
        {
            return orientations.toArray(new Quat4f[0]);
        }

        float[] getAlphas()
        {
            float alphas[] = new float[positions.size()];
            float delta = 1.0f / (alphas.length - 1);
            for (int i=0; i<alphas.length; i++)
            {
                alphas[i] = i * delta;
            }
            return alphas;
        }
    }

    private static void createContents(BranchGroup rootBranchGroup)
    {
        Alpha alpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 
            0, 0, 6000, 0, 0, 0, 0, 0);
        TransformGroup target = new TransformGroup();
        target.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D axisOfTransform = new Transform3D();

        InterpolatorData i = new InterpolatorData();
        i.add(new Point3f(-2.0f, 0.0f,  2.0f),   0.0f);
        i.add(new Point3f(-2.0f, 0.0f, -2.0f),   0.0f);
        i.add(new Point3f(-2.0f, 0.0f, -2.0f),  90.0f);
        i.add(new Point3f( 2.0f, 0.0f, -2.0f),  90.0f);
        i.add(new Point3f( 2.0f, 0.0f, -2.0f), 180.0f);
        i.add(new Point3f( 2.0f, 0.0f,  2.0f), 180.0f);
        i.add(new Point3f( 2.0f, 0.0f,  2.0f), 270.0f);
        i.add(new Point3f(-2.0f, 0.0f,  2.0f), 270.0f);
        i.add(new Point3f(-2.0f, 0.0f,  2.0f),   0.0f);

        RotPosPathInterpolator interpolator = new RotPosPathInterpolator(
            alpha, target, axisOfTransform, 
            i.getAlphas(), i.getOrientations(), i.getPositions());        
        interpolator.setSchedulingBounds(
            new BoundingSphere(new Point3d(), 100.0));

        rootBranchGroup.addChild(target);
        target.addChild(interpolator);
        target.addChild(new ColorCube(0.4));
    }
}

导入java.awt.GraphicsConfiguration；
导入java.util.ArrayList；
导入java.util.List；
导入javax.media.j3d.Alpha；
导入javax.media.j3d.BoundingSphere；
导入javax.media.j3d.BranchGroup；
导入javax.media.j3d.Canvas3D；
导入javax.media.j3d.RotPosPathInterpolator；
导入javax.media.j3d.Transform3D；
导入javax.media.j3d.TransformGroup；
导入javax.swing.JFrame；
导入javax.swing.SwingUtilities；
导入javax.vecmath.AxisAngle4f；
导入javax.vecmath.Point3d；
导入javax.vecmath.Point3f；
导入javax.vecmath.Quat4f；
导入javax.vecmath.Vector3d；
导入com.sun.j3d.utils.geometry.ColorCube；
导入com.sun.j3d.utils.universe.SimpleUniverse；
公共类Rotpospathortest
{
公共静态void main（字符串[]args）
{
System.setProperty（“sun.awt.noerasebackground”、“true”）；
SwingUtilities.invokeLater（新的Runnable（）
{
@凌驾
公开募捐
{
createAndShowGUI（）；
}
});
}
私有静态void createAndShowGUI（）
{
JFrame=新JFrame（）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；；
图形配置配置=
SimpleUniverse.getPreferredConfiguration（）；
Canvas3D画布=新的Canvas3D（配置）；
frame.getContentPane（）.add（画布）；
SimpleUniverse SimpleUniverse=新SimpleUniverse（画布）；
BranchGroup rootBranchGroup=新建BranchGroup（）；
createContents（rootBranchGroup）；
simpleUniverse.addBranchGraph（rootBranchGroup）；
Transform3D t0=新Transform3D（）；
t0.rotX（数学托拉迪安（-45））；
Transform3D t1=新Transform3D（）；
t1.集平移（新向量3D（0,0,10））；
t0.mul（t1）；
简单宇宙。
getViewingPlatform（）。
getViewPlatformTransform（）。
setTransform（t0）；
框架。设置尺寸（400400）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
私有静态类插值数据
{
私有最终列表位置=新ArrayList（）；
私有最终列表方向=新建ArrayList（）；
无效添加（点3F p，浮动角度DEG）
{
增加（p）；
AxisAngle4f a=新AxisAngle4f(
0.0f，1.0f，0.0f，（浮动）数学托拉半径（角度度）；
Quat4f q=新的Quat4f（）；
q、 组（a）；
方向。添加（q）；
}
点3f[]获取位置（）
{
返回位置。toArray（新的点3f[0]）；
}
Quat4f[]获取方向（）
{
返回方向。toArray（新的Quat4f[0]）；
}
float[]getAlphas（）
{
float alphas[]=新的float[positions.size（）]；
浮动增量=1.0f/（字母长度-1）；
对于（int i=0；i