/** * Creates a KeyFrameInterpolator, with {@code frame} as associated {@link #frame()}. * * <p>The {@link #frame()} can be set or changed using {@link #setFrame(Frame)}. * * <p>{@link #interpolationTime()}, {@link #interpolationSpeed()} and {@link * #interpolationPeriod()} are set to their default values. */ public KeyFrameInterpolator(AbstractScene scn, Frame frame) { gScene = scn; keyFrameList = new ArrayList<KeyFrame>(); path = new ArrayList<Frame>(); mainFrame = null; period = 40; interpolationTm = 0.0f; interpolationSpd = 1.0f; interpolationStrt = false; lpInterpolation = false; pathIsValid = false; valuesAreValid = true; currentFrmValid = false; setFrame(frame); currentFrame0 = keyFrameList.listIterator(); currentFrame1 = keyFrameList.listIterator(); currentFrame2 = keyFrameList.listIterator(); currentFrame3 = keyFrameList.listIterator(); interpolationTimerTask = new TimingTask() { public void execute() { update(); } }; gScene.registerTimingTask(interpolationTimerTask); }
/** * Appends a new keyFrame to the path. * * <p>Same as {@link #addKeyFrame(GenericFrame, float)}, except that the {@link * #keyFrameTime(int)} is set to the previous {@link #keyFrameTime(int)} plus one second (or 0.0 * if there is no previous keyFrame). */ public void addKeyFrame(GenericFrame frame) { float time; if (keyFrameList.isEmpty()) time = 0.0f; else time = keyFrameList.get(keyFrameList.size() - 1).time() + 1.0f; addKeyFrame(frame, time); }
/** * Remove KeyFrame according to {@code index} in the list and {@link #stopInterpolation()} if * {@link #interpolationStarted()}. If {@code index < 0 || index >= keyFr.size()} the call is * silently ignored. */ public void removeKeyFrame(int index) { if (index < 0 || index >= keyFrameList.size()) return; valuesAreValid = false; pathIsValid = false; currentFrmValid = false; if (interpolationStarted()) stopInterpolation(); KeyFrame kf = keyFrameList.remove(index); for (Agent agent : gScene.inputHandler().agents()) agent.removeGrabber(kf.frm); setInterpolationTime(firstTime()); }
protected void updateSplineCache() { Vec deltaP = Vec.subtract( keyFrameList.get(currentFrame2.nextIndex()).position(), keyFrameList.get(currentFrame1.nextIndex()).position()); pv1 = Vec.add( Vec.multiply(deltaP, 3.0f), Vec.multiply(keyFrameList.get(currentFrame1.nextIndex()).tgP(), (-2.0f))); pv1 = Vec.subtract(pv1, keyFrameList.get(currentFrame2.nextIndex()).tgP()); pv2 = Vec.add(Vec.multiply(deltaP, (-2.0f)), keyFrameList.get(currentFrame1.nextIndex()).tgP()); pv2 = Vec.add(pv2, keyFrameList.get(currentFrame2.nextIndex()).tgP()); splineCacheIsValid = true; }
protected void updateModifiedFrameValues() { KeyFrame kf; KeyFrame prev = keyFrameList.get(0); kf = keyFrameList.get(0); int index = 1; while (kf != null) { KeyFrame next = (index < keyFrameList.size()) ? keyFrameList.get(index) : null; index++; if (next != null) kf.computeTangent(prev, next); else kf.computeTangent(prev, kf); prev = kf; kf = next; } valuesAreValid = true; }
/** Removes all keyFrames from the path. The {@link #numberOfKeyFrames()} is set to 0. */ public void deletePath() { stopInterpolation(); keyFrameList.clear(); pathIsValid = false; valuesAreValid = false; currentFrmValid = false; }
/** * Returns the Frame associated with the keyFrame at index {@code index}. * * <p>See also {@link #keyFrameTime(int)}. {@code index} has to be in the range 0..{@link * #numberOfKeyFrames()}-1. * * <p><b>Note:</b> If this keyFrame was defined using a reference to a Frame (see {@link * #addKeyFrame(GenericFrame, float)} the current referenced Frame state is returned. */ public GenericFrame keyFrame(int index) { /** * AbstractKeyFrame kf = keyFr.get(index); return new Frame(kf.orientation(), kf.position(), * kf.magnitude()); */ return keyFrameList.get(index).frame(); }
protected KeyFrameInterpolator(KeyFrameInterpolator otherKFI) { this.gScene = otherKFI.gScene; this.path = new ArrayList<Frame>(); ListIterator<Frame> frameIt = otherKFI.path.listIterator(); while (frameIt.hasNext()) { this.path.add(frameIt.next().get()); } this.setFrame(otherKFI.frame()); this.period = otherKFI.period; this.interpolationTm = otherKFI.interpolationTm; this.interpolationSpd = otherKFI.interpolationSpd; this.interpolationStrt = otherKFI.interpolationStrt; this.lpInterpolation = otherKFI.lpInterpolation; this.pathIsValid = otherKFI.pathIsValid; this.valuesAreValid = otherKFI.valuesAreValid; this.currentFrmValid = otherKFI.currentFrmValid; this.keyFrameList = new ArrayList<KeyFrame>(); for (KeyFrame element : otherKFI.keyFrameList) { KeyFrame kf = (KeyFrame) element.get(); this.keyFrameList.add(kf); } this.currentFrame0 = keyFrameList.listIterator(otherKFI.currentFrame0.nextIndex()); this.currentFrame1 = keyFrameList.listIterator(otherKFI.currentFrame1.nextIndex()); this.currentFrame2 = keyFrameList.listIterator(otherKFI.currentFrame2.nextIndex()); this.currentFrame3 = keyFrameList.listIterator(otherKFI.currentFrame3.nextIndex()); this.interpolationTimerTask = new TimingTask() { public void execute() { update(); } }; gScene.registerTimingTask(interpolationTimerTask); this.invalidateValues(); }
/** * Starts the interpolation process. * * <p>A timer is started with an {@link #interpolationPeriod()} period that updates the {@link * #frame()}'s position, orientation and magnitude. {@link #interpolationStarted()} will return * {@code true} until {@link #stopInterpolation()} or {@link #toggleInterpolation()} is called. * * <p>If {@code period} is positive, it is set as the new {@link #interpolationPeriod()}. The * previous {@link #interpolationPeriod()} is used otherwise (default). * * <p>If {@link #interpolationTime()} is larger than {@link #lastTime()}, {@link * #interpolationTime()} is reset to {@link #firstTime()} before interpolation starts (and * inversely for negative {@link #interpolationSpeed()}. * * <p>Use {@link #setInterpolationTime(float)} before calling this method to change the starting * {@link #interpolationTime()}. * * <p><b>Attention:</b> The keyFrames must be defined (see {@link #addKeyFrame(GenericFrame, * float)}) before you startInterpolation(), or else the interpolation will naturally immediately * stop. */ public void startInterpolation(int myPeriod) { if (myPeriod >= 0) setInterpolationPeriod(myPeriod); if (!keyFrameList.isEmpty()) { if ((interpolationSpeed() > 0.0) && (interpolationTime() >= keyFrameList.get(keyFrameList.size() - 1).time())) setInterpolationTime(keyFrameList.get(0).time()); if ((interpolationSpeed() < 0.0) && (interpolationTime() <= keyFrameList.get(0).time())) setInterpolationTime(keyFrameList.get(keyFrameList.size() - 1).time()); if (keyFrameList.size() > 1) interpolationTimerTask.run(interpolationPeriod()); interpolationStrt = true; update(); } }
protected void updateCurrentKeyFrameForTime(float time) { // Assertion: times are sorted in monotone order. // Assertion: keyFrame_ is not empty // TODO: Special case for loops when closed path is implemented !! if (!currentFrmValid) // Recompute everything from scratch currentFrame1 = keyFrameList.listIterator(); // currentFrame_[1]->peekNext() <---> keyFr.get(currentFrame1.nextIndex()); while (keyFrameList.get(currentFrame1.nextIndex()).time() > time) { currentFrmValid = false; if (!currentFrame1.hasPrevious()) break; currentFrame1.previous(); } if (!currentFrmValid) currentFrame2 = keyFrameList.listIterator(currentFrame1.nextIndex()); while (keyFrameList.get(currentFrame2.nextIndex()).time() < time) { currentFrmValid = false; if (!currentFrame2.hasNext()) break; currentFrame2.next(); } if (!currentFrmValid) { currentFrame1 = keyFrameList.listIterator(currentFrame2.nextIndex()); if ((currentFrame1.hasPrevious()) && (time < keyFrameList.get(currentFrame2.nextIndex()).time())) currentFrame1.previous(); currentFrame0 = keyFrameList.listIterator(currentFrame1.nextIndex()); if (currentFrame0.hasPrevious()) currentFrame0.previous(); currentFrame3 = keyFrameList.listIterator(currentFrame2.nextIndex()); if (currentFrame3.hasNext()) currentFrame3.next(); currentFrmValid = true; splineCacheIsValid = false; } }
/** * 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(); }
/** * Interpolate {@link #frame()} at time {@code time} (expressed in seconds). {@link * #interpolationTime()} is set to {@code time} and {@link #frame()} is set accordingly. * * <p>If you simply want to change {@link #interpolationTime()} but not the {@link #frame()} * state, use {@link #setInterpolationTime(float)} instead. */ public void interpolateAtTime(float time) { this.checkValidity(); setInterpolationTime(time); if ((keyFrameList.isEmpty()) || (frame() == null)) return; if (!valuesAreValid) updateModifiedFrameValues(); updateCurrentKeyFrameForTime(time); if (!splineCacheIsValid) updateSplineCache(); float alpha; float dt = keyFrameList.get(currentFrame2.nextIndex()).time() - keyFrameList.get(currentFrame1.nextIndex()).time(); if (Util.zero(dt)) alpha = 0.0f; else alpha = (time - keyFrameList.get(currentFrame1.nextIndex()).time()) / dt; Vec pos = Vec.add( keyFrameList.get(currentFrame1.nextIndex()).position(), Vec.multiply( Vec.add( keyFrameList.get(currentFrame1.nextIndex()).tgP(), Vec.multiply(Vec.add(pv1, Vec.multiply(pv2, alpha)), alpha)), alpha)); float mag = Util.lerp( keyFrameList.get(currentFrame1.nextIndex()).magnitude(), keyFrameList.get(currentFrame2.nextIndex()).magnitude(), alpha); Rotation q; if (gScene.is3D()) { q = Quat.squad( (Quat) keyFrameList.get(currentFrame1.nextIndex()).orientation(), ((KeyFrame3D) keyFrameList.get(currentFrame1.nextIndex())).tgQ(), ((KeyFrame3D) keyFrameList.get(currentFrame2.nextIndex())).tgQ(), (Quat) keyFrameList.get(currentFrame2.nextIndex()).orientation(), alpha); } else { q = new Rot( Util.lerp( keyFrameList.get(currentFrame1.nextIndex()).orientation().angle(), keyFrameList.get(currentFrame2.nextIndex()).orientation().angle(), (alpha))); } frame().setPositionWithConstraint(pos); frame().setRotationWithConstraint(q); frame().setMagnitude(mag); }
/** * Returns the number of keyFrames used by the interpolation. Use {@link * #addKeyFrame(GenericFrame)} to add new keyFrames. */ public int numberOfKeyFrames() { return keyFrameList.size(); }
/** * Returns the time corresponding to the last keyFrame, expressed in seconds. * * <p> * * @see #firstTime() * @see #duration() * @see #keyFrameTime(int) */ public float lastTime() { if (keyFrameList.isEmpty()) return 0.0f; else return keyFrameList.get(keyFrameList.size() - 1).time(); }
/** * Returns the time corresponding to the first keyFrame, expressed in seconds. * * <p>Returns 0.0 if the path is empty. * * @see #lastTime() * @see #duration() * @see #keyFrameTime(int) */ public float firstTime() { if (keyFrameList.isEmpty()) return 0.0f; else return keyFrameList.get(0).time(); }
/** * Returns the time corresponding to the {@code index} keyFrame. index has to be in the range 0.. * {@link #numberOfKeyFrames()}-1. * * @see #keyFrame(int) */ public float keyFrameTime(int index) { return keyFrameList.get(index).time(); }
/** 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; } }
/** * Updates {@link #frame()} state according to current {@link #interpolationTime()}. Then adds * {@link #interpolationPeriod()}* {@link #interpolationSpeed()} to {@link #interpolationTime()}. * * <p>This internal method is called by a timer when {@link #interpolationStarted()}. It can be * used for debugging purpose. {@link #stopInterpolation()} is called when {@link * #interpolationTime()} reaches {@link #firstTime()} or {@link #lastTime()}, unless {@link * #loopInterpolation()} is {@code true}. */ protected void update() { interpolateAtTime(interpolationTime()); interpolationTm += interpolationSpeed() * interpolationPeriod() / 1000.0f; if (interpolationTime() > keyFrameList.get(keyFrameList.size() - 1).time()) { if (loopInterpolation()) setInterpolationTime( keyFrameList.get(0).time() + interpolationTm - keyFrameList.get(keyFrameList.size() - 1).time()); else { // Make sure last KeyFrame is reached and displayed interpolateAtTime(keyFrameList.get(keyFrameList.size() - 1).time()); stopInterpolation(); } } else if (interpolationTime() < keyFrameList.get(0).time()) { if (loopInterpolation()) setInterpolationTime( keyFrameList.get(keyFrameList.size() - 1).time() - keyFrameList.get(0).time() + interpolationTm); else { // Make sure first KeyFrame is reached and displayed interpolateAtTime(keyFrameList.get(0).time()); stopInterpolation(); } } }