11 files changed, 432 insertions, 3 deletions

diff --git a/intern/cycles/blender/blender_mesh.cpp b/intern/cycles/blender/blender_mesh.cpp
index 49407799fcd..9043cd81293 100644
--- a/intern/cycles/blender/blender_mesh.cpp
+++ b/intern/cycles/blender/blender_mesh.cpp
@@ -923,6 +923,73 @@ static void create_subd_mesh(Scene *scene,
 
 /* Sync */
 
+static BL::MeshSequenceCacheModifier object_mesh_cache_find(BL::Object &b_ob, BL::Scene b_scene)
+{
+  BL::Object::modifiers_iterator b_mod;
+
+  for (b_ob.modifiers.begin(b_mod); b_mod != b_ob.modifiers.end(); ++b_mod) {
+    if (!b_mod->is_a(&RNA_MeshSequenceCacheModifier)) {
+      continue;
+    }
+
+    BL::MeshSequenceCacheModifier mesh_cache = BL::MeshSequenceCacheModifier(*b_mod);
+
+    if (MeshSequenceCacheModifier_has_velocity_get(&mesh_cache.ptr)) {
+      return mesh_cache;
+    }
+  }
+
+  return BL::MeshSequenceCacheModifier(PointerRNA_NULL);
+}
+
+static void sync_mesh_cached_velocities(BL::Object &b_ob,
+                                        BL::Scene b_scene,
+                                        Scene *scene,
+                                        Mesh *mesh)
+{
+  if (scene->need_motion() == Scene::MOTION_NONE)
+    return;
+
+  BL::MeshSequenceCacheModifier b_mesh_cache = object_mesh_cache_find(b_ob, b_scene);
+
+  if (!b_mesh_cache) {
+    return;
+  }
+
+  /* Find or add attribute */
+  float3 *P = &mesh->verts[0];
+  Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+
+  if (!attr_mP) {
+    attr_mP = mesh->attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
+  }
+
+  if (!MeshSequenceCacheModifier_read_velocity_get(&b_mesh_cache.ptr)) {
+    return;
+  }
+
+  const size_t numverts = mesh->verts.size();
+
+  if (b_mesh_cache.vertex_velocities.length() != numverts) {
+    return;
+  }
+
+  /* Only export previous and next frame, we don't have any in between data. */
+  float motion_times[2] = {-1.0f, 1.0f};
+  for (int step = 0; step < 2; step++) {
+    const float relative_time = motion_times[step] * scene->motion_shutter_time() * 0.5f;
+    float3 *mP = attr_mP->data_float3() + step * numverts;
+
+    BL::MeshSequenceCacheModifier::vertex_velocities_iterator vvi;
+    int i = 0;
+
+    for (b_mesh_cache.vertex_velocities.begin(vvi); vvi != b_mesh_cache.vertex_velocities.end();
+         ++vvi, ++i) {
+      mP[i] = P[i] + get_float3(vvi->velocity()) * relative_time;
+    }
+  }
+}
+
 static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
 {
   if (scene->need_motion() == Scene::MOTION_NONE)
@@ -1002,6 +1069,9 @@ void BlenderSync::sync_mesh(BL::Depsgraph b_depsgraph,
     }
   }
 
+  /* cached velocities (e.g. from alembic archive) */
+  sync_mesh_cached_velocities(b_ob, b_depsgraph.scene(), scene, mesh);
+
   /* mesh fluid motion mantaflow */
   sync_mesh_fluid_motion(b_ob, scene, mesh);
 
@@ -1023,6 +1093,12 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
     return;
   }
 
+  /* Cached motion blur already exported. */
+  BL::MeshSequenceCacheModifier mesh_cache = object_mesh_cache_find(b_ob, b_scene);
+  if (mesh_cache) {
+    return;
+  }
+
   /* Skip if no vertices were exported. */
   size_t numverts = mesh->verts.size();
   if (numverts == 0) {
diff --git a/source/blender/blenkernel/intern/cachefile.c b/source/blender/blenkernel/intern/cachefile.c
index da9dab36044..9ad6ae84c5c 100644
--- a/source/blender/blenkernel/intern/cachefile.c
+++ b/source/blender/blenkernel/intern/cachefile.c
@@ -61,6 +61,8 @@ static void cache_file_init_data(ID *id)
   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(cache_file, id));
 
   cache_file->scale = 1.0f;
+  cache_file->velocity_unit = CACHEFILE_VELOCITY_UNIT_SECOND;
+  BLI_strncpy(cache_file->velocity_name, ".velocities", sizeof(cache_file->velocity_name));
 }
 
 static void cache_file_copy_data(Main *UNUSED(bmain),
diff --git a/source/blender/blenloader/intern/versioning_290.c b/source/blender/blenloader/intern/versioning_290.c
index b6caa018756..c4c697254bd 100644
--- a/source/blender/blenloader/intern/versioning_290.c
+++ b/source/blender/blenloader/intern/versioning_290.c
@@ -22,9 +22,11 @@
 
 #include "BLI_listbase.h"
 #include "BLI_math.h"
+#include "BLI_string.h"
 #include "BLI_utildefines.h"
 
 #include "DNA_brush_types.h"
+#include "DNA_cachefile_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_genfile.h"
 #include "DNA_gpencil_modifier_types.h"
@@ -427,5 +429,28 @@ void blo_do_versions_290(FileData *fd, Library *UNUSED(lib), Main *bmain)
         }
       }
     }
+
+    /* Initialise additional velocity parameter for CacheFiles. */
+    if (!DNA_struct_elem_find(
+            fd->filesdna, "MeshSeqCacheModifierData", "float", "velocity_scale")) {
+      for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
+        LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
+          if (md->type == eModifierType_MeshSequenceCache) {
+            MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
+            mcmd->velocity_scale = 1.0f;
+            mcmd->vertex_velocities = NULL;
+            mcmd->num_vertices = 0;
+          }
+        }
+      }
+    }
+
+    if (!DNA_struct_elem_find(fd->filesdna, "CacheFile", "char", "velocity_unit")) {
+      for (CacheFile *cache_file = bmain->cachefiles.first; cache_file != NULL;
+           cache_file = cache_file->id.next) {
+        BLI_strncpy(cache_file->velocity_name, ".velocities", sizeof(cache_file->velocity_name));
+        cache_file->velocity_unit = CACHEFILE_VELOCITY_UNIT_SECOND;
+      }
+    }
   }
 }
diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c
index d3487b635ce..fcafa88a806 100644
--- a/source/blender/editors/interface/interface_templates.c
+++ b/source/blender/editors/interface/interface_templates.c
@@ -7348,6 +7348,9 @@ void uiTemplateCacheFile(uiLayout *layout,
     uiItemR(row, &fileptr, "scale", 0, IFACE_("Manual Scale"), ICON_NONE);
   }
 
+  uiItemR(layout, &fileptr, "velocity_name", 0, NULL, ICON_NONE);
+  uiItemR(layout, &fileptr, "velocity_unit", 0, NULL, ICON_NONE);
+
   /* TODO: unused for now, so no need to expose. */
 #if 0
   row = uiLayoutRow(layout, false);
diff --git a/source/blender/io/alembic/ABC_alembic.h b/source/blender/io/alembic/ABC_alembic.h
index ddf75aa3258..67f8aeb0a67 100644
--- a/source/blender/io/alembic/ABC_alembic.h
+++ b/source/blender/io/alembic/ABC_alembic.h
@@ -128,6 +128,16 @@ struct CacheReader *CacheReader_open_alembic_object(struct AbcArchiveHandle *han
                                                     struct Object *object,
                                                     const char *object_path);
 
+bool ABC_has_vec3_array_property_named(struct CacheReader *reader, const char *name);
+
+/* r_vertex_velocities should point to a preallocated array of num_vertices floats */
+int ABC_read_velocity_cache(struct CacheReader *reader,
+                            const char *velocity_name,
+                            float time,
+                            float fps,
+                            int num_vertices,
+                            float *r_vertex_velocities);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/io/alembic/intern/alembic_capi.cc b/source/blender/io/alembic/intern/alembic_capi.cc
index 7cde2d4fe73..89eb9ed41a1 100644
--- a/source/blender/io/alembic/intern/alembic_capi.cc
+++ b/source/blender/io/alembic/intern/alembic_capi.cc
@@ -22,6 +22,7 @@
 
 #include <Alembic/AbcMaterial/IMaterial.h>
 
+#include "abc_axis_conversion.h"
 #include "abc_reader_archive.h"
 #include "abc_reader_camera.h"
 #include "abc_reader_curves.h"
@@ -70,7 +71,10 @@
 #include "WM_api.h"
 #include "WM_types.h"
 
+using Alembic::Abc::IV3fArrayProperty;
 using Alembic::Abc::ObjectHeader;
+using Alembic::Abc::PropertyHeader;
+using Alembic::Abc::V3fArraySamplePtr;
 using Alembic::AbcGeom::ICamera;
 using Alembic::AbcGeom::ICurves;
 using Alembic::AbcGeom::IFaceSet;
@@ -79,9 +83,11 @@ using Alembic::AbcGeom::INuPatch;
 using Alembic::AbcGeom::IObject;
 using Alembic::AbcGeom::IPoints;
 using Alembic::AbcGeom::IPolyMesh;
+using Alembic::AbcGeom::IPolyMeshSchema;
 using Alembic::AbcGeom::ISampleSelector;
 using Alembic::AbcGeom::ISubD;
 using Alembic::AbcGeom::IXform;
+using Alembic::AbcGeom::kWrapExisting;
 using Alembic::AbcGeom::MetaData;
 using Alembic::AbcMaterial::IMaterial;
 
@@ -859,3 +865,136 @@ CacheReader *CacheReader_open_alembic_object(AbcArchiveHandle *handle,
 
   return reinterpret_cast<CacheReader *>(abc_reader);
 }
+
+/* ************************************************************************** */
+
+static const PropertyHeader *get_property_header(const IPolyMeshSchema &schema, const char *name)
+{
+  const PropertyHeader *prop_header = schema.getPropertyHeader(name);
+
+  if (prop_header) {
+    return prop_header;
+  }
+
+  ICompoundProperty prop = schema.getArbGeomParams();
+
+  if (!has_property(prop, name)) {
+    return nullptr;
+  }
+
+  return prop.getPropertyHeader(name);
+}
+
+bool ABC_has_vec3_array_property_named(struct CacheReader *reader, const char *name)
+{
+  AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
+
+  if (!abc_reader) {
+    return false;
+  }
+
+  IObject iobject = abc_reader->iobject();
+
+  if (!iobject.valid()) {
+    return false;
+  }
+
+  const ObjectHeader &header = iobject.getHeader();
+
+  if (!IPolyMesh::matches(header)) {
+    return false;
+  }
+
+  IPolyMesh mesh(iobject, kWrapExisting);
+  IPolyMeshSchema schema = mesh.getSchema();
+
+  const PropertyHeader *prop_header = get_property_header(schema, name);
+
+  if (!prop_header) {
+    return false;
+  }
+
+  return IV3fArrayProperty::matches(prop_header->getMetaData());
+}
+
+static V3fArraySamplePtr get_velocity_prop(const IPolyMeshSchema &schema,
+                                           const ISampleSelector &iss,
+                                           const std::string &name)
+{
+  const PropertyHeader *prop_header = schema.getPropertyHeader(name);
+
+  if (prop_header) {
+    const IV3fArrayProperty &velocity_prop = IV3fArrayProperty(schema, name, 0);
+    return velocity_prop.getValue(iss);
+  }
+
+  ICompoundProperty prop = schema.getArbGeomParams();
+
+  if (!has_property(prop, name)) {
+    return V3fArraySamplePtr();
+  }
+
+  const IV3fArrayProperty &velocity_prop = IV3fArrayProperty(prop, name, 0);
+
+  if (velocity_prop) {
+    return velocity_prop.getValue(iss);
+  }
+
+  return V3fArraySamplePtr();
+}
+
+int ABC_read_velocity_cache(CacheReader *reader,
+                            const char *velocity_name,
+                            const float time,
+                            float velocity_scale,
+                            int num_vertices,
+                            float *r_vertex_velocities)
+{
+  AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
+
+  if (!abc_reader) {
+    return -1;
+  }
+
+  IObject iobject = abc_reader->iobject();
+
+  if (!iobject.valid()) {
+    return -1;
+  }
+
+  const ObjectHeader &header = iobject.getHeader();
+
+  if (!IPolyMesh::matches(header)) {
+    return -1;
+  }
+
+  IPolyMesh mesh(iobject, kWrapExisting);
+  IPolyMeshSchema schema = mesh.getSchema();
+  ISampleSelector sample_sel(time);
+  const IPolyMeshSchema::Sample sample = schema.getValue(sample_sel);
+
+  V3fArraySamplePtr velocities = get_velocity_prop(schema, sample_sel, velocity_name);
+
+  if (!velocities) {
+    return -1;
+  }
+
+  float vel[3];
+
+  int num_velocity_vectors = static_cast<int>(velocities->size());
+
+  if (num_velocity_vectors != num_vertices) {
+    return -1;
+  }
+
+  for (size_t i = 0; i < velocities->size(); ++i) {
+    const Imath::V3f &vel_in = (*velocities)[i];
+    copy_zup_from_yup(vel, vel_in.getValue());
+
+    mul_v3_fl(vel, velocity_scale);
+
+    copy_v3_v3(r_vertex_velocities + i * 3, vel);
+  }
+
+  return num_vertices;
+}
diff --git a/source/blender/makesdna/DNA_cachefile_types.h b/source/blender/makesdna/DNA_cachefile_types.h
index 1175c7f0dc0..376041e0cce 100644
--- a/source/blender/makesdna/DNA_cachefile_types.h
+++ b/source/blender/makesdna/DNA_cachefile_types.h
@@ -53,6 +53,13 @@ typedef struct AlembicObjectPath {
   char path[4096];
 } AlembicObjectPath;
 
+/* CacheFile::velocity_unit
+ * Determines what temporal unit is used to interpret velocity vectors for motion blur effects. */
+enum {
+  CACHEFILE_VELOCITY_UNIT_FRAME,
+  CACHEFILE_VELOCITY_UNIT_SECOND,
+};
+
 typedef struct CacheFile {
   ID id;
   struct AnimData *adt;
@@ -78,7 +85,11 @@ typedef struct CacheFile {
   short flag;
   short draw_flag; /* UNUSED */
 
-  char _pad[4];
+  char _pad[3];
+
+  char velocity_unit;
+  /* Name of the velocity property in the Alembic file. */
+  char velocity_name[64];
 
   /* Runtime */
   struct AbcArchiveHandle *handle;
diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h
index 8c564bda3d0..9b1543d0f79 100644
--- a/source/blender/makesdna/DNA_modifier_types.h
+++ b/source/blender/makesdna/DNA_modifier_types.h
@@ -2052,6 +2052,10 @@ enum {
   MOD_NORMALEDIT_MIX_MUL = 3,
 };
 
+typedef struct MeshCacheVertexVelocity {
+  float vel[3];
+} MeshCacheVertexVelocity;
+
 typedef struct MeshSeqCacheModifierData {
   ModifierData modifier;
 
@@ -2060,11 +2064,31 @@ typedef struct MeshSeqCacheModifierData {
   char object_path[1024];
 
   char read_flag;
-  char _pad[7];
+  char _pad[3];
+
+  float velocity_scale;
 
   /* Runtime. */
   struct CacheReader *reader;
   char reader_object_path[1024];
+
+  /* Vertex velocities read from the cache. The velocities are not automatically read during
+   * modifier execution, and therefore have to manually be read when needed. This is only used
+   * through the RNA for now. */
+  struct MeshCacheVertexVelocity *vertex_velocities;
+
+  /* The number of vertices of the Alembic mesh, set when the modifier is executed. */
+  int num_vertices;
+
+  /* Time (in frames or seconds) between two velocity samples. Automatically computed to
+   * scale the velocity vectors at render time for generating proper motion blur data. */
+  float velocity_delta;
+
+  /* Caches the scene time (in seconds) used to lookup data in the Alembic archive when the
+   * modifier was last executed. Used to access Alembic samples through the RNA. */
+  float last_lookup_time;
+
+  int _pad1;
 } MeshSeqCacheModifierData;
 
 /* MeshSeqCacheModifierData.read_flag */
diff --git a/source/blender/makesrna/intern/rna_cachefile.c b/source/blender/makesrna/intern/rna_cachefile.c
index f9275ef1993..00cd95c4492 100644
--- a/source/blender/makesrna/intern/rna_cachefile.c
+++ b/source/blender/makesrna/intern/rna_cachefile.c
@@ -174,6 +174,33 @@ static void rna_def_cachefile(BlenderRNA *brna)
   RNA_def_property_ui_text(
       prop, "Object Paths", "Paths of the objects inside the Alembic archive");
 
+  /* ----------------- Alembic Velocity Attribute ----------------- */
+
+  prop = RNA_def_property(srna, "velocity_name", PROP_STRING, PROP_NONE);
+  RNA_def_property_ui_text(prop,
+                           "Velocity Attribute",
+                           "Name of the Alembic attribute used for generating motion blur data");
+  RNA_def_struct_name_property(srna, prop);
+  RNA_def_property_update(prop, 0, "rna_CacheFile_update");
+  RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+
+  static const EnumPropertyItem velocity_unit_items[] = {
+      {CACHEFILE_VELOCITY_UNIT_SECOND, "SECOND", 0, "Second", ""},
+      {CACHEFILE_VELOCITY_UNIT_FRAME, "FRAME", 0, "Frame", ""},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+  prop = RNA_def_property(srna, "velocity_unit", PROP_ENUM, PROP_NONE);
+  RNA_def_property_enum_sdna(prop, NULL, "velocity_unit");
+  RNA_def_property_enum_items(prop, velocity_unit_items);
+  RNA_def_property_ui_text(
+      prop,
+      "Velocity Unit",
+      "Define how the velocity vectors are interpreted with regard to time, 'frame' means "
+      "the delta time is 1 frame, 'second' means the delta time is 1 / FPS");
+  RNA_def_property_update(prop, 0, "rna_CacheFile_update");
+  RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+
   RNA_define_lib_overridable(false);
 
   rna_def_cachefile_object_paths(brna, prop);
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index d4b1009df4d..ea33307060c 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -113,7 +113,7 @@ const EnumPropertyItem rna_enum_object_modifier_type_items[] = {
     {0, "", 0, N_("Generate"), ""},
     {eModifierType_Array,
      "ARRAY",
-     ICON_MOD_ARRAY,
+  ICON_MOD_ARRAY,
      "Array",
      "Create copies of the shape with offsets"},
     {eModifierType_Bevel,
@@ -1699,6 +1699,51 @@ static bool rna_Modifier_show_expanded_get(PointerRNA *ptr)
   return md->ui_expand_flag & (1 << 0);
 }
 
+static int rna_MeshSequenceCacheModifier_has_velocity_get(PointerRNA *ptr)
+{
+#  ifdef WITH_ALEMBIC
+  MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)ptr->data;
+  return ABC_has_vec3_array_property_named(mcmd->reader, mcmd->cache_file->velocity_name);
+#  else
+  return false;
+  UNUSED_VARS(ptr);
+#  endif
+}
+
+static int rna_MeshSequenceCacheModifier_read_velocity_get(PointerRNA *ptr)
+{
+#  ifdef WITH_ALEMBIC
+  MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)ptr->data;
+
+  if (mcmd->num_vertices == 0) {
+    return 0;
+  }
+
+  if (mcmd->vertex_velocities) {
+    MEM_freeN(mcmd->vertex_velocities);
+  }
+
+  mcmd->vertex_velocities = MEM_mallocN(sizeof(MeshCacheVertexVelocity) * mcmd->num_vertices,
+                                        "Mesh Cache Velocities");
+
+  int num_read = ABC_read_velocity_cache(mcmd->reader,
+                                         mcmd->cache_file->velocity_name,
+                                         mcmd->last_lookup_time,
+                                         mcmd->velocity_scale * mcmd->velocity_delta,
+                                         mcmd->num_vertices,
+                                         (float *)mcmd->vertex_velocities);
+
+  if (num_read == -1 || num_read != mcmd->num_vertices) {
+    return false;
+  }
+
+  return true;
+#  else
+  return false;
+  UNUSED_VARS(ptr);
+#  endif
+}
+
 #else
 
 /* NOTE: *MUST* return subdivision_type property. */
@@ -6066,6 +6111,22 @@ static void rna_def_modifier_meshcache(BlenderRNA *brna)
   RNA_define_lib_overridable(false);
 }
 
+static void rna_def_mesh_cache_velocities(BlenderRNA *brna)
+{
+  StructRNA *srna;
+  PropertyRNA *prop;
+
+  srna = RNA_def_struct(brna, "MeshCacheVertexVelocity", NULL);
+  RNA_def_struct_ui_text(srna, "Mesh Cache Velocity", "Velocity attribute of an Alembic mesh");
+  RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
+
+  prop = RNA_def_property(srna, "velocity", PROP_FLOAT, PROP_VELOCITY);
+  RNA_def_property_array(prop, 3);
+  RNA_def_property_float_sdna(prop, NULL, "vel");
+  RNA_def_property_ui_text(prop, "Velocity", "");
+  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+}
+
 static void rna_def_modifier_meshseqcache(BlenderRNA *brna)
 {
   StructRNA *srna;
@@ -6108,6 +6169,35 @@ static void rna_def_modifier_meshseqcache(BlenderRNA *brna)
 
   RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
+  prop = RNA_def_property(srna, "velocity_scale", PROP_FLOAT, PROP_NONE);
+  RNA_def_property_float_sdna(prop, NULL, "velocity_scale");
+  RNA_def_property_range(prop, 0.0f, FLT_MAX);
+  RNA_def_property_ui_text(
+      prop,
+      "Velocity Scale",
+      "Multiplier used to control the magnitude of the velocity vectors for time effects");
+  RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+  /* -------------------------- Velocity Vectors -------------------------- */
+
+  prop = RNA_def_property(srna, "vertex_velocities", PROP_COLLECTION, PROP_NONE);
+  RNA_def_property_collection_sdna(prop, NULL, "vertex_velocities", "num_vertices");
+  RNA_def_property_struct_type(prop, "MeshCacheVertexVelocity");
+  RNA_def_property_ui_text(
+      prop, "Fluid Mesh Vertices", "Vertices of the fluid mesh generated by simulation");
+
+  rna_def_mesh_cache_velocities(brna);
+
+  prop = RNA_def_property(srna, "has_velocity", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_ui_text(prop, "Has Velocity Cache", "");
+  RNA_def_property_boolean_funcs(prop, "rna_MeshSequenceCacheModifier_has_velocity_get", NULL);
+  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+  prop = RNA_def_property(srna, "read_velocity", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_ui_text(prop, "Read Velocity Cache", "");
+  RNA_def_property_boolean_funcs(prop, "rna_MeshSequenceCacheModifier_read_velocity_get", NULL);
+  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
   RNA_define_lib_overridable(false);
 }
 
diff --git a/source/blender/modifiers/intern/MOD_meshsequencecache.c b/source/blender/modifiers/intern/MOD_meshsequencecache.c
index 8f6676dd0b2..5513e6b4971 100644
--- a/source/blender/modifiers/intern/MOD_meshsequencecache.c
+++ b/source/blender/modifiers/intern/MOD_meshsequencecache.c
@@ -33,6 +33,8 @@
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
 
+#include "MEM_guardedalloc.h"
+
 #include "BKE_cachefile.h"
 #include "BKE_context.h"
 #include "BKE_lib_query.h"
@@ -65,6 +67,9 @@ static void initData(ModifierData *md)
   mcmd->cache_file = NULL;
   mcmd->object_path[0] = '\0';
   mcmd->read_flag = MOD_MESHSEQ_READ_ALL;
+  mcmd->velocity_scale = 1.0f;
+  mcmd->vertex_velocities = NULL;
+  mcmd->num_vertices = 0;
 
   mcmd->reader = NULL;
   mcmd->reader_object_path[0] = '\0';
@@ -91,6 +96,10 @@ static void freeData(ModifierData *md)
     mcmd->reader_object_path[0] = '\0';
     BKE_cachefile_reader_free(mcmd->cache_file, &mcmd->reader);
   }
+
+  if (mcmd->vertex_velocities) {
+    MEM_freeN(mcmd->vertex_velocities);
+  }
 }
 
 static bool isDisabled(const struct Scene *UNUSED(scene),
@@ -154,6 +163,17 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
   Mesh *result = ABC_read_mesh(mcmd->reader, ctx->object, mesh, time, &err_str, mcmd->read_flag);
 
+  mcmd->velocity_delta = 1.0f;
+  if (mcmd->cache_file->velocity_unit == CACHEFILE_VELOCITY_UNIT_SECOND) {
+    mcmd->velocity_delta /= FPS;
+  }
+
+  mcmd->last_lookup_time = time;
+
+  if (result != NULL) {
+    mcmd->num_vertices = result->totvert;
+  }
+
   if (err_str) {
     BKE_modifier_set_error(md, "%s", err_str);
   }
@@ -221,6 +241,8 @@ static void panel_draw(const bContext *C, Panel *panel)
     uiItemR(layout, &ptr, "read_data", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
   }
 
+  uiItemR(layout, &ptr, "velocity_scale", 0, NULL, ICON_NONE);
+
   modifier_panel_end(layout, &ptr);
 }