[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Java3Djp:01688] 追跡視点を実現したい



〜 12月1日新しいビジネスが始まる!ビジネスも楽天、楽天ビジネス誕生 〜
         ●●●●●●●●●●●●●●●●●●●●●●●●●●●
         ● サービスリリース第一弾!ビジネスサービス商談市場 ●
         ●●●●●●●●●●●●●●●●●●●●●●●●●●●
〜〜〜〜〜 今すぐアクセス! http://business.rakuten.co.jp 〜〜〜〜〜
------------------------------------------------------------------------


初めて投稿します。
佐藤といいます。

ある物体を追跡して表示する視点を実現したいと思い、とりあえず実装してみたので
すが、追跡対象の物体がブレて表示されてしまい困っています。

具体的な方法は
Behaviorから派生させたTrackingBehavior というクラスをこしらえて、こいつに視
点のTransform3Dと追跡対象物のTransform3Dを与えるとWakeupOnTransformChangeを
使って位置変化を検出して追いかけるという方法です。

追跡される物体はKeyNavigatorBehaviorによって移動します。

どうもKeyNavigatorBehaviorが追跡対象のTransform3Dを変化させてから一回画面表
示が行われ、その後にTrackingBehaviorのprocessStimulus()が呼び出されているよ
うな気がします。

こういう状態にならないようにフレームワークのメソッド呼び出しの順序を制御する
方法はあるのでしょうか?

どなたか知恵(知識)をお貸しください。

長いけどソース付けます。(TrackingTest.java)
--------------------------------------------------------------
import java.applet.*;
import java.awt.*;
import java.util.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.behaviors.keyboard.*;

class TrackingBehavior extends Behavior
{
        protected WakeupOnTransformChange wup = null;
        protected TransformGroup handleTG = null;
        protected TransformGroup targetTG = null;

        private Transform3D targetT3D = new Transform3D();
        private Transform3D handleT3D = new Transform3D();
        private Vector3d targetVector = new Vector3d();
        private Vector3d handleVector = new Vector3d();
        private Point3d eye = new Point3d();
        private Point3d center = new Point3d();
        private Vector3d up = new Vector3d();
        private Vector3d temp = new Vector3d();

        private final Vector3d XPLUS = new Vector3d(1.0, 0.0, 0.0);
        private final Vector3d YPLUS = new Vector3d(0.0, 1.0, 0.0);
        private final Vector3d ZPLUS = new Vector3d(0.0, 0.0, 1.0);

        public TrackingBehavior(TransformGroup handleTG)
        {
                super();
                this.handleTG = handleTG;
        }

        public void setTarget(TransformGroup targetTG)
        {
                this.targetTG = targetTG;
                compute();
                wup = new WakeupOnTransformChange(this.targetTG);
        }

        public void setTarget(Cube target)
        {
                setTarget(target.getTransformGroup());
        }

        protected void compute()
        {
                targetTG.getTransform(targetT3D);
                targetT3D.get(targetVector);

                handleTG.getTransform(handleT3D);
                handleT3D.get(handleVector);

                temp.set(handleVector);
                temp.sub(targetVector);

                eye.set(handleVector);
                center.set(targetVector);

                if( temp.x == 0 && temp.z == 0)
                        handleT3D.lookAt(eye, center, ZPLUS);
                else
                        handleT3D.lookAt(eye, center, YPLUS);

                handleT3D.invert();

                try
                {
                        handleTG.setTransform(handleT3D);
                }
                catch(Exception e)
                {
                        System.out.println(e.toString());
                }
        }

        public void initialize()
        {
                compute();
                wakeupOn(wup);
        }

        public void processStimulus(Enumeration criteria)
        {
                compute();
                wakeupOn(wup);
        }
}

class Cube
{
        private BranchGroup bg = null;
        private TransformGroup tg = null;

        public Cube()
        {
                bg = new BranchGroup();

                tg = new TransformGroup();
                tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
                tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
                tg.addChild(new ColorCube(1.0));
                bg.addChild(tg);
        }

        public void enableKeyBehavior()
        {
                BoundingSphere bounds = new BoundingSphere(new Point3d(),
200.0);
                KeyNavigatorBehavior keybehavior = new
KeyNavigatorBehavior(tg);
//              SimpleKeyBehavior keybehavior = new SimpleKeyBehavior(tg);
                keybehavior.setSchedulingBounds(bounds);
                bg.addChild(keybehavior);
        }

        public TransformGroup getTransformGroup()
        {
                return tg;
        }

        public BranchGroup getSceneGraph()
        {
                return bg;
        }
}

public class TrackingTest extends Applet
{
        protected SimpleUniverse universe = null;

        private BranchGroup createFloor()
        {
                BranchGroup bg = new BranchGroup();

                Point3d[] vertices = {
                                new Point3d(-150.0, -2.0, +150.0), new
Point3d(+150.0, -2.0, +150.0),
                                new Point3d(+150.0, -2.0, -150.0), new
Point3d(-150.0, -2.0, -150.0) };

                Color3f[] colors = {
                                new Color3f(0.3f, 0.0f, 0.0f), new
Color3f(0.0f, 0.3f, 0.0f),
                                new Color3f(0.3f, 0.3f, 0.0f), new
Color3f(0.0f, 0.0f, 0.3f) };


                QuadArray geometry = new QuadArray(vertices.length,
GeometryArray.COORDINATES | GeometryArray.COLOR_3);
                geometry.setCoordinates(0, vertices);
                geometry.setColors(0, colors);

                Shape3D floor = new Shape3D(geometry);
                bg.addChild(floor);

                bg.compile();

                return bg;
        }

        public TrackingTest()
        {
                GraphicsConfiguration config =
                        SimpleUniverse.getPreferredConfiguration();

                Canvas3D canvas = new Canvas3D(config);
                this.setLayout(new BorderLayout());
                this.add(canvas, BorderLayout.CENTER);

                universe = new SimpleUniverse(canvas);
                universe.getViewer().getView().setBackClipDistance(100.0);

                BranchGroup root = new BranchGroup();
                Cube cube = new Cube();
                cube.enableKeyBehavior();
                root.addChild(cube.getSceneGraph());

                universe.addBranchGraph(root);
                universe.addBranchGraph(createFloor());

                Transform3D viewT3D = new Transform3D();
                viewT3D.set(new Vector3d(0.0, 80.0, 0.0));

                TransformGroup viewTG =
universe.getViewingPlatform().getViewPlatformTransform();
                viewTG.setTransform(viewT3D);

                TrackingBehavior tb = new
TrackingBehavior(universe.getViewingPlatform().getViewPlatformTransform());
                BoundingSphere bounds = new BoundingSphere( new Point3d(),
100.0 );
                tb.setTarget(cube);
                tb.setSchedulingBounds(bounds);

                PlatformGeometry pg = new PlatformGeometry();
                pg.addChild(tb);
                universe.getViewingPlatform().setPlatformGeometry(pg);
        }

        public static void main(String[] args)
        {
                TrackingTest applet = new TrackingTest();
                MainFrame frame = new MainFrame(applet, 500, 500);
        }
}