Updated ozz-animation to version 0.14.1 @35b2efd4

3rdparty/ozz-animation/include/ozz/animation/runtime/animation.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_ANIMATION_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_ANIMATION_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/io/archive_traits.h"
 #include "ozz/base/platform.h"
 #include "ozz/base/span.h"
@@ -58,11 +59,19 @@ struct QuaternionKey;
 // joints order of the runtime skeleton structure. In order to optimize cache
 // coherency when sampling the animation, Keyframes in this array are sorted by
 // time, then by track number.
-class Animation {
+class OZZ_ANIMATION_DLL Animation {
  public:
   // Builds a default animation.
   Animation();
 
+  // Allow moves.
+  Animation(Animation&&);
+  Animation& operator=(Animation&&);
+
+  // Delete copies.
+  Animation(Animation const&) = delete;
+  Animation& operator=(Animation const&) = delete;
+
   // Declares the public non-virtual destructor.
   ~Animation();
 
@@ -80,9 +89,7 @@ class Animation {
   const char* name() const { return name_ ? name_ : ""; }
 
   // Gets the buffer of translations keys.
-  span<const Float3Key> translations() const {
-    return translations_;
-  }
+  span<const Float3Key> translations() const { return translations_; }
 
   // Gets the buffer of rotation keys.
   span<const QuaternionKey> rotations() const { return rotations_; }
@@ -98,12 +105,7 @@ class Animation {
   void Save(ozz::io::OArchive& _archive) const;
   void Load(ozz::io::IArchive& _archive, uint32_t _version);
 
- protected:
  private:
-  // Disables copy and assignation.
-  Animation(Animation const&);
-  void operator=(Animation const&);
-
   // AnimationBuilder class is allowed to instantiate an Animation.
   friend class offline::AnimationBuilder;
 

3rdparty/ozz-animation/include/ozz/animation/runtime/animation_utils.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_ANIMATION_UTILS_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_ANIMATION_UTILS_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/animation/runtime/animation.h"
 
 namespace ozz {
@@ -35,9 +36,12 @@ namespace animation {
 
 // Count translation, rotation or scale keyframes for a given track number. Use
 // a negative _track value to count all tracks.
-int CountTranslationKeyframes(const Animation& _animation, int _track = -1);
-int CountRotationKeyframes(const Animation& _animation, int _track = -1);
-int CountScaleKeyframes(const Animation& _animation, int _track = -1);
+OZZ_ANIMATION_DLL int CountTranslationKeyframes(const Animation& _animation,
+                                                int _track = -1);
+OZZ_ANIMATION_DLL int CountRotationKeyframes(const Animation& _animation,
+                                             int _track = -1);
+OZZ_ANIMATION_DLL int CountScaleKeyframes(const Animation& _animation,
+                                          int _track = -1);
 }  // namespace animation
 }  // namespace ozz
 #endif  // OZZ_OZZ_ANIMATION_RUNTIME_ANIMATION_UTILS_H_

3rdparty/ozz-animation/include/ozz/animation/runtime/blending_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_BLENDING_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_BLENDING_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/maths/simd_math.h"
 #include "ozz/base/span.h"
 
@@ -44,15 +45,15 @@ namespace animation {
 // (the result of a sampled animation) according to their respective weight,
 // into one output pose.
 // The number of transforms/joints blended by the job is defined by the number
-// of transforms of the bind pose (note that this is a SoA format). This means
-// that all buffers must be at least as big as the bind pose buffer.
+// of transforms of the rest pose (note that this is a SoA format). This means
+// that all buffers must be at least as big as the rest pose buffer.
 // Partial animation blending is supported through optional joint weights that
 // can be specified with layers joint_weights buffer. Unspecified joint weights
 // are considered as a unit weight of 1.f, allowing to mix full and partial
 // blend operations in a single pass.
 // The job does not owned any buffers (input/output) and will thus not delete
 // them during job's destruction.
-struct BlendingJob {
+struct OZZ_ANIMATION_DLL BlendingJob {
   // Default constructor, initializes default values.
   BlendingJob();
 
@@ -63,7 +64,7 @@ struct BlendingJob {
   // -if any layer is not valid.
   // -if output range is not valid.
   // -if any buffer (including layers' content : transform, joint weights...) is
-  // smaller than the bind pose buffer.
+  // smaller than the rest pose buffer.
   // -if the threshold value is less than or equal to 0.f.
   bool Validate() const;
 
@@ -75,7 +76,7 @@ struct BlendingJob {
 
   // Defines a layer of blending input data (local space transforms) and
   // parameters (weights).
-  struct Layer {
+  struct OZZ_ANIMATION_DLL Layer {
     // Default constructor, initializes default values.
     Layer();
 
@@ -86,8 +87,8 @@ struct BlendingJob {
 
     // The range [begin,end[ of input layer posture. This buffer expect to store
     // local space transforms, that are usually outputted from a sampling job.
-    // This range must be at least as big as the bind pose buffer, even though
-    // only the number of transforms defined by the bind pose buffer will be
+    // This range must be at least as big as the rest pose buffer, even though
+    // only the number of transforms defined by the rest pose buffer will be
     // processed.
     span<const math::SoaTransform> transform;
 
@@ -95,8 +96,8 @@ struct BlendingJob {
     // layer.
     // If both pointers are nullptr (default case) then per joint weight
     // blending is disabled. A valid range is defined as being at least as big
-    // as the bind pose buffer, even though only the number of transforms
-    // defined by the bind pose buffer will be processed. When a layer doesn't
+    // as the rest pose buffer, even though only the number of transforms
+    // defined by the rest pose buffer will be processed. When a layer doesn't
     // specifies per joint weights, then it is implicitly considered as
     // being 1.f. This default value is a reference value for the normalization
     // process, which implies that the range of values for joint weights should
@@ -106,7 +107,7 @@ struct BlendingJob {
     span<const math::SimdFloat4> joint_weights;
   };
 
-  // The job blends the bind pose to the output when the accumulated weight of
+  // The job blends the rest pose to the output when the accumulated weight of
   // all layers is less than this threshold value.
   // Must be greater than 0.f.
   float threshold;
@@ -119,18 +120,18 @@ struct BlendingJob {
   // The range of layers that must be added to the output.
   span<const Layer> additive_layers;
 
-  // The skeleton bind pose. The size of this buffer defines the number of
+  // The skeleton rest pose. The size of this buffer defines the number of
   // transforms to blend. This is the reference because this buffer is defined
   // by the skeleton that all the animations belongs to.
   // It is used when the accumulated weight for a bone on all layers is
   // less than the threshold value, in order to fall back on valid transforms.
-  span<const ozz::math::SoaTransform> bind_pose;
+  span<const ozz::math::SoaTransform> rest_pose;
 
   // Job output.
   // The range of output transforms to be filled with blended layer
   // transforms during job execution.
-  // Must be at least as big as the bind pose buffer, but only the number of
-  // transforms defined by the bind pose buffer size will be processed.
+  // Must be at least as big as the rest pose buffer, but only the number of
+  // transforms defined by the rest pose buffer size will be processed.
   span<ozz::math::SoaTransform> output;
 };
 }  // namespace animation

3rdparty/ozz-animation/include/ozz/animation/runtime/export.h

@@ -0,0 +1,44 @@
+//----------------------------------------------------------------------------//
+//                                                                            //
+// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation  //
+// and distributed under the MIT License (MIT).                               //
+//                                                                            //
+// Copyright (c) Guillaume Blanc                                              //
+//                                                                            //
+// Permission is hereby granted, free of charge, to any person obtaining a    //
+// copy of this software and associated documentation files (the "Software"), //
+// to deal in the Software without restriction, including without limitation  //
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,   //
+// and/or sell copies of the Software, and to permit persons to whom the      //
+// Software is furnished to do so, subject to the following conditions:       //
+//                                                                            //
+// The above copyright notice and this permission notice shall be included in //
+// all copies or substantial portions of the Software.                        //
+//                                                                            //
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   //
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    //
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    //
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        //
+// DEALINGS IN THE SOFTWARE.                                                  //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+#ifndef OZZ_OZZ_ANIMATION_RUNTIME_EXPORT_H_
+#define OZZ_OZZ_ANIMATION_RUNTIME_EXPORT_H_
+
+#if defined(_MSC_VER) && defined(OZZ_USE_DYNAMIC_LINKING)
+
+#ifdef OZZ_BUILD_ANIMATION_LIB
+// Import/Export for dynamic linking while building ozz
+#define OZZ_ANIMATION_DLL __declspec(dllexport)
+#else
+#define OZZ_ANIMATION_DLL __declspec(dllimport)
+#endif
+#else  // defined(_MSC_VER) && defined(OZZ_USE_DYNAMIC_LINKING)
+// Static or non msvc linking
+#define OZZ_ANIMATION_DLL
+#endif  // defined(_MSC_VER) && defined(OZZ_USE_DYNAMIC_LINKING)
+
+#endif  // OZZ_OZZ_ANIMATION_RUNTIME_EXPORT_H_

3rdparty/ozz-animation/include/ozz/animation/runtime/ik_aim_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_IK_AIM_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_IK_AIM_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/platform.h"
 
 #include "ozz/base/maths/simd_math.h"
@@ -50,7 +51,7 @@ namespace animation {
 // vector should aim the target.
 // Result is unstable if joint-to-target direction is parallel to pole vector,
 // or if target is too close to joint position.
-struct IKAimJob {
+struct OZZ_ANIMATION_DLL IKAimJob {
   // Default constructor, initializes default values.
   IKAimJob();
 

3rdparty/ozz-animation/include/ozz/animation/runtime/ik_two_bone_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_IK_TWO_BONE_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_IK_TWO_BONE_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/platform.h"
 
 #include "ozz/base/maths/simd_math.h"
@@ -51,7 +52,7 @@ namespace animation {
 // ancestors (joints in-between will simply remain fixed).
 // Implementation is inspired by Autodesk Maya 2 bone IK, improved stability
 // wise and extended with Soften IK.
-struct IKTwoBoneJob {
+struct OZZ_ANIMATION_DLL IKTwoBoneJob {
   // Constructor, initializes default values.
   IKTwoBoneJob();
 

3rdparty/ozz-animation/include/ozz/animation/runtime/local_to_model_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_LOCAL_TO_MODEL_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_LOCAL_TO_MODEL_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/platform.h"
 #include "ozz/base/span.h"
 
@@ -55,7 +56,7 @@ class Skeleton;
 // ordered like skeleton's joints. Output are matrices, because the combination
 // of affine transformations can contain shearing or complex transformation
 // that cannot be represented as Transform object.
-struct LocalToModelJob {
+struct OZZ_ANIMATION_DLL LocalToModelJob {
   // Default constructor, initializes default values.
   LocalToModelJob();
 

3rdparty/ozz-animation/include/ozz/animation/runtime/sampling_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_SAMPLING_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_SAMPLING_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/platform.h"
 #include "ozz/base/span.h"
 
@@ -43,19 +44,16 @@ namespace animation {
 // Forward declares the animation type to sample.
 class Animation;
 
-// Forward declares the cache object used by the SamplingJob.
-class SamplingCache;
-
 // Samples an animation at a given time ratio in the unit interval [0,1] (where
 // 0 is the beginning of the animation, 1 is the end), to output the
 // corresponding posture in local-space.
-// SamplingJob uses a cache (aka SamplingCache) to store intermediate values
-// (decompressed animation keyframes...) while sampling. This cache also stores
-// pre-computed values that allows drastic optimization while playing/sampling
-// the animation forward. Backward sampling works, but isn't optimized through
-// the cache. The job does not owned the buffers (in/output) and will thus not
-// delete them during job's destruction.
-struct SamplingJob {
+// SamplingJob uses a context (aka SamplingJob::Context) to store intermediate
+// values (decompressed animation keyframes...) while sampling. This context
+// also stores pre-computed values that allows drastic optimization while
+// playing/sampling the animation forward. Backward sampling works, but isn't
+// optimized through the context. The job does not owned the buffers (in/output)
+// and will thus not delete them during job's destruction.
+struct OZZ_ANIMATION_DLL SamplingJob {
   // Default constructor, initializes default values.
   SamplingJob();
 
@@ -80,8 +78,11 @@ struct SamplingJob {
   // The animation to sample.
   const Animation* animation;
 
-  // A cache object that must be big enough to sample *this animation.
-  SamplingCache* cache;
+  // Forward declares the context object used by the SamplingJob.
+  class Context;
+
+  // A context object that must be big enough to sample *this animation.
+  Context* context;
 
   // Job output.
   // The output range to be filled with sampled joints during job execution.
@@ -98,61 +99,62 @@ struct InterpSoaFloat3;
 struct InterpSoaQuaternion;
 }  // namespace internal
 
-// Declares the cache object used by the workload to take advantage of the
+// Declares the context object used by the workload to take advantage of the
 // frame coherency of animation sampling.
-class SamplingCache {
+class OZZ_ANIMATION_DLL SamplingJob::Context {
  public:
-  // Constructs an empty cache. The cache needs to be resized with the
+  // Constructs an empty context. The context needs to be resized with the
   // appropriate number of tracks before it can be used with a SamplingJob.
-  SamplingCache();
+  Context();
 
-  // Constructs a cache that can be used to sample any animation with at most
+  // Constructs a context that can be used to sample any animation with at most
   // _max_tracks tracks. _num_tracks is internally aligned to a multiple of
   // soa size, which means max_tracks() can return a different (but bigger)
   // value than _max_tracks.
-  explicit SamplingCache(int _max_tracks);
+  explicit Context(int _max_tracks);
 
-  // Deallocates cache.
-  ~SamplingCache();
+  // Disables copy and assignation.
+  Context(Context const&) = delete;
+  Context& operator=(Context const&) = delete;
 
-  // Resize the number of joints that the cache can support.
-  // This also implicitly invalidate the cache.
+  // Deallocates context.
+  ~Context();
+
+  // Resize the number of joints that the context can support.
+  // This also implicitly invalidate the context.
   void Resize(int _max_tracks);
 
-  // Invalidate the cache.
-  // The SamplingJob automatically invalidates a cache when required
+  // Invalidate the context.
+  // The SamplingJob automatically invalidates a context when required
   // during sampling. This automatic mechanism is based on the animation
   // address and sampling time ratio. The weak point is that it can result in a
   // crash if ever the address of an animation is used again with another
   // animation (could be the result of successive call to delete / new).
-  // Therefore it is recommended to manually invalidate a cache when it is
-  // known that this cache will not be used for with an animation again.
+  // Therefore it is recommended to manually invalidate a context when it is
+  // known that this context will not be used for with an animation again.
   void Invalidate();
 
-  // The maximum number of tracks that the cache can handle.
+  // The maximum number of tracks that the context can handle.
   int max_tracks() const { return max_soa_tracks_ * 4; }
   int max_soa_tracks() const { return max_soa_tracks_; }
 
  private:
-  // Disables copy and assignation.
-  SamplingCache(SamplingCache const&);
-  void operator=(SamplingCache const&);
-
   friend struct SamplingJob;
 
-  // Steps the cache in order to use it for a potentially new animation and
+  // Steps the context in order to use it for a potentially new animation and
   // ratio. If the _animation is different from the animation currently cached,
   // or if the _ratio shows that the animation is played backward, then the
-  // cache is invalidated and reseted for the new _animation and _ratio.
+  // context is invalidated and reset for the new _animation and _ratio.
   void Step(const Animation& _animation, float _ratio);
 
-  // The animation this cache refers to. nullptr means that the cache is invalid.
+  // The animation this context refers to. nullptr means that the context is
+  // invalid.
   const Animation* animation_;
 
   // The current time ratio in the animation.
   float ratio_;
 
-  // The number of soa tracks that can store this cache.
+  // The number of soa tracks that can store this context.
   int max_soa_tracks_;
 
   // Soa hot data to interpolate.
@@ -166,7 +168,7 @@ class SamplingCache {
   int* rotation_keys_;
   int* scale_keys_;
 
-  // Current cursors in the animation. 0 means that the cache is invalid.
+  // Current cursors in the animation. 0 means that the context is invalid.
   int translation_cursor_;
   int rotation_cursor_;
   int scale_cursor_;

3rdparty/ozz-animation/include/ozz/animation/runtime/skeleton.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_SKELETON_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_SKELETON_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/io/archive_traits.h"
 #include "ozz/base/platform.h"
 #include "ozz/base/span.h"
@@ -48,16 +49,16 @@ class SkeletonBuilder;
 }
 
 // This runtime skeleton data structure provides a const-only access to joint
-// hierarchy, joint names and bind-pose. This structure is filled by the
+// hierarchy, joint names and rest-pose. This structure is filled by the
 // SkeletonBuilder and can be serialize/deserialized.
-// Joint names, bind-poses and hierarchy information are all stored in separate
+// Joint names, rest-poses and hierarchy information are all stored in separate
 // arrays of data (as opposed to joint structures for the RawSkeleton), in order
 // to closely match with the way runtime algorithms use them. Joint hierarchy is
 // packed as an array of parent jont indices (16 bits), stored in depth-first
 // order. This is enough to traverse the whole joint hierarchy. See
 // IterateJointsDF() from skeleton_utils.h that implements a depth-first
 // traversal utility.
-class Skeleton {
+class OZZ_ANIMATION_DLL Skeleton {
  public:
   // Defines Skeleton constant values.
   enum Constants {
@@ -81,6 +82,14 @@ class Skeleton {
   // Builds a default skeleton.
   Skeleton();
 
+  // Allow move.
+  Skeleton(Skeleton&&);
+  Skeleton& operator=(Skeleton&&);
+
+  // Disables copy and assignation.
+  Skeleton(Skeleton const&) = delete;
+  Skeleton& operator=(Skeleton const&) = delete;
+
   // Declares the public non-virtual destructor.
   ~Skeleton();
 
@@ -91,9 +100,9 @@ class Skeleton {
   // skeleton. This value is useful to allocate SoA runtime data structures.
   int num_soa_joints() const { return (num_joints() + 3) / 4; }
 
-  // Returns joint's bind poses. Bind poses are stored in soa format.
-  span<const math::SoaTransform> joint_bind_poses() const {
-    return joint_bind_poses_;
+  // Returns joint's rest poses. Rest poses are stored in soa format.
+  span<const math::SoaTransform> joint_rest_poses() const {
+    return joint_rest_poses_;
   }
 
   // Returns joint's parent indices range.
@@ -110,10 +119,6 @@ class Skeleton {
   void Load(ozz::io::IArchive& _archive, uint32_t _version);
 
  private:
-  // Disables copy and assignation.
-  Skeleton(Skeleton const&);
-  void operator=(Skeleton const&);
-
   // Internal allocation/deallocation function.
   // Allocate returns the beginning of the contiguous buffer of names.
   char* Allocate(size_t _char_count, size_t _num_joints);
@@ -125,8 +130,8 @@ class Skeleton {
   // Buffers below store joint informations in joing depth first order. Their
   // size is equal to the number of joints of the skeleton.
 
-  // Bind pose of every joint in local space.
-  span<math::SoaTransform> joint_bind_poses_;
+  // Rest pose of every joint in local space.
+  span<math::SoaTransform> joint_rest_poses_;
 
   // Array of joint parent indexes.
   span<int16_t> joint_parents_;

3rdparty/ozz-animation/include/ozz/animation/runtime/skeleton_utils.h

@@ -28,17 +28,18 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_SKELETON_UTILS_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_SKELETON_UTILS_H_
 
+#include <cassert>
+
+#include "ozz/animation/runtime/export.h"
 #include "ozz/animation/runtime/skeleton.h"
 #include "ozz/base/maths/transform.h"
 
-#include <cassert>
-
 namespace ozz {
 namespace animation {
 
-// Get bind-pose of a skeleton joint.
-ozz::math::Transform GetJointLocalBindPose(const Skeleton& _skeleton,
-                                           int _joint);
+// Get rest-pose of a skeleton joint.
+OZZ_ANIMATION_DLL ozz::math::Transform GetJointLocalRestPose(
+    const Skeleton& _skeleton, int _joint);
 
 // Test if a joint is a leaf. _joint number must be in range [0, num joints].
 // "_joint" is a leaf if it's the last joint, or next joint's parent isn't
@@ -51,12 +52,15 @@ inline bool IsLeaf(const Skeleton& _skeleton, int _joint) {
   return next == num_joints || parents[next] != _joint;
 }
 
+// Finds joint index by name. Uses a case sensitive comparison.
+OZZ_ANIMATION_DLL int FindJoint(const Skeleton& _skeleton, const char* _name);
+
 // Applies a specified functor to each joint in a depth-first order.
-// _Fct is of type void(int _current, int _parent) where the first argument is
-// the child of the second argument. _parent is kNoParent if the
-// _current joint is a root. _from indicates the joint from which the joint
-// hierarchy traversal begins. Use Skeleton::kNoParent to traverse the
-// whole hierarchy, in case there are multiple roots.
+// _Fct is of type void(int _current, int _parent) where the first argument
+// is the child of the second argument. _parent is kNoParent if the _current
+// joint is a root. _from indicates the joint from which the joint hierarchy
+// traversal begins. Use Skeleton::kNoParent to traverse the whole
+// hierarchy, in case there are multiple roots.
 template <typename _Fct>
 inline _Fct IterateJointsDF(const Skeleton& _skeleton, _Fct _fct,
                             int _from = Skeleton::kNoParent) {

3rdparty/ozz-animation/include/ozz/animation/runtime/track.h

@@ -28,12 +28,12 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_TRACK_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_TRACK_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/io/archive_traits.h"
-#include "ozz/base/platform.h"
-#include "ozz/base/span.h"
-
 #include "ozz/base/maths/quaternion.h"
 #include "ozz/base/maths/vec_float.h"
+#include "ozz/base/platform.h"
+#include "ozz/base/span.h"
 
 namespace ozz {
 namespace animation {
@@ -54,11 +54,20 @@ namespace internal {
 // coherently. Ratios are usually accessed/read alone from the jobs that all
 // start by looking up the keyframes to interpolate indeed.
 template <typename _ValueType>
-class Track {
+class OZZ_ANIMATION_DLL Track {
  public:
   typedef _ValueType ValueType;
 
   Track();
+
+  // Allow move.
+  Track(Track&& _other);
+  Track& operator=(Track&& _other);
+
+  // Disables copy and assignation.
+  Track(Track const&) = delete;
+  void operator=(Track const&) = delete;
+
   ~Track();
 
   // Keyframe accessors.
@@ -78,10 +87,6 @@ class Track {
   void Load(ozz::io::IArchive& _archive, uint32_t _version);
 
  private:
-  // Disables copy and assignation.
-  Track(Track const&);
-  void operator=(Track const&);
-
   // TrackBuilder class is allowed to allocate a Track.
   friend class offline::TrackBuilder;
 
@@ -99,7 +104,7 @@ class Track {
   span<uint8_t> steps_;
 
   // Track name.
-  char* name_;
+  char* name_ = nullptr;
 };
 
 // Definition of operations policies per track value type.
@@ -146,11 +151,12 @@ inline math::Quaternion TrackPolicy<math::Quaternion>::identity() {
 }  // namespace internal
 
 // Runtime track data structure instantiation.
-class FloatTrack : public internal::Track<float> {};
-class Float2Track : public internal::Track<math::Float2> {};
-class Float3Track : public internal::Track<math::Float3> {};
-class Float4Track : public internal::Track<math::Float4> {};
-class QuaternionTrack : public internal::Track<math::Quaternion> {};
+class OZZ_ANIMATION_DLL FloatTrack : public internal::Track<float> {};
+class OZZ_ANIMATION_DLL Float2Track : public internal::Track<math::Float2> {};
+class OZZ_ANIMATION_DLL Float3Track : public internal::Track<math::Float3> {};
+class OZZ_ANIMATION_DLL Float4Track : public internal::Track<math::Float4> {};
+class OZZ_ANIMATION_DLL QuaternionTrack
+    : public internal::Track<math::Quaternion> {};
 
 }  // namespace animation
 namespace io {

3rdparty/ozz-animation/include/ozz/animation/runtime/track_sampling_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_TRACK_SAMPLING_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_TRACK_SAMPLING_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/animation/runtime/track.h"
 
 namespace ozz {
@@ -65,14 +66,15 @@ struct TrackSamplingJob {
 // Track sampling job implementation. Track sampling allows to query a track
 // value for a specified ratio. This is a ratio rather than a time because
 // tracks have no duration.
-struct FloatTrackSamplingJob : public internal::TrackSamplingJob<FloatTrack> {};
-struct Float2TrackSamplingJob : public internal::TrackSamplingJob<Float2Track> {
-};
-struct Float3TrackSamplingJob : public internal::TrackSamplingJob<Float3Track> {
-};
-struct Float4TrackSamplingJob : public internal::TrackSamplingJob<Float4Track> {
-};
-struct QuaternionTrackSamplingJob
+struct OZZ_ANIMATION_DLL FloatTrackSamplingJob
+    : public internal::TrackSamplingJob<FloatTrack> {};
+struct OZZ_ANIMATION_DLL Float2TrackSamplingJob
+    : public internal::TrackSamplingJob<Float2Track> {};
+struct OZZ_ANIMATION_DLL Float3TrackSamplingJob
+    : public internal::TrackSamplingJob<Float3Track> {};
+struct OZZ_ANIMATION_DLL Float4TrackSamplingJob
+    : public internal::TrackSamplingJob<Float4Track> {};
+struct OZZ_ANIMATION_DLL QuaternionTrackSamplingJob
     : public internal::TrackSamplingJob<QuaternionTrack> {};
 
 }  // namespace animation

3rdparty/ozz-animation/include/ozz/animation/runtime/track_triggering_job.h

@@ -28,6 +28,7 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_TRACK_TRIGGERING_JOB_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_TRACK_TRIGGERING_JOB_H_
 
+#include "ozz/animation/runtime/export.h"
 #include "ozz/base/platform.h"
 
 namespace ozz {
@@ -46,7 +47,7 @@ class FloatTrack;
 // track types isn't possible.
 // The job execution actually performs a lazy evaluation of edges. It builds an
 // iterator that will process the next edge on each call to ++ operator.
-struct TrackTriggeringJob {
+struct OZZ_ANIMATION_DLL TrackTriggeringJob {
   TrackTriggeringJob();
 
   // Validates job parameters.
@@ -95,7 +96,7 @@ struct TrackTriggeringJob {
 // Iterator implementation. Calls to ++ operator will compute the next edge. It
 // should be compared (using operator !=) to job's end iterator to test if the
 // last edge has been reached.
-class TrackTriggeringJob::Iterator {
+class OZZ_ANIMATION_DLL TrackTriggeringJob::Iterator {
  public:
   Iterator() : job_(nullptr), outer_(0.f), inner_(0) {}
 

3rdparty/ozz-animation/include/ozz/animation/runtime/track_triggering_job_trait.h

@@ -28,6 +28,8 @@
 #ifndef OZZ_OZZ_ANIMATION_RUNTIME_TRACK_TRIGGERING_JOB_TRAIT_H_
 #define OZZ_OZZ_ANIMATION_RUNTIME_TRACK_TRIGGERING_JOB_TRAIT_H_
 
+#include "ozz/animation/runtime/export.h"
+
 // Defines iterator traits required to use TrackTriggeringJob::Iterator
 // with stl algorithms.
 // This is a separate file from "track_triggering_job.h" to prevent everyone