and Animation

This outline describes the process of interpolation as used in oglr’s animation implementation.

Interpolation is a technique used to generate smooth transitions between two points in space or time. In the context of oglr, we primarily use interpolation to achieve smooth animation.

Interpolation

Interpolation involves calculating intermediate values between two known points. oglr leverages several interpolation methods:

• Linear Interpolation: The simplest form, linear interpolation calculates a value that is proportionally between two given points.

  // Example: Linear interpolation between 0 and 10
            float value = glm::mix(0.0f, 10.0f, 0.5f); // value = 5.0f
            

  This example illustrates the usage of glm::mix in oglr to perform linear interpolation. This function takes three arguments:

  1. Start value: The initial point of interpolation.
  2. End value: The final point of interpolation.
  3. Interpolation factor: A value between 0.0 and 1.0, representing the position along the interpolation range.

• Slerp (Spherical Linear Interpolation): This method is primarily used for interpolating rotations.

  // Example: Slerp between two quaternions
            glm::quat q1 = glm::angleAxis(glm::radians(45.0f), glm::vec3(1.0f, 0.0f, 0.0f));
            glm::quat q2 = glm::angleAxis(glm::radians(90.0f), glm::vec3(0.0f, 1.0f, 0.0f));
            glm::quat result = glm::slerp(q1, q2, 0.5f); // result is a quaternion representing the halfway rotation between q1 and q2.
            

  Slerp is crucial for ensuring smooth and consistent rotational interpolation in oglr.

• Cubic Hermite Interpolation: This method employs tangents at the start and end points to achieve smoother curves than linear interpolation.

  // Example: Cubic Hermite interpolation between two points
            glm::vec3 p0 = glm::vec3(0.0f, 0.0f, 0.0f);
            glm::vec3 p1 = glm::vec3(10.0f, 10.0f, 10.0f);
            glm::vec3 t0 = glm::vec3(1.0f, 0.0f, 0.0f);
            glm::vec3 t1 = glm::vec3(0.0f, 1.0f, 0.0f);
            glm::vec3 result = glm::hermite(p0, t0, p1, t1, 0.5f);
            

  The glm::hermite function in oglr allows for the calculation of smooth transitions using Cubic Hermite Interpolation.

Animations

Animations in oglr are defined as sequences of keyframes. A keyframe represents a specific state of an object at a given time. The interpolation techniques described above are used to create smooth transitions between these keyframes.

Keyframes: Keyframes can contain various data, such as:

• Position: The location of the object in 3D space.
• Rotation: The orientation of the object.
• Scale: The size of the object.

Interpolation: Interpolation between keyframes is managed by a dedicated Animator class within oglr.

// Example: Create an Animator for a specific model
          Animator animator = Animator(model);
          
          // Example: Add a keyframe at time 0.0f
          animator.addKeyframe(0.0f, glm::vec3(0.0f, 0.0f, 0.0f), glm::quat(1.0f, 0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f));
          
          // Example: Add a keyframe at time 2.0f
          animator.addKeyframe(2.0f, glm::vec3(10.0f, 0.0f, 0.0f), glm::quat(1.0f, 0.0f, 0.0f, 0.0f), glm::vec3(2.0f, 2.0f, 2.0f));
          
          // Example: Update the animation
          animator.update(currentTime);
          

This example demonstrates the use of the Animator class to create an animation with two keyframes.

Conclusion

Understanding interpolation techniques is fundamental to building smooth and visually appealing animations. oglr provides a robust framework for creating and managing animations, utilizing interpolation methods like linear interpolation, slerp, and Cubic Hermite Interpolation for seamless transitions between keyframes.