Example #1
0
  /**
   * Appends a new keyFrame to the path, with its associated {@code time} (in seconds).
   *
   * <p>When {@code setRef} is {@code false} the keyFrame is added by value, meaning that the path
   * will use the current {@code frame} state.
   *
   * <p>When {@code setRef} is {@code true} the keyFrame is given as a reference to a Frame, which
   * will be connected to the KeyFrameInterpolator: when {@code frame} is modified, the
   * KeyFrameInterpolator path is updated accordingly. This allows for dynamic paths, where keyFrame
   * can be edited, even during the interpolation. {@code null} frame references are silently
   * ignored. The {@link #keyFrameTime(int)} has to be monotonously increasing over keyFrames.
   */
  public void addKeyFrame(GenericFrame frame, float time) {
    if (frame == null) return;

    if (keyFrameList.isEmpty()) interpolationTm = time;

    if ((!keyFrameList.isEmpty()) && (keyFrameList.get(keyFrameList.size() - 1).time() > time))
      System.out.println("Error in KeyFrameInterpolator.addKeyFrame: time is not monotone");
    else {
      if (gScene.is3D()) keyFrameList.add(new KeyFrame3D(frame, time));
      else keyFrameList.add(new KeyFrame2D(frame, time));
    }

    valuesAreValid = false;
    pathIsValid = false;
    currentFrmValid = false;
    resetInterpolation();
  }
Example #2
0
  /** Intenal use. Call {@link #checkValidity()} and if path is not valid recomputes it. */
  protected void updatePath() {
    checkValidity();
    if (!pathIsValid) {
      path.clear();
      int nbSteps = 30;

      if (keyFrameList.isEmpty()) return;

      if (!valuesAreValid) updateModifiedFrameValues();

      if (keyFrameList.get(0) == keyFrameList.get(keyFrameList.size() - 1))
        // TODO experimenting really
        path.add(
            new Frame(
                keyFrameList.get(0).position(),
                keyFrameList.get(0).orientation(),
                keyFrameList.get(0).magnitude()));
      else {
        KeyFrame[] kf = new KeyFrame[4];
        kf[0] = keyFrameList.get(0);
        kf[1] = kf[0];

        int index = 1;
        kf[2] = (index < keyFrameList.size()) ? keyFrameList.get(index) : null;
        index++;
        kf[3] = (index < keyFrameList.size()) ? keyFrameList.get(index) : null;

        while (kf[2] != null) {
          Vec pdiff = Vec.subtract(kf[2].position(), kf[1].position());
          Vec pvec1 = Vec.add(Vec.multiply(pdiff, 3.0f), Vec.multiply(kf[1].tgP(), (-2.0f)));
          pvec1 = Vec.subtract(pvec1, kf[2].tgP());
          Vec pvec2 = Vec.add(Vec.multiply(pdiff, (-2.0f)), kf[1].tgP());
          pvec2 = Vec.add(pvec2, kf[2].tgP());

          for (int step = 0; step < nbSteps; ++step) {
            Frame frame = new Frame();
            float alpha = step / (float) nbSteps;
            frame.setPosition(
                Vec.add(
                    kf[1].position(),
                    Vec.multiply(
                        Vec.add(
                            kf[1].tgP(),
                            Vec.multiply(Vec.add(pvec1, Vec.multiply(pvec2, alpha)), alpha)),
                        alpha)));
            if (gScene.is3D()) {
              frame.setOrientation(
                  Quat.squad(
                      (Quat) kf[1].orientation(),
                      ((KeyFrame3D) kf[1]).tgQ(),
                      ((KeyFrame3D) kf[2]).tgQ(),
                      (Quat) kf[2].orientation(),
                      alpha));
            } else {
              // linear interpolation
              float start = kf[1].orientation().angle();
              float stop = kf[2].orientation().angle();
              frame.setOrientation(new Rot(start + (stop - start) * alpha));
            }
            frame.setMagnitude(Util.lerp(kf[1].magnitude(), kf[2].magnitude(), alpha));
            path.add(frame.get());
          }

          // Shift
          kf[0] = kf[1];
          kf[1] = kf[2];
          kf[2] = kf[3];

          index++;
          kf[3] = (index < keyFrameList.size()) ? keyFrameList.get(index) : null;
        }
        // Add last KeyFrame
        path.add(new Frame(kf[1].position(), kf[1].orientation(), kf[1].magnitude()));
      }
      pathIsValid = true;
    }
  }