omkeybehavior.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

        }
        doMove(new Vector3d(0.0, 0.0, getMovementRate()));
    }

    public void moveLeft() {
        if (DEBUG) {
            Debug.output("Moving left <");
        }
        doMove(new Vector3d(-getMovementRate(), 0.0, 0.0));
    }

    public void moveRight() {
        if (DEBUG) {
            Debug.output("Moving right >");
        }
        doMove(new Vector3d(getMovementRate(), 0.0, 0.0));
    }

    public void moveUp() {
        if (DEBUG) {
            Debug.output("Moving up ^");
        }
        doMove(new Vector3d(0.0, getMovementRate(), 0.0));
    }

    public void moveDown() {
        if (DEBUG) {
            Debug.output("Moving down v ");
        }
        doMove(new Vector3d(0.0, -getMovementRate(), 0.0));
    }

    public void rotRight() {
        if (DEBUG) {
            Debug.output("Rotating right");
        }
        doRotateY(getRotateRightAmount());
    }

    public void lookRight() {
        if (DEBUG) {
            Debug.output("Looking right");
        }
        doLookY(getRotateRightAmount());
    }

    public void rotUp() {
        if (DEBUG) {
            Debug.output("Rotating up");
        }
        doRotateX(getRotateUpAmount());
    }

    public void lookUp() {
        if (DEBUG) {
            Debug.output("Looking up");
        }
        doLookX(getRotateUpAmount());
    }

    public void rotLeft() {
        if (DEBUG) {
            Debug.output("Rotating left");
        }
        doRotateY(getRotateLeftAmount());
    }

    public void lookLeft() {
        if (DEBUG) {
            Debug.output("Looking left");
        }
        doLookY(getRotateLeftAmount());
    }

    public void rotDown() {
        if (DEBUG) {
            Debug.output("Rotating down");
        }
        doRotateX(getRotateDownAmount());
    }

    public void lookDown() {
        if (DEBUG) {
            Debug.output("Looking down");
        }
        doLookX(getRotateDownAmount());
    }

    /**
     * Rotating position on the z axis, negative.
     */
    public void rollLeft() {
        if (DEBUG) {
            Debug.output("Rolling left");
        }
        doRotateZ(getRollLeftAmount());
    }

    /**
     * Tilting the view to the left.
     */
    public void rollLookLeft() {
        if (DEBUG) {
            Debug.output("Tilting left");
        }
        doLookZ(getRollLeftAmount());
    }

    /**
     * Rotating position on the z axis, positive.
     */
    public void rollRight() {
        if (DEBUG) {
            Debug.output("Rolling right");
        }
        doRotateZ(getRollRightAmount());
    }

    /**
     * Tilting the view to the right.
     */
    public void rollLookRight() {
        if (DEBUG) {
            Debug.output("Tilting right");
        }
        doLookZ(getRollRightAmount());
    }

    protected void changePosition(Transform3D toMove) {
        cameraTransformGroup.getTransform(transform3D);

        // Gather the total look transform on all three axis
        Transform3D viewTransform = new Transform3D();
        viewTransform.invert(xRotLookTransform);
        viewTransform.mulInverse(yRotLookTransform);
        viewTransform.mulInverse(zRotLookTransform);

        transform3D.mul(viewTransform);
        transform3D.mul(toMove);

        // May have to create and multiply the non-inverse look
        // transforms.
        transform3D.mulInverse(viewTransform);

        cameraTransformGroup.setTransform(transform3D);
    }

    public void doRotateY(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating Y " + radians + " radians");
        }
        Transform3D toMove = new Transform3D();
        toMove.rotY(radians);
        changePosition(toMove);
    }

    public void doLookY(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating view Y " + radians
                    + " radians");
        }
        cameraTransformGroup.getTransform(transform3D);
        Transform3D toMove = new Transform3D();
        toMove.rotY(radians);
        transform3D.mul(toMove);
        cameraTransformGroup.setTransform(transform3D);

        //Keep track of the view y rotation.
        yRotLookTransform.mul(toMove);
    }

    public void doRotateX(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating X " + radians + " radians");
        }
        Transform3D toMove = new Transform3D();
        toMove.rotX(radians);
        changePosition(toMove);
    }

    public void doLookX(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating view X " + radians
                    + " radians");
        }
        cameraTransformGroup.getTransform(transform3D);
        Transform3D toMove = new Transform3D();
        toMove.rotX(radians);
        transform3D.mul(toMove);
        cameraTransformGroup.setTransform(transform3D);

        //Keep track of the view x rotation.
        xRotLookTransform.mul(toMove);
    }

    public void doRotateZ(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating Z " + radians + " radians");
        }
        Transform3D toMove = new Transform3D();
        toMove.rotZ(radians);
        changePosition(toMove);
    }

    public void doLookZ(double radians) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: rotating view Z " + radians
                    + " radians");
        }
        cameraTransformGroup.getTransform(transform3D);
        Transform3D toMove = new Transform3D();
        toMove.rotZ(radians);
        transform3D.mul(toMove);
        cameraTransformGroup.setTransform(transform3D);

        //Keep track of the view z rotation.
        zRotLookTransform.mul(toMove);
    }

    public void doMove(Vector3d theMove) {
        if (DEBUG) {
            Debug.output("OMKeyBehavior: moving " + theMove);
            Debug.output("     transform before:\n " + transform3D);
        }

        Transform3D toMove = new Transform3D();
        toMove.setTranslation(theMove);
        changePosition(toMove);
    }

    public double getMovementRate() {
        return moveRate * speed;
    }

    public double getRollLeftAmount() {
        return rotateZAmount * speed;
    }

    public double getRollRightAmount() {
        return -rotateZAmount * speed;
    }

    public double getRotateUpAmount() {
        return rotateYAmount * speed;
    }

    public double getRotateDownAmount() {
        return -rotateYAmount * speed;
    }

    public double getRotateLeftAmount() {
        return rotateYAmount * speed;
    }

    public double getRotateRightAmount() {
        return -rotateYAmount * speed;
    }

    public void setRotateXAmount(double radians) {
        rotateXAmount = radians;
    }

    public void setRotateYAmount(double radians) {
        rotateYAmount = radians;
    }

    public void setRotateZAmount(double radians) {
        rotateZAmount = radians;
    }

    public void setMovementRate(double meters) {
        moveRate = meters;
        // Travel rate in meters/frame
    }

    public void setForwardKey(int key) {
        forwardKey = key;
    }

    public void setBackKey(int key) {
        backKey = key;
    }

    public void setLeftKey(int key) {
        leftKey = key;
    }

    public void setRightKey(int key) {
        rightKey = key;
    }
}