15.10. Track Follower Engine

SoEngine
- SoTrackFollower

Figure 15.12. Track follower engine class

The SoTrackFollower⁽^C++^|^Java^|^.NET⁾ engine interpolates between positions to generate animations in Open Inventor.

The main input fields are a collection of points (points), which define a track to be followed, and an interpolation value (alpha) which must vary between 0 and 1 in order to determine the outputs. The two outputs are a position (position) and an orientation (orientation). Orientation has the same meaning as it does for SoCamera⁽^C++^|^Java^|^.NET⁾. Initially “forward” is the -Z direction, “up” is the +Y direction, and the orientation is rotation with respect to this starting point.

Connecting Fields

To animate an object (i.e., a sub-scene graph), the object must be controlled by an SoTransform⁽^C++^|^Java^|^.NET⁾node which has its translation and rotation fields connected respectively to the position and orientation fields of the SoTrackFollower⁽^C++^|^Java^|^.NET⁾engine.

To animate a camera, the position and orientation fields of the SoTrackFollower⁽^C++^|^Java^|^.NET⁾ engine are connected to the position and orientation fields of the camera.

In order to make an animation, the alpha field value must be connected to a time-changing field, for example, the result of an SoTimeCounter⁽^C++^|^Java^|^.NET⁾engine tuned by an SoCalculator⁽^C++^|^Java^|^.NET⁾engine.

This code fragment shows the basic objects and connections that must be defined:

C++

SoSeparator *root = new SoSeparator;
SoTransform *animationTransform = new SoTransform;
root->addChild (animationTransform);
root->addChild (objectToAnimate);

SoTrackFollower *trackFollowerEngine = new SoTrackFollower;
trackFollowerEngine->points.setValue (0, NUM_POINTS, points);
animationTransform ->translation.connectFrom (&trackFollowerEngine->position);
animationTransform ->rotation.connectFrom (&trackFollowerEngine->orientation);

SoTimeCounter *counter = new SoTimeCounter();
counter->on = true;
counter->min = 0;
counter->max = 10000;
counter->frequency = .005f;

SoCalculator *calc = new SoCalculator();
calc->expression.set1Value(0,"oa = a/10000.");
calc->a.connectFrom(&counter->output);
trackFollowerEngine->alpha.connectFrom(&calc->oa);

.NET

SoSeparator root = new SoSeparator();
SoTransform animationTransform = new SoTransform();
root.AddChild (animationTransform);
root.AddChild (objectToAnimate);

SoTrackFollower trackFollowerEngine = new SoTrackFollower();
trackFollowerEngine.points.SetValue (0, NUM_POINTS, points);
animationTransform.translation.ConnectFrom (trackFollowerEngine.position);
animationTransform.rotation.ConnectFrom (trackFollowerEngine.orientation);

SoTimeCounter counter = new SoTimeCounter();
counter.on.Value = true;
counter.min.Value = 0;
counter.max.Value = 10000;
counter.frequency.Value = .005f;

SoCalculator calc = new SoCalculator();
calc.expression[0] = "oa = a/10000.";
calc.a.ConnectFrom(counter.output);
trackFollowerEngine.alpha.ConnectFrom(calc.oa);

Java

SoSeparator root = new SoSeparator();
SoTransform animationTransform = new SoTransform();
root.addChild (animationTransform);
root.addChild (objectToAnimate);

SoTrackFollower trackFollowerEngine = new SoTrackFollower();
trackFollowerEngine.points.setValue(points);
animationTransform.translation.connectFrom (trackFollowerEngine.position);
animationTransform.rotation.connectFrom (trackFollowerEngine.orientation);

SoTimeCounter counter = new SoTimeCounter();
counter.on.setValue(true);
counter.min.setValue((short)0);
counter.max.setValue((short)10000);
counter.frequency.setValue(.005f);

SoCalculator calc = new SoCalculator();
calc.expression.set1Value(0,"oa = a/10000.");
calc.a.connectFrom(counter.output);
trackFollowerEngine.alpha.connectFrom(calc.oa);

Track Follower Example (.iv)

Here’s a simple example of using the SoTrackFollower⁽^C++^|^Java^|^.NET⁾ engine to animate a cube going around a sphere. First we show the definition of the SoTrackFollower⁽^C++^|^Java^|^.NET⁾ engine.

TrackFollower
{
points [ -4 0 -4,
  -4 0 4,
  4 0 4,
  4 0 -4]
  radius [ 2 ]
  rollAngle [ 0.25]
  rollSpeed [ 0.5 ]
  loop TRUE
}

Now to make a complete file, we connect the Track Follower engine to a transform node, and two other engines (SoCalculator⁽^C++^|^Java^|^.NET⁾and SoElapsedTime⁽^C++^|^Java^|^.NET⁾ ) are connected to the Track Follower engine to generate the time steps.

#Inventor V2.1 ascii

  Separator
    {

    Sphere
      {
      }
    Transform
      {
      translation 0 0 0 =
        DEF track TrackFollower
        {
        points [ -4 0 -4,
          -4 0 4,
          4 0 4,
          4 0 -4]
          radius [ 2 ]
          rollAngle [ 0.25]
          rollSpeed [ 0.5 ]
          alpha 0 =
          Calculator
          {
          a 0 =
            ElapsedTime
            {
            speed 0.1
            } . timeOut
            expression "oa = fmod (a , 1)"
          } . oa
          loop TRUE
        } . position
        rotation 0 0 0 0 = USE track . orientation
      }
    Cube
      {
      }
    }

Prev	Up	Next
15.9. Animation Engines	Home	15.11. Gate Engine