Method Move

IO/MotionFX/vtkMotionFXCFGReader.cxx:782–893

  bool read_universaltransform_file(const std::string& rootDir) const;

  bool Move(vtkPoints* pts, double time) const override
  {
    if (this->transforms.empty())
    {
      // at least one entry is required
      return false;
    }

    // let's clamp to time range in the universal transform file
    time = std::min(this->transforms.rbegin()->first, time);
    time = std::max(this->transforms.begin()->first, time);

    auto next = this->transforms.lower_bound(time);
    auto prev = next;

    vtkNew<vtkTransform> transform;
    transform->PostMultiply();

    double t;
    if (next->first > time)
    {
      prev = std::prev(next);
      const double interval = (next->first - prev->first);
      const double dt = std::min(time - prev->first, interval);
      t = dt / interval; // normalized dt
    }
    else // this also handles single entry files
    {
      t = 0.0;
    }

    const vtkVector3d rotation_center =
      prev->second.rotation_center * (1.0 - t) + next->second.rotation_center * t;
    transform->Translate((rotation_center * -1.0).GetData());

    const vtkVector3d linear_scale =
      prev->second.linear_scale * (1.0 - t) + next->second.linear_scale * t;
    transform->Scale(linear_scale.GetData());

    double quatdotprod = prev->second.quaternion.Dot(next->second.quaternion);

    if (quatdotprod < 0.0)
    {
      next->second.quaternion = -next->second.quaternion;
      quatdotprod = -quatdotprod;
    }

    vtkVector4d quatnow;
    if (quatdotprod > 0.9995) // linear interpolation (LERP)
    {
      quatnow = prev->second.quaternion * (1.0 - t) + next->second.quaternion * t;
    }
    else // spherical linear interpolation (SLERP)
    {
      const double thdiff = std::acos(quatdotprod);
      const double sndiff = std::sin(thdiff);
      const double cfi = sin((1.0 - t) * thdiff) / sndiff;
      const double cfn = sin(t * thdiff) / sndiff;