@Override
 public void compute(ProcessorArmingCollection collection) {
   degrees += increment;
   quaternion.fromAngles(0.0f, degrees, 0.0f);
   quaternion.mult(up, upOut);
   quaternion.mult(position, positionOut);
 }
  protected void handleRotate(Vector3f start, Vector3f end, float direction) {
    LOGGER.warning(
        "Handling rotate, start: "
            + start
            + ""
            + "\nlast: "
            + lastTranslation
            + ""
            + "\nend: "
            + end);
    Vector3f increment = end.subtract(lastTranslation);
    increment.y = 0;
    float length = increment.length();
    float magic = 3f; // ~ 180 degrees
    float percent = length / magic;

    // if the difference is negative, we need to rotate in the opposite
    // direction. Caclulate the difference after taking into account
    // the direction of the camera
    //        CellTransform viewTransform = ViewManager.getViewManager().getCameraTransform();
    //        Quaternion viewRotation = viewTransform.getRotation(null);
    //        increment = viewRotation.mult(increment);
    //
    //        LOGGER.warning("viewTransform: " + viewTransform + ", increment: " +
    //                       increment);
    //
    //        if (increment.x < 0 || increment.z < 0) {
    //            percent = -percent;
    //        }

    // take direction into account
    percent *= direction;

    Quaternion rotation = new Quaternion();
    rotation.fromAngles(0f, percent * FastMath.PI, 0f);

    // rotation is the total rotation since we started moving the mouse,
    // so calculate just the delta to apply
    Quaternion deltaRotation = rotation.mult(lastRotation.inverse());

    LOGGER.warning(
        "Percent: "
            + percent
            + " = "
            + toAnglesString(rotation)
            + ". Last = "
            + toAnglesString(lastRotation)
            + ". Delta = "
            + toAnglesString(deltaRotation));

    applyDelta(Vector3f.ZERO, deltaRotation);
  }
  public ModulatorThreeNodes(
      ModulatorRenderer Renderer, String node1Name, String node2Name, String node3Name) {
    renderer = Renderer;
    rotFinal.fromAngles(0.0f, 0.0f, 0.0f);

    node1theSpatial = renderer.getNode(node1Name);

    System.out.println("node1theSpatial = " + node1theSpatial);
    al = node1theSpatial.getControllers();

    Tco = node1theSpatial.getController(0);
    //        float max = Tco.getMaxTime();
    //        float min = Tco.getMinTime();

    Tac = (AnimationController) Tco;
    Tani = Tac.getAnimation(0);
    Tkft = Tani.getKeyFrameTimes();
    if (traceLoad) System.out.println("node1Tkft size = " + Tkft.length);

    // Make storage for the transforms at each keyframe

    transX = new float[Tkft.length];
    transY = new float[Tkft.length];
    transZ = new float[Tkft.length];
    angleX = new float[Tkft.length];
    angleY = new float[Tkft.length];
    angleZ = new float[Tkft.length];
    // Make storage for the Quats that will hold the rotates at each keyframe
    node1keyFrames = new Quaternion[Tkft.length];
    // and the vectors that will hold the translates
    node1keyTrans = new Vector3f[Tkft.length];

    // There wil be multiple animations for the same node. Each animation will express one (?) of
    // the
    // directions of rotation or one of the directions of translation, or combinations. All the
    // rotations
    // for a key frame combined together will be the full rotation. All the translations for a key
    // frame
    // summed together will be the total translation for the key frame. Scaling should have the same
    // structure
    // when I get it added.
    // The result of all this will be a series of Quaternions, one for each key frame start and one
    // to finish
    // that contain the rotations for each keyframe. Also, there will be a set of vectors that
    // contain
    // the translations.

    // Step through the animation controllers to pick up the changes at each key frame
    for (int k = 0; k < al.size(); k++) {
      if (traceLoad) System.out.println("Controller = " + al.get(k).toString());

      // Get the controller and then cast it to an animation controller
      Controller co = node1theSpatial.getController(k);
      AnimationController ac = (AnimationController) co;
      // Get the animations for this controller
      ArrayList bans = ac.getAnimations();
      // Step through the animations
      for (int i = 0; i < bans.size(); i++) {
        // Get this animation
        BoneAnimation ani = ac.getAnimation(i);
        // Get the frame times for this animation
        float kft[] = ani.getKeyFrameTimes();
        if (traceLoad) {
          System.out.println("kft size = " + kft.length);

          for (int j = 0; j < kft.length; j++) {
            System.out.println("kft - " + kft[j]);
          }
        }
        ArrayList<BoneTransform> bt = ani.getBoneTransforms();
        if (traceLoad) {
          System.out.println("bt size = " + bt.size());
          for (int j = 0; j < bt.size(); j++) {
            System.out.println("bt = " + bt.get(j).toString());
          }
        }
        Quaternion qt[] = bt.get(0).getRotations();
        if (traceLoad) System.out.println("bt - rotations = " + qt.length);

        for (int j = 0; j < qt.length; j++) {
          if (traceLoad) System.out.println("rots = " + qt[j]);
          float[] fromAngles = qt[j].toAngles(null);
          if (traceLoad)
            System.out.println(
                "Angles - " + fromAngles[0] + " - " + fromAngles[1] + " - " + fromAngles[2]);

          angleX[j] = angleX[j] + fromAngles[0];
          angleY[j] = angleY[j] + fromAngles[1];
          angleZ[j] = angleZ[j] + fromAngles[2];
        }
        if (traceLoad)
          System.out.println(
              " start frame = " + ani.getStartFrame() + " - end frame = " + ani.getEndFrame());
        Vector3f v3f[] = bt.get(0).getTranslations();
        if (traceLoad) System.out.println("bt - translations = " + v3f.length);

        for (int j = 0; j < v3f.length; j++) {
          if (traceLoad) System.out.println("trans = " + v3f[j]);
          transX[j] = transX[j] + v3f[j].x;
          transY[j] = transY[j] + v3f[j].y;
          transZ[j] = transZ[j] + v3f[j].z;
        }
      }
    }
    // Build the final key frame Quats from the extracted angles and the Vectors from the extracted
    // translates
    for (int j = 0; j < Tkft.length; j++) {
      Quaternion temp = null;
      temp = new Quaternion();
      temp.fromAngles(angleX[j], angleY[j], angleZ[j]);
      if (traceLoad)
        System.out.println(
            " ********************** final angles "
                + angleX[j]
                + "--"
                + angleY[j]
                + "--"
                + angleZ[j]);
      node1keyFrames[j] = temp;
      node1keyTrans[j] = new Vector3f(transX[j], transY[j], transZ[j]);
      if (traceLoad)
        System.out.println(
            " *************** final translations "
                + transX[j]
                + " - "
                + transY[j]
                + " - "
                + transZ[j]);
    }

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

    node2theSpatial = renderer.getNode(node2Name);

    System.out.println("theSpatial = " + node2theSpatial);
    al = node2theSpatial.getControllers();

    Tco = node2theSpatial.getController(0);
    //        float max = Tco.getMaxTime();
    //        float min = Tco.getMinTime();

    Tac = (AnimationController) Tco;
    Tani = Tac.getAnimation(0);
    Tkft = Tani.getKeyFrameTimes();
    if (traceLoad) System.out.println("node2Tkft size = " + Tkft.length);

    // Make storage for the transforms at each keyframe

    transX = new float[Tkft.length];
    transY = new float[Tkft.length];
    transZ = new float[Tkft.length];
    angleX = new float[Tkft.length];
    angleY = new float[Tkft.length];
    angleZ = new float[Tkft.length];
    // Make storage for the Quats that will hold the rotates at each keyframe
    node2keyFrames = new Quaternion[Tkft.length];
    // and the vectors that will hold the translates
    node2keyTrans = new Vector3f[Tkft.length];

    // There wil be multiple animations for the same node. Each animation will express one (?) of
    // the
    // directions of rotation or one of the directions of translation, or combinations. All the
    // rotations
    // for a key frame combined together will be the full rotation. All the translations for a key
    // frame
    // summed together will be the total translation for the key frame. Scaling should have the same
    // structure
    // when I get it added.
    // The result of all this will be a series of Quaternions, one for each key frame start and one
    // to finish
    // that contain the rotations for each keyframe. Also, there will be a set of vectors that
    // contain
    // the translations.

    // Step through the animation controllers to pick up the changes at each key frame
    for (int k = 0; k < al.size(); k++) {
      if (traceLoad) System.out.println("Controller = " + al.get(k).toString());

      // Get the controller and then cast it to an animation controller
      Controller co = node2theSpatial.getController(k);
      AnimationController ac = (AnimationController) co;
      // Get the animations for this controller
      ArrayList bans = ac.getAnimations();
      // Step through the animations
      for (int i = 0; i < bans.size(); i++) {
        // Get this animation
        BoneAnimation ani = ac.getAnimation(i);
        // Get the frame times for this animation
        float kft[] = ani.getKeyFrameTimes();
        if (traceLoad) {
          System.out.println("kft size = " + kft.length);

          for (int j = 0; j < kft.length; j++) {
            System.out.println("kft - " + kft[j]);
          }
        }
        ArrayList<BoneTransform> bt = ani.getBoneTransforms();
        if (traceLoad) {
          System.out.println("bt size = " + bt.size());
          for (int j = 0; j < bt.size(); j++) {
            System.out.println("bt = " + bt.get(j).toString());
          }
        }
        Quaternion qt[] = bt.get(0).getRotations();
        if (traceLoad) System.out.println("bt - rotations = " + qt.length);

        for (int j = 0; j < qt.length; j++) {
          if (traceLoad) System.out.println("rots = " + qt[j]);
          float[] fromAngles = qt[j].toAngles(null);
          if (traceLoad)
            System.out.println(
                "Angles - " + fromAngles[0] + " - " + fromAngles[1] + " - " + fromAngles[2]);

          angleX[j] = angleX[j] + fromAngles[0];
          angleY[j] = angleY[j] + fromAngles[1];
          angleZ[j] = angleZ[j] + fromAngles[2];
        }
        if (traceLoad)
          System.out.println(
              " start frame = " + ani.getStartFrame() + " - end frame = " + ani.getEndFrame());
        Vector3f v3f[] = bt.get(0).getTranslations();
        if (traceLoad) System.out.println("bt - translations = " + v3f.length);

        for (int j = 0; j < v3f.length; j++) {
          if (traceLoad) System.out.println("trans = " + v3f[j]);
          transX[j] = transX[j] + v3f[j].x;
          transY[j] = transY[j] + v3f[j].y;
          transZ[j] = transZ[j] + v3f[j].z;
        }
      }
    }
    // Build the final key frame Quats from the extracted angles and the Vectors from the extracted
    // translates
    for (int j = 0; j < Tkft.length; j++) {
      Quaternion temp = null;
      temp = new Quaternion();
      temp.fromAngles(angleX[j], angleY[j], angleZ[j]);
      if (traceLoad)
        System.out.println(
            " ********************** final angles "
                + angleX[j]
                + "--"
                + angleY[j]
                + "--"
                + angleZ[j]);
      node2keyFrames[j] = temp;
      node2keyTrans[j] = new Vector3f(transX[j], transY[j], transZ[j]);
      if (traceLoad)
        System.out.println(
            " *************** final translations "
                + transX[j]
                + " - "
                + transY[j]
                + " - "
                + transZ[j]);
    }

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

    node3theSpatial = renderer.getNode(node3Name);

    System.out.println("node3theSpatial = " + node3theSpatial);
    al = node3theSpatial.getControllers();

    Tco = node3theSpatial.getController(0);
    //        float max = Tco.getMaxTime();
    //        float min = Tco.getMinTime();

    Tac = (AnimationController) Tco;
    Tani = Tac.getAnimation(0);
    Tkft = Tani.getKeyFrameTimes();
    if (traceLoad) System.out.println("node3Tkft size = " + Tkft.length);

    // Make storage for the transforms at each keyframe

    transX = new float[Tkft.length];
    transY = new float[Tkft.length];
    transZ = new float[Tkft.length];
    angleX = new float[Tkft.length];
    angleY = new float[Tkft.length];
    angleZ = new float[Tkft.length];
    // Make storage for the Quats that will hold the rotates at each keyframe
    node3keyFrames = new Quaternion[Tkft.length];
    // and the vectors that will hold the translates
    node3keyTrans = new Vector3f[Tkft.length];

    // There wil be multiple animations for the same node. Each animation will express one (?) of
    // the
    // directions of rotation or one of the directions of translation, or combinations. All the
    // rotations
    // for a key frame combined together will be the full rotation. All the translations for a key
    // frame
    // summed together will be the total translation for the key frame. Scaling should have the same
    // structure
    // when I get it added.
    // The result of all this will be a series of Quaternions, one for each key frame start and one
    // to finish
    // that contain the rotations for each keyframe. Also, there will be a set of vectors that
    // contain
    // the translations.

    // Step through the animation controllers to pick up the changes at each key frame
    for (int k = 0; k < al.size(); k++) {
      if (traceLoad) System.out.println("Controller = " + al.get(k).toString());

      // Get the controller and then cast it to an animation controller
      Controller co = node3theSpatial.getController(k);
      AnimationController ac = (AnimationController) co;
      // Get the animations for this controller
      ArrayList bans = ac.getAnimations();
      // Step through the animations
      for (int i = 0; i < bans.size(); i++) {
        // Get this animation
        BoneAnimation ani = ac.getAnimation(i);
        // Get the frame times for this animation
        float kft[] = ani.getKeyFrameTimes();
        if (traceLoad) {
          System.out.println("kft size = " + kft.length);

          for (int j = 0; j < kft.length; j++) {
            System.out.println("kft - " + kft[j]);
          }
        }
        ArrayList<BoneTransform> bt = ani.getBoneTransforms();
        if (traceLoad) {
          System.out.println("bt size = " + bt.size());
          for (int j = 0; j < bt.size(); j++) {
            System.out.println("bt = " + bt.get(j).toString());
          }
        }
        Quaternion qt[] = bt.get(0).getRotations();
        if (traceLoad) System.out.println("bt - rotations = " + qt.length);

        for (int j = 0; j < qt.length; j++) {
          if (traceLoad) System.out.println("rots = " + qt[j]);
          float[] fromAngles = qt[j].toAngles(null);
          if (traceLoad)
            System.out.println(
                "Angles - " + fromAngles[0] + " - " + fromAngles[1] + " - " + fromAngles[2]);

          angleX[j] = angleX[j] + fromAngles[0];
          angleY[j] = angleY[j] + fromAngles[1];
          angleZ[j] = angleZ[j] + fromAngles[2];
        }
        if (traceLoad)
          System.out.println(
              " start frame = " + ani.getStartFrame() + " - end frame = " + ani.getEndFrame());
        Vector3f v3f[] = bt.get(0).getTranslations();
        if (traceLoad) System.out.println("bt - translations = " + v3f.length);

        for (int j = 0; j < v3f.length; j++) {
          if (traceLoad) System.out.println("trans = " + v3f[j]);
          transX[j] = transX[j] + v3f[j].x;
          transY[j] = transY[j] + v3f[j].y;
          transZ[j] = transZ[j] + v3f[j].z;
        }
      }
    }
    // Build the final key frame Quats from the extracted angles and the Vectors from the extracted
    // translates
    for (int j = 0; j < Tkft.length; j++) {
      Quaternion temp = null;
      temp = new Quaternion();
      temp.fromAngles(angleX[j], angleY[j], angleZ[j]);
      if (traceLoad)
        System.out.println(
            " ********************** final angles "
                + angleX[j]
                + "--"
                + angleY[j]
                + "--"
                + angleZ[j]);
      node3keyFrames[j] = temp;
      node3keyTrans[j] = new Vector3f(transX[j], transY[j], transZ[j]);
      if (traceLoad)
        System.out.println(
            " *************** final translations "
                + transX[j]
                + " - "
                + transY[j]
                + " - "
                + transZ[j]);
    }
  }
  public void animateNode() {
    Vector3f v3f;

    int startFrame = 0;
    int endFrame = 0;
    float zRotationInc = 0.0f;
    float xRotationInc = 0.0f;

    System.out.println("animateNode");

    v3f = node1theSpatial.getLocalTranslation();
    System.out.println("Before animation - " + v3f + " - After last run = " + v3fFinal);

    node1result = new TimelineScenario.Sequence();
    // Add each key frame info as an animation and then play the whole
    if (animationStartKeyframe == 0 && animationEndKeyframe == 0) {
      startFrame = 0;
      endFrame = Tkft.length - 1;
    } else {
      startFrame = animationStartKeyframe;
      endFrame = animationEndKeyframe - 1;
    }

    for (int j = startFrame; j < endFrame; j++) {
      t = new Timeline(this);
      // *******************************************  Node 1
      float[] fromAngles = node1keyFrames[j].toAngles(null);
      float[] fromAnglesNext = node1keyFrames[j + 1].toAngles(null);

      float[] rotFinalAngles = rotFinal.toAngles(null);

      Quaternion quat = new Quaternion();
      quat.fromAngles(
          //                    fromAngles[0] + rotFinalAngles[0] + animationStartRotation[0],
          //                    fromAngles[1] + rotFinalAngles[1] + animationStartRotation[1],
          //                    fromAngles[2] + rotFinalAngles[2] + animationStartRotation[2]);
          fromAngles[0] + animationStartRotation[0],
          fromAngles[1] + rotFinalAngles[1] + animationStartRotation[1],
          fromAngles[2] + animationStartRotation[2]);
      Quaternion quatNext = new Quaternion();
      quatNext.fromAngles(
          //                    fromAnglesNext[0] + rotFinalAngles[0] + animationStartRotation[0],
          //                    fromAnglesNext[1] + rotFinalAngles[1] + animationStartRotation[1],
          //                    fromAnglesNext[2] + rotFinalAngles[2] + animationStartRotation[2]);
          fromAnglesNext[0] + animationStartRotation[0],
          fromAnglesNext[1] + rotFinalAngles[1] + animationStartRotation[1],
          fromAnglesNext[2] + animationStartRotation[2]);
      //            System.out.println("rots - x = " +
      //                    (fromAngles[0] + rotFinalAngles[0] + animationStartRotation[0]) + " - y
      // = " +
      //                    (fromAngles[1] + rotFinalAngles[1] + animationStartRotation[1]) + " - z
      // = " +
      //                    (fromAngles[2] + rotFinalAngles[2] + animationStartRotation[2]));

      t.addPropertyToInterpolate(
          "Node1Quat", quat, quatNext, new ModulatorQuaternionInterpolator());

      ////            t.addPropertyToInterpolate("Node1Quat", node1keyFrames[j], node1keyFrames[j +
      // 1], new ModulatorQuaternionInterpolator());

      zRotationInc = (float) Math.sin(animationStartRotation[1]);
      xRotationInc = (float) Math.cos(animationStartRotation[1]);

      if (v3fFinal.x == 0.0f && v3fFinal.y == 0.0 && v3fFinal.z == 0.0) {
        Vector3f tempVec =
            new Vector3f(
                (node1keyTrans[j].x + animationStartTranslate.x),
                (node1keyTrans[j].y + animationStartTranslate.y),
                (node1keyTrans[j].z + animationStartTranslate.z));
        Vector3f tempVecPlus =
            new Vector3f(
                (node1keyTrans[j + 1].x + animationStartTranslate.x),
                (node1keyTrans[j + 1].y + animationStartTranslate.y),
                (node1keyTrans[j + 1].z + animationStartTranslate.z));
        //                System.out.println("x = " +
        //                        (node1keyTrans[j].x + animationStartTranslate.x) + " - y = " +
        //                        (node1keyTrans[j].y + animationStartTranslate.y) + " - z = " +
        //                        (node1keyTrans[j].z + animationStartTranslate.z));
        t.addPropertyToInterpolate(
            "Node1Trans", tempVec, tempVecPlus, new ModulatorVectorInterpolator());
      } else {
        Vector3f tempVec =
            new Vector3f(
                node1keyTrans[j].x
                    + v3fFinal.x
                    + (node1keyTrans[j].x * (float) Math.sin(rotFinalAngles[1])),
                node1keyTrans[j].y + v3fFinal.y,
                node1keyTrans[j].z
                    + v3fFinal.z
                    + (node1keyTrans[j].z * (float) Math.cos(rotFinalAngles[1])));
        Vector3f tempVecPlus =
            new Vector3f(
                node1keyTrans[j + 1].x
                    + v3fFinal.x
                    + (node1keyTrans[j + 1].x * (float) Math.sin(rotFinalAngles[1])),
                node1keyTrans[j + 1].y + v3fFinal.y,
                node1keyTrans[j + 1].z
                    + v3fFinal.z
                    + (node1keyTrans[j + 1].z * (float) Math.cos(rotFinalAngles[1])));
        //                System.out.println("final - x = " +
        //                        (node1keyTrans[j].x + v3fFinal.x + (node1keyTrans[j].x *
        // (float)Math.sin(rotFinalAngles[1]))) + " - y = " +
        //                        (node1keyTrans[j].y + v3fFinal.y) + " - z = " +
        //                        (node1keyTrans[j].z + v3fFinal.z + (node1keyTrans[j].z *
        // (float)Math.cos(rotFinalAngles[1]))));
        t.addPropertyToInterpolate(
            "Node1Trans", tempVec, tempVecPlus, new ModulatorVectorInterpolator());
      }
      if (j == endFrame - 1) {
        t.addCallback(
            new TimelineCallback() {

              public void onTimelineDone() {
                Vector3f v3f = node1theSpatial.getLocalTranslation();
                System.out.println("After animation from timeline done - " + v3f);
              }

              public void onTimelineStateChanged(
                  TimelineState oldState, TimelineState newState, float arg2, float arg3) {
                if (newState == TimelineState.DONE) {
                  if (animationSaveTransform) {
                    v3fFinal = node1theSpatial.getLocalTranslation();
                    rotFinal = node1theSpatial.getLocalRotation();
                  }
                  System.out.println("After animation - " + v3fFinal);
                  ClientContext.getInputManager()
                      .postEvent(new IntercellEvent("F", animationIceCode));
                }
              }

              public void onTimelinePulse(float arg0, float arg1) {}
            });
      }

      ////            t.addPropertyToInterpolate("Node1Trans", node1keyTrans[j], node1keyTrans[j +
      // 1], new ModulatorVectorInterpolator());
      //        t.setEase(new Spline(0.4f));
      t.setDuration((long) ((Tkft[j + 1] - Tkft[j]) * 1000) * animationTimeMultiplier);
      node1result.addScenarioActor(t);
    }

    node2result = new TimelineScenario.Sequence();
    // ***************************************** Node 2
    // Add each key frame info as an animation and then play the whole
    for (int j = startFrame; j < endFrame; j++) {
      t = new Timeline(this);
      t.addPropertyToInterpolate(
          "Node2Quat",
          node2keyFrames[j],
          node2keyFrames[j + 1],
          new ModulatorQuaternionInterpolator());

      ///            Vector3f tempVec = new Vector3f(node2keyTrans[j].x + animationStartTranslate.x,
      // node2keyTrans[j].y + animationStartTranslate.y, node2keyTrans[j].z +
      // animationStartTranslate.z);
      ///            Vector3f tempVecPlus = new Vector3f(node2keyTrans[j + 1].x +
      // animationStartTranslate.x, node2keyTrans[j + 1].y + animationStartTranslate.y,
      // node2keyTrans[j + 1].z + animationStartTranslate.z);
      ///            t.addPropertyToInterpolate("Node2Trans", tempVec, tempVecPlus, new
      // ModulatorVectorInterpolator());
      /// System.out.println("node2 - orig y = " + node2keyTrans[j].y + " - shift - " + tempVec.y);
      t.addPropertyToInterpolate(
          "Node2Trans", node2keyTrans[j], node2keyTrans[j + 1], new ModulatorVectorInterpolator());
      //        t.setEase(new Spline(0.4f));
      t.setDuration((long) ((Tkft[j + 1] - Tkft[j]) * 1000) * animationTimeMultiplier);
      node2result.addScenarioActor(t);
    }

    node3result = new TimelineScenario.Sequence();
    // *******************************************************  Node 3
    // Add each key frame info as an animation and then play the whole
    for (int j = startFrame; j < endFrame; j++) {
      t = new Timeline(this);
      t.addPropertyToInterpolate(
          "Node3Quat",
          node3keyFrames[j],
          node3keyFrames[j + 1],
          new ModulatorQuaternionInterpolator());

      ///            Vector3f tempVec = new Vector3f(node3keyTrans[j].x + animationStartTranslate.x,
      // node3keyTrans[j].y + animationStartTranslate.y, node3keyTrans[j].z +
      // animationStartTranslate.z);
      ///            Vector3f tempVecPlus = new Vector3f(node3keyTrans[j + 1].x +
      // animationStartTranslate.x, node3keyTrans[j + 1].y + animationStartTranslate.y,
      // node3keyTrans[j + 1].z + animationStartTranslate.z);
      ///            t.addPropertyToInterpolate("Node3Trans", tempVec, tempVecPlus, new
      // ModulatorVectorInterpolator());
      /// System.out.println("node3 - orig y = " + node3keyTrans[j].y + " - shift - " + tempVec.y);
      t.addPropertyToInterpolate(
          "Node3Trans", node3keyTrans[j], node3keyTrans[j + 1], new ModulatorVectorInterpolator());
      //        t.setEase(new Spline(0.4f));
      t.setDuration((long) ((Tkft[j + 1] - Tkft[j]) * 1000) * animationTimeMultiplier);
      node3result.addScenarioActor(t);
    }

    node1result.play();
    node2result.play();
    node3result.play();
  }