* $Author: hansonr $

* $Date: 2006-12-18 10:29:29 -0600 (Mon, 18 Dec 2006) $

* $Revision: 6502 $

*

* Copyright (C) 2003-2005  The Jmol Development Team

*

* Contact: jmol-developers@lists.sf.net

*

*  This library is free software; you can redistribute it and/or

*  modify it under the terms of the GNU Lesser General Public

*  License as published by the Free Software Foundation; either

*  version 2.1 of the License, or (at your option) any later version.

*

*  This library is distributed in the hope that it will be useful,

*  but WITHOUT ANY WARRANTY; without even the implied warranty of

*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

*  Lesser General Public License for more details.

*

*  You should have received a copy of the GNU Lesser General Public

*  License along with this library; if not, write to the Free Software

*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*/

  Viewer viewer;

  final static double twoPI = 2 * Math.PI;

  final static double degreesPerRadian = 180 / Math.PI;

  static final int DEFAULT_NAV_FPS = 10;

  protected int perspectiveModel = DEFAULT_PERSPECTIVE_MODEL;

  protected float cameraScaleFactor;

  protected float referencePlaneOffset;

  protected float aperatureAngle;

  protected float cameraDistanceFromCenter;

  protected float modelCenterOffset;

  protected float modelRadius;

  protected float modelRadiusPixels;

 

  protected final Point3f navigationCenter = new Point3f();

  protected final Point3f navigationOffset = new Point3f();

  protected final Point3f navigationShiftXY = new Point3f();

  protected final Matrix4f matrixTemp = new Matrix4f();

  protected final Vector3f vectorTemp = new Vector3f();

  /**

   * sets all camera and scale factors needed by

   * the specific perspective model instantiated

   *

   */

  abstract protected void calcCameraFactors();

  /**

   * calculate the perspective factor based on z

   * @param z

   * @return perspectiveFactor

   */

  abstract protected float getPerspectiveFactor(float z);

  /**

   * adjusts the temporary point for perspective and offsets

   *

   */

  abstract void adjustTemporaryScreenPoint();

  TransformManager() {

  }

  TransformManager(Viewer viewer) {

    this.viewer = viewer;

  }

  TransformManager(Viewer viewer, int width, int height) {

    setViewer(viewer, width, height);

  }

  void setViewer(Viewer viewer, int width, int height) {

    this.viewer = viewer;

    setScreenParameters(width, height, true, false, true, true);

  }

  TransformManager getNavigationManager(Viewer viewer, int width, int height) {

    TransformManager t = new TransformManager11();

    t.setViewer(viewer, width, height);

    return t;

  }

  /* ***************************************************************

   * GENERAL METHODS

   ***************************************************************/

  void homePosition(boolean resetSpin) {

    // reset, setNavigationMode, setPerspectiveModel

    if (resetSpin)

      setSpinOn(false);

    setNavOn(false);

    navFps = DEFAULT_NAV_FPS;

    navX = navY = navZ = 0;

    rotationCenterDefault.set(viewer.getBoundBoxCenter());

    setFixedRotationCenter(rotationCenterDefault);

    rotationRadiusDefault = setRotationRadius(0, true);

    windowCentered = true;

    setRotationCenterAndRadiusXYZ(null, true);

    matrixRotate.setIdentity(); // no rotations

    //if (viewer.autoLoadOrientation()) {

      Matrix3f m = (Matrix3f) viewer

          .getModelSetAuxiliaryInfo("defaultOrientationMatrix");

      if (m != null)

        matrixRotate.set(m);

    //}

    setZoomEnabled(true);

    zoomToPercent(viewer.isModelKitMode() ? 50 : 100);

    zoomPercent = zoomPercentSetting;

    slabReset();

    scaleFitToScreen(true);

    if (viewer.isJmolDataFrame()) {

      fixedRotationCenter.set(0, 0, 0);

    } else {

      if (viewer.getAxesOrientationRasmol())

        rotateX((float) Math.PI);

    }

    viewer.saveOrientation("default");

    if (mode == MODE_NAVIGATION)

      setNavigationMode(true);

  }

  void clear() {

    clearVibration();

    clearSpin();

    stopMotion();

    fixedRotationCenter.set(0, 0, 0);

    navigating = false;

    slabPlane = null;

    depthPlane = null;

    resetNavigationPoint(true);

  }

  String getState(StringBuffer sfunc) {

    StringBuffer commands = new StringBuffer("");

    if (sfunc != null) {

      sfunc.append("  _setPerspectiveState;\n");

      commands.append("function _setPerspectiveState() {\n");

    }

    StateManager

        .appendCmd(commands, "set perspectiveModel " + perspectiveModel);

    StateManager.appendCmd(commands, "set scaleAngstromsPerInch "

        + scale3DAngstromsPerInch);

    StateManager

        .appendCmd(commands, "set perspectiveDepth " + perspectiveDepth);

    StateManager.appendCmd(commands, "set visualRange " + visualRange);

    if (!isWindowCentered())

      StateManager.appendCmd(commands, "set windowCentered false");

    StateManager.appendCmd(commands, "set cameraDepth " + cameraDepth);

    if (mode == MODE_NAVIGATION)

      StateManager.appendCmd(commands, "set navigationMode true");

    StateManager.appendCmd(commands, viewer.getBoundBoxCommand(false));

    StateManager.appendCmd(commands, "center "

        + Escape.escape(fixedRotationCenter));

    commands.append(viewer.getSavedOrienationText(null));

   

   

    StateManager.appendCmd(commands, getMoveToText(0, false));

    if (stereoMode != JmolConstants.STEREO_NONE)

      StateManager.appendCmd(commands, "stereo "

          + (stereoColors == null ?

              JmolConstants.getStereoModeName(stereoMode)

              : Escape.escapeColor(stereoColors[0])

                  + " " + Escape.escapeColor(stereoColors[1]))

          + " " + stereoDegrees);

    if (mode != MODE_NAVIGATION && !zoomEnabled)

      StateManager.appendCmd(commands, "zoom off");

    commands.append("  slab ").append(slabPercentSetting).append(";depth ")

        .append(depthPercentSetting).append(

            slabEnabled && mode != MODE_NAVIGATION ? ";slab on" : "").append(";\n");

    if (zShadeEnabled)

      commands.append("  set zShade;\n");

    if (slabPlane != null)

      commands.append("  slab plane ").append(Escape.escape(slabPlane)).append(

          ";\n");

    if (depthPlane != null)

      commands.append("  depth plane ").append(Escape.escape(depthPlane))

          .append(";\n");

    commands.append(getSpinState(true)).append("\n");

    if (viewer.modelSetHasVibrationVectors() && vibrationOn)

      StateManager.appendCmd(commands, "set vibrationPeriod " + vibrationPeriod + ";vibration on");

    if (mode == MODE_NAVIGATION) {

      commands.append(getNavigationState());

      if (depthPlane != null || slabPlane != null)

        commands.append("  slab on;\n");

    }

    if (sfunc != null)

      commands.append("}\n\n");

    return commands.toString();

  }

  String getSpinState(boolean isAll) {

    String s = "  set spinX " + (int) spinX + "; set spinY " + (int) spinY

        + "; set spinZ " + (int) spinZ + "; set spinFps " + (int) spinFps + ";";

    if (!Float.isNaN(navFps))

      s += "  set navX " + (int) navX + "; set navY " + (int) navY

          + "; set navZ " + (int) navZ + "; set navFps " + (int) navFps + ";";

    if (navOn)

      s += " navigation on;";

    if (!spinOn)

      return s;

    String prefix = (isSpinSelected ? "\n  select "

        + Escape.escape(viewer.getSelectionSet(false)) + ";\n  rotateSelected"

        : "\n ");

    if (isSpinInternal) {

      Point3f pt = new Point3f(internalRotationCenter);

      pt.sub(rotationAxis);

      s += prefix + " spin " + rotationRate + " "

          + Escape.escape(internalRotationCenter) + " " + Escape.escape(pt);

    } else if (isSpinFixed) {

      s += prefix + " spin axisangle " + Escape.escape(rotationAxis) + " "

          + rotationRate;

    } else {

      s += " spin on";

    }

    return s + ";";

  }

  protected boolean haveNotifiedNaN = false;

  final static int DEFAULT_SPIN_Y = 30;

  final static int DEFAULT_SPIN_FPS = 30;

  float spinX, spinY = DEFAULT_SPIN_Y, spinZ, spinFps = DEFAULT_SPIN_FPS;

  protected float navX;

  protected float navY;

  protected float navZ;

  protected float navFps = Float.NaN;

  boolean isSpinInternal = false;

  boolean isSpinFixed = false;

  boolean isSpinSelected = false;

  protected final Point3f fixedRotationOffset = new Point3f();

  protected final Point3f fixedRotationCenter = new Point3f();

  protected final Point3f perspectiveOffset = new Point3f();

  protected final Point3f perspectiveShiftXY = new Point3f();

  private final Point3f rotationCenterDefault = new Point3f();

  private float rotationRadiusDefault;

  protected final AxisAngle4f fixedRotationAxis = new AxisAngle4f();

  protected final AxisAngle4f internalRotationAxis = new AxisAngle4f();

  protected Vector3f internalTranslation;

  private final Point3f internalRotationCenter = new Point3f(0, 0, 0);

  private float internalRotationAngle = 0;

  /* ***************************************************************

   * ROTATIONS

   ***************************************************************/

  // this matrix only holds rotations ... no translations

  protected final Matrix3f matrixRotate = new Matrix3f();

  private final Matrix3f matrixTemp3 = new Matrix3f();

  private final Matrix4f matrixTemp4 = new Matrix4f();

  private final AxisAngle4f axisangleT = new AxisAngle4f();

  private final Vector3f vectorT = new Vector3f();

  private final Vector3f vectorT2 = new Vector3f();

  private final Point3f pointT2 = new Point3f();

  final static int MAXIMUM_ZOOM_PERCENTAGE = 200000;

  final static int MAXIMUM_ZOOM_PERSPECTIVE_DEPTH = 10000;

  private void setFixedRotationCenter(Point3f center) {

    if (center == null)

      return;

    fixedRotationCenter.set(center);

  }

  void setRotationPointXY(Point3f center) {

    Point3i newCenterScreen = transformPoint(center);

    fixedTranslation.set(newCenterScreen.x, newCenterScreen.y, 0);

  }

  Vector3f rotationAxis = new Vector3f();

  float rotationRate = 0;

  void spinXYBy(int xDelta, int yDelta, float speed) {

    // from mouse action

    if (xDelta == 0 && yDelta == 0) {

      if (spinThread != null && spinThread.isGesture)

        clearSpin();

      return;

    }

    clearSpin();

    Point3f pt1 = new Point3f(fixedRotationCenter);

    Point3f ptScreen = new Point3f();

    transformPoint(pt1, ptScreen);

    Point3f pt2 = new Point3f(-yDelta, xDelta, 0);

    pt2.add(ptScreen);

    unTransformPoint(pt2, pt2);

    viewer.setInMotion(false);

    rotateAboutPointsInternal(pt2, pt1, 10 * speed, Float.NaN, false, true, null, true, null, null);

  }

  final Vector3f arcBall0 = new Vector3f();

  final Vector3f arcBall1 = new Vector3f();

  final Vector3f arcBallAxis = new Vector3f();

  final Matrix3f arcBall0Rotation = new Matrix3f();

  void rotateArcBall(float x, float y, float factor) {

    // radius is half the screen pixel count.

    float radius2 = (screenPixelCount >> 2) * screenPixelCount;

    x -= fixedTranslation.x;

    y -= fixedTranslation.y;

    float z = radius2 - x * x - y * y;

    z = (z < 0 ? -1 : 1) * (float) Math.sqrt(Math.abs(z));

    if (factor == 0) {

      // mouse down sets the initial rotation and point on the sphere

      arcBall0Rotation.set(matrixRotate);

      arcBall0.set(x, -y, z);

      if (!Float.isNaN(z))

        arcBall0.normalize();

      return;

    }

    if (Float.isNaN(arcBall0.z) || Float.isNaN(z))

      return;

    arcBall1.set(x, -y, z);

    arcBall1.normalize();

    arcBallAxis.cross(arcBall0, arcBall1);

    axisangleT.set(arcBallAxis, factor * (float) Math.acos(arcBall0.dot(arcBall1)));

    matrixRotate.set(arcBall0Rotation);

    rotateAxisAngle(axisangleT, null);

  }

  void rotateXYBy(float xDelta, float yDelta, BitSet bsAtoms) {

    // from mouse action

    rotateXRadians(yDelta * JmolConstants.radiansPerDegree, bsAtoms);

    rotateYRadians(xDelta * JmolConstants.radiansPerDegree, bsAtoms);

  }

  void rotateZBy(int zDelta, int x, int y) {

    if (x != Integer.MAX_VALUE && y != Integer.MAX_VALUE)

      resetXYCenter(x, y);

    rotateZRadians((float) (zDelta / degreesPerRadian));

  }

  void rotateFront() {

    matrixRotate.setIdentity();

  }

  void rotateX(float angleRadians) {

    matrixRotate.rotX(angleRadians);

  }

  void rotateY(float angleRadians) {

    matrixRotate.rotY(angleRadians);

  }

  void rotateZ(float angleRadians) {

    matrixRotate.rotZ(angleRadians);

  }

  private void applyRotation(Matrix3f mNew, boolean isInternal, BitSet bsAtoms, Vector3f translation) {

    if (bsAtoms == null) {

      matrixRotate.mul(mNew, matrixRotate);

      return;

    }

    viewer.rotateAtoms(mNew, matrixRotate,

        internalRotationCenter, isInternal, bsAtoms);

    if (translation != null) {

      viewer.setAtomCoordRelative(translation, bsAtoms);

      internalRotationCenter.add(translation);

    }

  }

  synchronized void rotateXRadians(float angleRadians, BitSet bsAtoms) {

    matrixTemp3.rotX(angleRadians);

    applyRotation(matrixTemp3, false, bsAtoms, null);

  }

  synchronized void rotateYRadians(float angleRadians, BitSet bsAtoms) {

    matrixTemp3.rotY(angleRadians);

    applyRotation(matrixTemp3, false, bsAtoms, null);

  }

  synchronized void rotateZRadians(float angleRadians) {

    matrixTemp3.rotZ(angleRadians);

    applyRotation(matrixTemp3, false, null, null);

  }

  protected void rotateAxisAngle(Vector3f rotAxis, float radians) {

    axisangleT.set(rotAxis, radians);

    rotateAxisAngle(axisangleT, null);

  }

  synchronized void rotateAxisAngle(AxisAngle4f axisAngle, BitSet bsAtoms) {

    //matrixTemp3.setIdentity();

    matrixTemp3.set(axisAngle);

    applyRotation(matrixTemp3, false, bsAtoms, null);

  }

  /*

   * *************************************************************** *THE* TWO

   * VIEWER INTERFACE METHODS

   * **************************************************************

   */

  void rotateAxisAngleAtCenter(Point3f rotCenter, Vector3f rotAxis,

                               float degreesPerSecond, float endDegrees,

                               boolean isSpin, BitSet bsAtoms) {

    // *THE* Viewer FIXED frame rotation/spinning entry point

    if (rotCenter != null)

      moveRotationCenter(rotCenter, true);

    setSpinOn(false);

    setNavOn(false);

    if (Float.isNaN(degreesPerSecond) || degreesPerSecond == 0)

      return;

    if (rotCenter != null) {

      setRotationPointXY(rotCenter);

    }

    setFixedRotationCenter(rotCenter);

    rotationAxis.set(rotAxis);

    rotationRate = degreesPerSecond;

    if (isSpin) {

      fixedRotationAxis.set(rotAxis, degreesPerSecond * JmolConstants.radiansPerDegree);

      isSpinInternal = false;

      isSpinFixed = true;

      isSpinSelected = (bsAtoms != null);

      setSpinOn(true, endDegrees, null, bsAtoms, false);

      return;

    }

    float radians = endDegrees * JmolConstants.radiansPerDegree;

    fixedRotationAxis.set(rotAxis, endDegrees);

    rotateAxisAngleRadiansFixed(radians, bsAtoms);

  }

  synchronized void rotateAxisAngleRadiansFixed(float angleRadians,

                                                BitSet bsAtoms) {

    // for spinning -- reduced number of radians

    axisangleT.set(fixedRotationAxis);

    axisangleT.angle = angleRadians;

    rotateAxisAngle(axisangleT, bsAtoms);

  }

  /*

   * *************************************************************** INTERNAL

   * ROTATIONS**************************************************************

   */

  void rotateAboutPointsInternal(Point3f point1, Point3f point2,

                                 float degreesPerSecond, float endDegrees,

                                 boolean isClockwise, boolean isSpin,

                                 BitSet bsAtoms, boolean isGesture,

                                 Vector3f translation, List finalPoints) {

    // *THE* Viewer INTERNAL frame rotation entry point

    setSpinOn(false);

    setNavOn(false);

    if ((translation == null || translation.length() < 0.001)

        && (!isSpin || endDegrees == 0 || Float.isNaN(degreesPerSecond) || degreesPerSecond == 0)

        && (isSpin || endDegrees == 0))

      return;

    Vector3f axis = new Vector3f(point2);

    axis.sub(point1);

    if (isClockwise)

      axis.scale(-1f);

    internalRotationCenter.set(point1);

    rotationAxis.set(axis);

    rotationRate = degreesPerSecond;

    if (translation == null) {

      internalTranslation = null;

    } else {

      internalTranslation = new Vector3f(translation);

      //System.out.println("TM TRANSLATE " + internalTranslation);

    }

    boolean isSelected = (bsAtoms != null);

    if (isSpin) {

      // we need to adjust the degreesPerSecond to match a multiple of the frame rate

      //System.out.println(" ?? " + (spinFps / Math.abs(degreesPerSecond) * Math.abs(endDegrees)));

      int nFrames = (int) (Math.abs(endDegrees) / Math.abs(degreesPerSecond) * spinFps + 0.5);

      if (!Float.isNaN(endDegrees)) {

        rotationRate = degreesPerSecond = endDegrees / nFrames * spinFps;

        //System.out.println("TM nFrames = " + nFrames);

        if (translation != null)

        internalTranslation.scale(1f / (nFrames));

      }

      internalRotationAxis.set(axis, rotationRate

          * JmolConstants.radiansPerDegree);

      isSpinInternal = true;

      isSpinFixed = false;

      isSpinSelected = isSelected;

      setSpinOn(true, endDegrees, finalPoints, bsAtoms, isGesture);

      return;

    }

    float radians = endDegrees * JmolConstants.radiansPerDegree;

    internalRotationAxis.set(axis, radians);

    rotateAxisAngleRadiansInternal(radians, bsAtoms);

  }

  synchronized void rotateAxisAngleRadiansInternal(float radians, BitSet bsAtoms) {

    // final matrix rotation when spinning or just rotating

    // trick is to apply the current rotation to the internal rotation axis

    // and then save the angle for generating a new fixed point later

    internalRotationAngle = radians;

    vectorT.set(internalRotationAxis.x, internalRotationAxis.y,

        internalRotationAxis.z);

    matrixRotate.transform(vectorT, vectorT2);

    axisangleT.set(vectorT2, radians);

    // NOW apply that rotation 

    matrixTemp3.set(axisangleT);

    applyRotation(matrixTemp3, true, bsAtoms, internalTranslation);

    if (bsAtoms == null)

      getNewFixedRotationCenter();

  }

  void getNewFixedRotationCenter() {

    /*

     * (1) determine vector offset VectorT ()

     * (2) translate old point so trueRotationPt is at [0,0,0] (old - true)

     * (3) do axisangle rotation of -radians (pointT2)

     * (4) translate back (pointT2 + vectorT)

     *

     * The new position of old point is the new rotation center

     * set this, rotate about it, and it will APPEAR that the

     * rotation was about the desired point and axis!

     * 

     */

    // fractional OPPOSITE of angle of rotation

    axisangleT.set(internalRotationAxis);

    axisangleT.angle = -internalRotationAngle;

    //this is a fraction of the original for spinning

    matrixTemp4.set(axisangleT);

    // apply this to the fixed center point in the internal frame

    vectorT.set(internalRotationCenter);

    pointT2.set(fixedRotationCenter);

    pointT2.sub(vectorT);

    Point3f pt = new Point3f();

    matrixTemp4.transform(pointT2, pt);

    // return this point to the fixed frame

    pt.add(vectorT);

    // it is the new fixed rotation center!

    setRotationCenterAndRadiusXYZ(pt, false);

  }

  /* ***************************************************************

   * TRANSLATIONS

   ****************************************************************/

  protected final Point3f fixedTranslation = new Point3f();

 

  float xTranslationFraction = 0.5f;

  float yTranslationFraction = 0.5f;

  protected float prevZoomSetting, previousX, previousY;

  void setTranslationFractions() {

    xTranslationFraction = fixedTranslation.x / width;

    yTranslationFraction = fixedTranslation.y / height;

  }

  public void centerAt(int x, int y, Point3f pt) {

    if (pt == null) {

      translateXYBy(x, y);

      return;