Alembic Procedural: refactor data reading

This splits the data reading logic from the AlembicObject class and moves it to
separate files to better enforce a separation of concern. The goal was to simplify
and improve the logic to read data from an Alembic archive.

Since the procedural loads data for the entire animation, this requires looping
over the frame range and looking up data for each frame. Previously those loops
would be duplicated over the entire code causing divergences in how we might
skip or deduplicate data across frames (if only some data change over time and
not other on the same object, e.g. vertices and triangles might not have the
same animation times), and therefore, bugs.

Now, we only use a single function with callback to loop over the geometry data
for each requested frame, and another one to loop over attributes. Given how
attributes are accessed it is a bit tricky to simplify further and only use a
ingle function, however, this is left as a further improvement as it is not
impossible.

To read the data, we now use a set of structures to hold which data to read.
Those structures might seem redundant with the Alembic schemas as they are
somewhat a copy of the schemas' structures, however they will allow us in the
long run to treat the data of one object type as the data of another object
type (e.g. to ignore subdivision, or only loading the vertices as point clouds).

For attributes, this new system allows us to read arbitrary attributes, although
with some limitations still:
* only subdivision and polygon meshes are supported due to lack of examples for
  curve data;
* some data types might be missing: we support float, float2, float3, booleans,
  normals, uvs, rgb, and rbga at the moment, other types can be trivially added
* some attribute scopes (or domains) are not handled, again, due to lack of example
  files
* color types are always interpreted as vertex colors

5 files changed, 1268 insertions, 840 deletions

diff --git a/intern/cycles/render/CMakeLists.txt b/intern/cycles/render/CMakeLists.txt
index c67919b375a..feead27c5ca 100644
--- a/intern/cycles/render/CMakeLists.txt
+++ b/intern/cycles/render/CMakeLists.txt
@@ -24,6 +24,7 @@ set(INC_SYS
 
 set(SRC
   alembic.cpp
+  alembic_read.cpp
   attribute.cpp
   background.cpp
   bake.cpp
@@ -67,6 +68,7 @@ set(SRC
 
 set(SRC_HEADERS
   alembic.h
+  alembic_read.h
   attribute.h
   bake.h
   background.h
diff --git a/intern/cycles/render/alembic.cpp b/intern/cycles/render/alembic.cpp
index c3a7b20f512..0dda8785bb3 100644
--- a/intern/cycles/render/alembic.cpp
+++ b/intern/cycles/render/alembic.cpp
@@ -16,6 +16,7 @@
 
 #include "render/alembic.h"
 
+#include "render/alembic_read.h"
 #include "render/camera.h"
 #include "render/curves.h"
 #include "render/mesh.h"
@@ -36,6 +37,47 @@ CCL_NAMESPACE_BEGIN
 
 /* TODO(@kevindietrich): motion blur support */
 
+template<typename SchemaType>
+static vector<FaceSetShaderIndexPair> parse_face_sets_for_shader_assignment(
+    SchemaType &schema, const array<Node *> &used_shaders)
+{
+  vector<FaceSetShaderIndexPair> result;
+
+  std::vector<std::string> face_set_names;
+  schema.getFaceSetNames(face_set_names);
+
+  if (face_set_names.empty()) {
+    return result;
+  }
+
+  for (const std::string &face_set_name : face_set_names) {
+    int shader_index = 0;
+
+    for (Node *node : used_shaders) {
+      if (node->name == face_set_name) {
+        break;
+      }
+
+      ++shader_index;
+    }
+
+    if (shader_index >= used_shaders.size()) {
+      /* use the first shader instead if none was found */
+      shader_index = 0;
+    }
+
+    const Alembic::AbcGeom::IFaceSet face_set = schema.getFaceSet(face_set_name);
+
+    if (!face_set.valid()) {
+      continue;
+    }
+
+    result.push_back({face_set, shader_index});
+  }
+
+  return result;
+}
+
 void CachedData::clear()
 {
   attributes.clear();
@@ -54,7 +96,7 @@ void CachedData::clear()
   subd_start_corner.clear();
   transforms.clear();
   triangles.clear();
-  triangles_loops.clear();
+  uv_loops.clear();
   vertices.clear();
 
   for (CachedAttribute &attr : attributes) {
@@ -101,7 +143,7 @@ bool CachedData::is_constant() const
   CHECK_IF_CONSTANT(subd_start_corner)
   CHECK_IF_CONSTANT(transforms)
   CHECK_IF_CONSTANT(triangles)
-  CHECK_IF_CONSTANT(triangles_loops)
+  CHECK_IF_CONSTANT(uv_loops)
   CHECK_IF_CONSTANT(vertices)
 
   for (const CachedAttribute &attr : attributes) {
@@ -140,7 +182,7 @@ void CachedData::invalidate_last_loaded_time(bool attributes_only)
   subd_start_corner.invalidate_last_loaded_time();
   transforms.invalidate_last_loaded_time();
   triangles.invalidate_last_loaded_time();
-  triangles_loops.invalidate_last_loaded_time();
+  uv_loops.invalidate_last_loaded_time();
   vertices.invalidate_last_loaded_time();
 }
 
@@ -161,7 +203,7 @@ void CachedData::set_time_sampling(TimeSampling time_sampling)
   subd_start_corner.set_time_sampling(time_sampling);
   transforms.set_time_sampling(time_sampling);
   triangles.set_time_sampling(time_sampling);
-  triangles_loops.set_time_sampling(time_sampling);
+  uv_loops.set_time_sampling(time_sampling);
   vertices.set_time_sampling(time_sampling);
 
   for (CachedAttribute &attr : attributes) {
@@ -169,36 +211,6 @@ void CachedData::set_time_sampling(TimeSampling time_sampling)
   }
 }
 
-/* get the sample times to load data for the given the start and end frame of the procedural */
-static set<chrono_t> get_relevant_sample_times(AlembicProcedural *proc,
-                                               const TimeSampling &time_sampling,
-                                               size_t num_samples)
-{
-  set<chrono_t> result;
-
-  if (num_samples < 2) {
-    result.insert(0.0);
-    return result;
-  }
-
-  double start_frame = (double)(proc->get_start_frame() / proc->get_frame_rate());
-  double end_frame = (double)((proc->get_end_frame() + 1) / proc->get_frame_rate());
-
-  size_t start_index = time_sampling.getFloorIndex(start_frame, num_samples).first;
-  size_t end_index = time_sampling.getCeilIndex(end_frame, num_samples).first;
-
-  for (size_t i = start_index; i < end_index; ++i) {
-    result.insert(time_sampling.getSampleTime(i));
-  }
-
-  return result;
-}
-
-static float3 make_float3_from_yup(const V3f &v)
-{
-  return make_float3(v.x, -v.z, v.y);
-}
-
 static M44d convert_yup_zup(const M44d &mtx, float scale_mult)
 {
   V3d scale, shear, rotation, translation;
@@ -366,249 +378,6 @@ static Transform make_transform(const M44d &a, float scale)
   return trans;
 }
 
-static void add_uvs(AlembicProcedural *proc,
-                    const IV2fGeomParam &uvs,
-                    CachedData &cached_data,
-                    Progress &progress)
-{
-  if (uvs.getScope() != kFacevaryingScope) {
-    return;
-  }
-
-  const TimeSamplingPtr time_sampling_ptr = uvs.getTimeSampling();
-
-  TimeSampling time_sampling;
-  if (time_sampling_ptr) {
-    time_sampling = *time_sampling_ptr;
-  }
-
-  std::string name = Alembic::Abc::GetSourceName(uvs.getMetaData());
-
-  /* According to the convention, primary UVs should have had their name
-   * set using Alembic::Abc::SetSourceName, but you can't expect everyone
-   * to follow it! :) */
-  if (name.empty()) {
-    name = uvs.getName();
-  }
-
-  CachedData::CachedAttribute &attr = cached_data.add_attribute(ustring(name), time_sampling);
-  attr.std = ATTR_STD_UV;
-
-  ccl::set<chrono_t> times = get_relevant_sample_times(proc, time_sampling, uvs.getNumSamples());
-
-  /* Keys used to determine if the UVs do actually change over time. */
-  ArraySample::Key previous_indices_key;
-  ArraySample::Key previous_values_key;
-
-  foreach (chrono_t time, times) {
-    if (progress.get_cancel()) {
-      return;
-    }
-
-    const ISampleSelector iss = ISampleSelector(time);
-    const IV2fGeomParam::Sample uvsample = uvs.getIndexedValue(iss);
-
-    if (!uvsample.valid()) {
-      continue;
-    }
-
-    const array<int3> *triangles =
-        cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
-    const array<int3> *triangles_loops =
-        cached_data.triangles_loops.data_for_time_no_check(time).get_data_or_null();
-
-    if (!triangles || !triangles_loops) {
-      continue;
-    }
-
-    array<char> data;
-    data.resize(triangles->size() * 3 * sizeof(float2));
-
-    float2 *data_float2 = reinterpret_cast<float2 *>(data.data());
-
-    const ArraySample::Key indices_key = uvsample.getIndices()->getKey();
-    const ArraySample::Key values_key = uvsample.getVals()->getKey();
-
-    if (indices_key == previous_indices_key && values_key == previous_values_key) {
-      attr.data.reuse_data_for_last_time(time);
-    }
-    else {
-      const unsigned int *indices = uvsample.getIndices()->get();
-      const V2f *values = uvsample.getVals()->get();
-
-      for (const int3 &loop : *triangles_loops) {
-        unsigned int v0 = indices[loop.x];
-        unsigned int v1 = indices[loop.y];
-        unsigned int v2 = indices[loop.z];
-
-        data_float2[0] = make_float2(values[v0][0], values[v0][1]);
-        data_float2[1] = make_float2(values[v1][0], values[v1][1]);
-        data_float2[2] = make_float2(values[v2][0], values[v2][1]);
-        data_float2 += 3;
-      }
-
-      attr.data.add_data(data, time);
-    }
-
-    previous_indices_key = indices_key;
-    previous_values_key = values_key;
-  }
-}
-
-static void add_normals(const Int32ArraySamplePtr face_indices,
-                        const IN3fGeomParam &normals,
-                        double time,
-                        CachedData &cached_data)
-{
-  switch (normals.getScope()) {
-    case kFacevaryingScope: {
-      const ISampleSelector iss = ISampleSelector(time);
-      const IN3fGeomParam::Sample sample = normals.getExpandedValue(iss);
-
-      if (!sample.valid()) {
-        return;
-      }
-
-      CachedData::CachedAttribute &attr = cached_data.add_attribute(ustring(normals.getName()),
-                                                                    *normals.getTimeSampling());
-      attr.std = ATTR_STD_VERTEX_NORMAL;
-
-      const array<float3> *vertices =
-          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
-
-      if (!vertices) {
-        return;
-      }
-
-      array<char> data;
-      data.resize(vertices->size() * sizeof(float3));
-
-      float3 *data_float3 = reinterpret_cast<float3 *>(data.data());
-
-      const int *face_indices_array = face_indices->get();
-      const N3fArraySamplePtr values = sample.getVals();
-
-      for (size_t i = 0; i < face_indices->size(); ++i) {
-        int point_index = face_indices_array[i];
-        data_float3[point_index] = make_float3_from_yup(values->get()[i]);
-      }
-
-      attr.data.add_data(data, time);
-      break;
-    }
-    case kVaryingScope:
-    case kVertexScope: {
-      const ISampleSelector iss = ISampleSelector(time);
-      const IN3fGeomParam::Sample sample = normals.getExpandedValue(iss);
-
-      if (!sample.valid()) {
-        return;
-      }
-
-      CachedData::CachedAttribute &attr = cached_data.add_attribute(ustring(normals.getName()),
-                                                                    *normals.getTimeSampling());
-      attr.std = ATTR_STD_VERTEX_NORMAL;
-
-      const array<float3> *vertices =
-          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
-
-      if (!vertices) {
-        return;
-      }
-
-      array<char> data;
-      data.resize(vertices->size() * sizeof(float3));
-
-      float3 *data_float3 = reinterpret_cast<float3 *>(data.data());
-
-      const Imath::V3f *values = sample.getVals()->get();
-
-      for (size_t i = 0; i < vertices->size(); ++i) {
-        data_float3[i] = make_float3_from_yup(values[i]);
-      }
-
-      attr.data.add_data(data, time);
-
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-}
-
-static void add_positions(const P3fArraySamplePtr positions, double time, CachedData &cached_data)
-{
-  if (!positions) {
-    return;
-  }
-
-  array<float3> vertices;
-  vertices.reserve(positions->size());
-
-  for (size_t i = 0; i < positions->size(); i++) {
-    V3f f = positions->get()[i];
-    vertices.push_back_reserved(make_float3_from_yup(f));
-  }
-
-  cached_data.vertices.add_data(vertices, time);
-}
-
-static void add_triangles(const Int32ArraySamplePtr face_counts,
-                          const Int32ArraySamplePtr face_indices,
-                          double time,
-                          CachedData &cached_data,
-                          const array<int> &polygon_to_shader)
-{
-  if (!face_counts || !face_indices) {
-    return;
-  }
-
-  const size_t num_faces = face_counts->size();
-  const int *face_counts_array = face_counts->get();
-  const int *face_indices_array = face_indices->get();
-
-  size_t num_triangles = 0;
-  for (size_t i = 0; i < face_counts->size(); i++) {
-    num_triangles += face_counts_array[i] - 2;
-  }
-
-  array<int> shader;
-  array<int3> triangles;
-  array<int3> triangles_loops;
-  shader.reserve(num_triangles);
-  triangles.reserve(num_triangles);
-  triangles_loops.reserve(num_triangles);
-  int index_offset = 0;
-
-  for (size_t i = 0; i < num_faces; i++) {
-    int current_shader = 0;
-
-    if (!polygon_to_shader.empty()) {
-      current_shader = polygon_to_shader[i];
-    }
-
-    for (int j = 0; j < face_counts_array[i] - 2; j++) {
-      int v0 = face_indices_array[index_offset];
-      int v1 = face_indices_array[index_offset + j + 1];
-      int v2 = face_indices_array[index_offset + j + 2];
-
-      shader.push_back_reserved(current_shader);
-
-      /* Alembic orders the loops following the RenderMan convention, so need to go in reverse. */
-      triangles.push_back_reserved(make_int3(v2, v1, v0));
-      triangles_loops.push_back_reserved(
-          make_int3(index_offset + j + 2, index_offset + j + 1, index_offset));
-    }
-
-    index_offset += face_counts_array[i];
-  }
-
-  cached_data.triangles.add_data(triangles, time);
-  cached_data.triangles_loops.add_data(triangles_loops, time);
-  cached_data.shader.add_data(shader, time);
-}
-
 NODE_DEFINE(AlembicObject)
 {
   NodeType *type = NodeType::add("alembic_object", create);
@@ -648,398 +417,141 @@ bool AlembicObject::has_data_loaded() const
   return data_loaded;
 }
 
-void AlembicObject::update_shader_attributes(const ICompoundProperty &arb_geom_params,
-                                             Progress &progress)
-{
-  AttributeRequestSet requested_attributes = get_requested_attributes();
-
-  foreach (const AttributeRequest &attr, requested_attributes.requests) {
-    if (progress.get_cancel()) {
-      return;
-    }
-
-    bool attr_exists = false;
-    foreach (CachedData::CachedAttribute &cached_attr, cached_data.attributes) {
-      if (cached_attr.name == attr.name) {
-        attr_exists = true;
-        break;
-      }
-    }
-
-    if (attr_exists) {
-      continue;
-    }
-
-    read_attribute(arb_geom_params, attr.name, progress);
-  }
-
-  cached_data.invalidate_last_loaded_time(true);
-  need_shader_update = false;
-}
-
-template<typename SchemaType>
-void AlembicObject::read_face_sets(SchemaType &schema,
-                                   array<int> &polygon_to_shader,
-                                   ISampleSelector sample_sel)
+void AlembicObject::load_data_in_cache(CachedData &cached_data,
+                                       AlembicProcedural *proc,
+                                       IPolyMeshSchema &schema,
+                                       Progress &progress)
 {
-  std::vector<std::string> face_sets;
-  schema.getFaceSetNames(face_sets);
-
-  if (face_sets.empty()) {
-    return;
-  }
-
-  const Int32ArraySamplePtr face_counts = schema.getFaceCountsProperty().getValue();
-
-  polygon_to_shader.resize(face_counts->size());
-
-  foreach (const std::string &face_set_name, face_sets) {
-    int shader_index = 0;
-
-    foreach (Node *node, get_used_shaders()) {
-      if (node->name == face_set_name) {
-        break;
-      }
-
-      ++shader_index;
-    }
-
-    if (shader_index >= get_used_shaders().size()) {
-      /* use the first shader instead if none was found */
-      shader_index = 0;
-    }
-
-    const IFaceSet face_set = schema.getFaceSet(face_set_name);
-
-    if (!face_set.valid()) {
-      continue;
-    }
-
-    const IFaceSetSchema face_schem = face_set.getSchema();
-    const IFaceSetSchema::Sample face_sample = face_schem.getValue(sample_sel);
-    const Int32ArraySamplePtr group_faces = face_sample.getFaces();
-    const size_t num_group_faces = group_faces->size();
-
-    for (size_t l = 0; l < num_group_faces; l++) {
-      size_t pos = (*group_faces)[l];
-
-      if (pos >= polygon_to_shader.size()) {
-        continue;
-      }
-
-      polygon_to_shader[pos] = shader_index;
-    }
-  }
-}
-
-void AlembicObject::load_all_data(AlembicProcedural *proc,
-                                  IPolyMeshSchema &schema,
-                                  Progress &progress)
-{
-  cached_data.clear();
-
   /* Only load data for the original Geometry. */
   if (instance_of) {
     return;
   }
 
-  const TimeSamplingPtr time_sampling = schema.getTimeSampling();
-  cached_data.set_time_sampling(*time_sampling);
-
-  const IN3fGeomParam &normals = schema.getNormalsParam();
-
-  ccl::set<chrono_t> times = get_relevant_sample_times(
-      proc, *time_sampling, schema.getNumSamples());
-
-  /* Key used to determine if the triangles change over time, if the key is the same as the
-   * last one, we can avoid creating a new entry in the cache and simply point to the last
-   * frame. */
-  ArraySample::Key previous_key;
-
-  /* read topology */
-  foreach (chrono_t time, times) {
-    if (progress.get_cancel()) {
-      return;
-    }
-
-    const ISampleSelector iss = ISampleSelector(time);
-    const IPolyMeshSchema::Sample sample = schema.getValue(iss);
-
-    add_positions(sample.getPositions(), time, cached_data);
-
-    /* Only copy triangles for other frames if the topology is changing over time as well. */
-    if (schema.getTopologyVariance() != kHomogenousTopology || cached_data.triangles.size() == 0) {
-      const ArraySample::Key key = sample.getFaceIndices()->getKey();
-
-      if (key == previous_key) {
-        cached_data.triangles.reuse_data_for_last_time(time);
-        cached_data.triangles_loops.reuse_data_for_last_time(time);
-        cached_data.shader.reuse_data_for_last_time(time);
-      }
-      else {
-        /* start by reading the face sets (per face shader), as we directly split polygons to
-         * triangles
-         */
-        array<int> polygon_to_shader;
-        read_face_sets(schema, polygon_to_shader, iss);
-
-        add_triangles(
-            sample.getFaceCounts(), sample.getFaceIndices(), time, cached_data, polygon_to_shader);
-      }
+  cached_data.clear();
 
-      previous_key = key;
-    }
+  PolyMeshSchemaData data;
+  data.topology_variance = schema.getTopologyVariance();
+  data.time_sampling = schema.getTimeSampling();
+  data.positions = schema.getPositionsProperty();
+  data.face_counts = schema.getFaceCountsProperty();
+  data.face_indices = schema.getFaceIndicesProperty();
+  data.normals = schema.getNormalsParam();
+  data.num_samples = schema.getNumSamples();
+  data.shader_face_sets = parse_face_sets_for_shader_assignment(schema, get_used_shaders());
 
-    if (normals.valid()) {
-      add_normals(sample.getFaceIndices(), normals, time, cached_data);
-    }
-  }
+  read_geometry_data(proc, cached_data, data, progress);
 
   if (progress.get_cancel()) {
     return;
   }
 
-  update_shader_attributes(schema.getArbGeomParams(), progress);
+  /* Use the schema as the base compound property to also be able to look for top level properties.
+   */
+  read_attributes(
+      proc, cached_data, schema, schema.getUVsParam(), get_requested_attributes(), progress);
 
   if (progress.get_cancel()) {
     return;
   }
 
-  const IV2fGeomParam &uvs = schema.getUVsParam();
-
-  if (uvs.valid()) {
-    add_uvs(proc, uvs, cached_data, progress);
-  }
-
+  cached_data.invalidate_last_loaded_time(true);
   data_loaded = true;
 }
 
-void AlembicObject::load_all_data(AlembicProcedural *proc, ISubDSchema &schema, Progress &progress)
+void AlembicObject::load_data_in_cache(CachedData &cached_data,
+                                       AlembicProcedural *proc,
+                                       ISubDSchema &schema,
+                                       Progress &progress)
 {
-  cached_data.clear();
-
   /* Only load data for the original Geometry. */
   if (instance_of) {
     return;
   }
 
-  AttributeRequestSet requested_attributes = get_requested_attributes();
-
-  const TimeSamplingPtr time_sampling = schema.getTimeSampling();
-  cached_data.set_time_sampling(*time_sampling);
-
-  ccl::set<chrono_t> times = get_relevant_sample_times(
-      proc, *time_sampling, schema.getNumSamples());
-
-  /* read topology */
-  foreach (chrono_t time, times) {
-    if (progress.get_cancel()) {
-      return;
-    }
-
-    const ISampleSelector iss = ISampleSelector(time);
-    const ISubDSchema::Sample sample = schema.getValue(iss);
-
-    add_positions(sample.getPositions(), time, cached_data);
-
-    const Int32ArraySamplePtr face_counts = sample.getFaceCounts();
-    const Int32ArraySamplePtr face_indices = sample.getFaceIndices();
-
-    /* start by reading the face sets (per face shader) */
-    array<int> polygon_to_shader;
-    read_face_sets(schema, polygon_to_shader, iss);
-
-    /* read faces */
-    array<int> subd_start_corner;
-    array<int> shader;
-    array<int> subd_num_corners;
-    array<bool> subd_smooth;
-    array<int> subd_ptex_offset;
-    array<int> subd_face_corners;
-
-    const size_t num_faces = face_counts->size();
-    const int *face_counts_array = face_counts->get();
-    const int *face_indices_array = face_indices->get();
-
-    int num_ngons = 0;
-    int num_corners = 0;
-    for (size_t i = 0; i < face_counts->size(); i++) {
-      num_ngons += (face_counts_array[i] == 4 ? 0 : 1);
-      num_corners += face_counts_array[i];
-    }
-
-    subd_start_corner.reserve(num_faces);
-    subd_num_corners.reserve(num_faces);
-    subd_smooth.reserve(num_faces);
-    subd_ptex_offset.reserve(num_faces);
-    shader.reserve(num_faces);
-    subd_face_corners.reserve(num_corners);
-
-    int start_corner = 0;
-    int current_shader = 0;
-    int ptex_offset = 0;
-
-    for (size_t i = 0; i < face_counts->size(); i++) {
-      num_corners = face_counts_array[i];
-
-      if (!polygon_to_shader.empty()) {
-        current_shader = polygon_to_shader[i];
-      }
-
-      subd_start_corner.push_back_reserved(start_corner);
-      subd_num_corners.push_back_reserved(num_corners);
-
-      for (int j = 0; j < num_corners; ++j) {
-        subd_face_corners.push_back_reserved(face_indices_array[start_corner + j]);
-      }
-
-      shader.push_back_reserved(current_shader);
-      subd_smooth.push_back_reserved(1);
-      subd_ptex_offset.push_back_reserved(ptex_offset);
-
-      ptex_offset += (num_corners == 4 ? 1 : num_corners);
-
-      start_corner += num_corners;
-    }
-
-    cached_data.shader.add_data(shader, time);
-    cached_data.subd_start_corner.add_data(subd_start_corner, time);
-    cached_data.subd_num_corners.add_data(subd_num_corners, time);
-    cached_data.subd_smooth.add_data(subd_smooth, time);
-    cached_data.subd_ptex_offset.add_data(subd_ptex_offset, time);
-    cached_data.subd_face_corners.add_data(subd_face_corners, time);
-    cached_data.num_ngons.add_data(num_ngons, time);
-
-    /* read creases */
-    Int32ArraySamplePtr creases_length = sample.getCreaseLengths();
-    Int32ArraySamplePtr creases_indices = sample.getCreaseIndices();
-    FloatArraySamplePtr creases_sharpnesses = sample.getCreaseSharpnesses();
-
-    if (creases_length && creases_indices && creases_sharpnesses) {
-      array<int> creases_edge;
-      array<float> creases_weight;
-
-      creases_edge.reserve(creases_sharpnesses->size() * 2);
-      creases_weight.reserve(creases_sharpnesses->size());
-
-      int length_offset = 0;
-      int weight_offset = 0;
-      for (size_t c = 0; c < creases_length->size(); ++c) {
-        const int crease_length = creases_length->get()[c];
-
-        for (size_t j = 0; j < crease_length - 1; ++j) {
-          creases_edge.push_back_reserved(creases_indices->get()[length_offset + j]);
-          creases_edge.push_back_reserved(creases_indices->get()[length_offset + j + 1]);
-          creases_weight.push_back_reserved(creases_sharpnesses->get()[weight_offset++]);
-        }
-
-        length_offset += crease_length;
-      }
-
-      cached_data.subd_creases_edge.add_data(creases_edge, time);
-      cached_data.subd_creases_weight.add_data(creases_weight, time);
-    }
-  }
+  cached_data.clear();
 
-  /* TODO(@kevindietrich) : attributes, need test files */
+  SubDSchemaData data;
+  data.time_sampling = schema.getTimeSampling();
+  data.num_samples = schema.getNumSamples();
+  data.topology_variance = schema.getTopologyVariance();
+  data.face_counts = schema.getFaceCountsProperty();
+  data.face_indices = schema.getFaceIndicesProperty();
+  data.positions = schema.getPositionsProperty();
+  data.face_varying_interpolate_boundary = schema.getFaceVaryingInterpolateBoundaryProperty();
+  data.face_varying_propagate_corners = schema.getFaceVaryingPropagateCornersProperty();
+  data.interpolate_boundary = schema.getInterpolateBoundaryProperty();
+  data.crease_indices = schema.getCreaseIndicesProperty();
+  data.crease_lengths = schema.getCreaseLengthsProperty();
+  data.crease_sharpnesses = schema.getCreaseSharpnessesProperty();
+  data.corner_indices = schema.getCornerIndicesProperty();
+  data.corner_sharpnesses = schema.getCornerSharpnessesProperty();
+  data.holes = schema.getHolesProperty();
+  data.subdivision_scheme = schema.getSubdivisionSchemeProperty();
+  data.velocities = schema.getVelocitiesProperty();
+  data.shader_face_sets = parse_face_sets_for_shader_assignment(schema, get_used_shaders());
+
+  read_geometry_data(proc, cached_data, data, progress);
 
   if (progress.get_cancel()) {
     return;
   }
 
+  /* Use the schema as the base compound property to also be able to look for top level properties.
+   */
+  read_attributes(proc,
+                  cached_data,
+                  schema.getArbGeomParams(),
+                  schema.getUVsParam(),
+                  get_requested_attributes(),
+                  progress);
+
+  cached_data.invalidate_last_loaded_time(true);
   data_loaded = true;
 }
 
-void AlembicObject::load_all_data(AlembicProcedural *proc,
-                                  const ICurvesSchema &schema,
-                                  Progress &progress,
-                                  float default_radius)
+void AlembicObject::load_data_in_cache(CachedData &cached_data,
+                                       AlembicProcedural *proc,
+                                       const ICurvesSchema &schema,
+                                       Progress &progress)
 {
-  cached_data.clear();
-
   /* Only load data for the original Geometry. */
   if (instance_of) {
     return;
   }
 
-  const TimeSamplingPtr time_sampling = schema.getTimeSampling();
-  cached_data.set_time_sampling(*time_sampling);
-
-  ccl::set<chrono_t> times = get_relevant_sample_times(
-      proc, *time_sampling, schema.getNumSamples());
-
-  foreach (chrono_t time, times) {
-    if (progress.get_cancel()) {
-      return;
-    }
-
-    const ISampleSelector iss = ISampleSelector(time);
-    const ICurvesSchema::Sample sample = schema.getValue(iss);
-
-    const Int32ArraySamplePtr curves_num_vertices = sample.getCurvesNumVertices();
-    const P3fArraySamplePtr position = sample.getPositions();
-
-    const IFloatGeomParam widths_param = schema.getWidthsParam();
-    FloatArraySamplePtr radiuses;
-
-    if (widths_param.valid()) {
-      IFloatGeomParam::Sample wsample = widths_param.getExpandedValue(iss);
-      radiuses = wsample.getVals();
-    }
-
-    const bool do_radius = (radiuses != nullptr) && (radiuses->size() > 1);
-    float radius = (radiuses && radiuses->size() == 1) ? (*radiuses)[0] : default_radius;
-
-    array<float3> curve_keys;
-    array<float> curve_radius;
-    array<int> curve_first_key;
-    array<int> curve_shader;
-
-    const bool is_homogenous = schema.getTopologyVariance() == kHomogenousTopology;
-
-    curve_keys.reserve(position->size());
-    curve_radius.reserve(position->size());
-    curve_first_key.reserve(curves_num_vertices->size());
-    curve_shader.reserve(curves_num_vertices->size());
-
-    int offset = 0;
-    for (size_t i = 0; i < curves_num_vertices->size(); i++) {
-      const int num_vertices = curves_num_vertices->get()[i];
-
-      for (int j = 0; j < num_vertices; j++) {
-        const V3f &f = position->get()[offset + j];
-        curve_keys.push_back_reserved(make_float3_from_yup(f));
-
-        if (do_radius) {
-          radius = (*radiuses)[offset + j];
-        }
-
-        curve_radius.push_back_reserved(radius * radius_scale);
-      }
-
-      if (!is_homogenous || cached_data.curve_first_key.size() == 0) {
-        curve_first_key.push_back_reserved(offset);
-        curve_shader.push_back_reserved(0);
-      }
-
-      offset += num_vertices;
-    }
+  cached_data.clear();
 
-    cached_data.curve_keys.add_data(curve_keys, time);
-    cached_data.curve_radius.add_data(curve_radius, time);
+  CurvesSchemaData data;
+  data.positions = schema.getPositionsProperty();
+  data.position_weights = schema.getPositionWeightsProperty();
+  data.normals = schema.getNormalsParam();
+  data.knots = schema.getKnotsProperty();
+  data.orders = schema.getOrdersProperty();
+  data.widths = schema.getWidthsParam();
+  data.velocities = schema.getVelocitiesProperty();
+  data.time_sampling = schema.getTimeSampling();
+  data.topology_variance = schema.getTopologyVariance();
+  data.num_samples = schema.getNumSamples();
+  data.num_vertices = schema.getNumVerticesProperty();
+  data.default_radius = proc->get_default_radius();
+  data.radius_scale = get_radius_scale();
+
+  read_geometry_data(proc, cached_data, data, progress);
 
-    if (!is_homogenous || cached_data.curve_first_key.size() == 0) {
-      cached_data.curve_first_key.add_data(curve_first_key, time);
-      cached_data.curve_shader.add_data(curve_shader, time);
-    }
+  if (progress.get_cancel()) {
+    return;
   }
 
-  // TODO(@kevindietrich): attributes, need example files
+  /* Use the schema as the base compound property to also be able to look for top level properties.
+   */
+  read_attributes(
+      proc, cached_data, schema, schema.getUVsParam(), get_requested_attributes(), progress);
 
+  cached_data.invalidate_last_loaded_time(true);
   data_loaded = true;
 }
 
-void AlembicObject::setup_transform_cache(float scale)
+void AlembicObject::setup_transform_cache(CachedData &cached_data, float scale)
 {
   cached_data.transforms.clear();
   cached_data.transforms.invalidate_last_loaded_time();
@@ -1102,188 +614,6 @@ AttributeRequestSet AlembicObject::get_requested_attributes()
   return requested_attributes;
 }
 
-void AlembicObject::read_attribute(const ICompoundProperty &arb_geom_params,
-                                   const ustring &attr_name,
-                                   Progress &progress)
-{
-  const PropertyHeader *prop = arb_geom_params.getPropertyHeader(attr_name.c_str());
-
-  if (prop == nullptr) {
-    return;
-  }
-
-  if (IV2fProperty::matches(prop->getMetaData()) && Alembic::AbcGeom::isUV(*prop)) {
-    const IV2fGeomParam &param = IV2fGeomParam(arb_geom_params, prop->getName());
-
-    CachedData::CachedAttribute &attribute = cached_data.add_attribute(attr_name,
-                                                                       *param.getTimeSampling());
-
-    for (size_t i = 0; i < param.getNumSamples(); ++i) {
-      if (progress.get_cancel()) {
-        return;
-      }
-
-      ISampleSelector iss = ISampleSelector(index_t(i));
-
-      IV2fGeomParam::Sample sample;
-      param.getIndexed(sample, iss);
-
-      const chrono_t time = param.getTimeSampling()->getSampleTime(index_t(i));
-
-      if (param.getScope() == kFacevaryingScope) {
-        V2fArraySamplePtr values = sample.getVals();
-        UInt32ArraySamplePtr indices = sample.getIndices();
-
-        attribute.std = ATTR_STD_NONE;
-        attribute.element = ATTR_ELEMENT_CORNER;
-        attribute.type_desc = TypeFloat2;
-
-        const array<int3> *triangles =
-            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
-        const array<int3> *triangles_loops =
-            cached_data.triangles_loops.data_for_time_no_check(time).get_data_or_null();
-
-        if (!triangles || !triangles_loops) {
-          return;
-        }
-
-        array<char> data;
-        data.resize(triangles->size() * 3 * sizeof(float2));
-
-        float2 *data_float2 = reinterpret_cast<float2 *>(data.data());
-
-        for (const int3 &loop : *triangles_loops) {
-          unsigned int v0 = (*indices)[loop.x];
-          unsigned int v1 = (*indices)[loop.y];
-          unsigned int v2 = (*indices)[loop.z];
-
-          data_float2[0] = make_float2((*values)[v0][0], (*values)[v0][1]);
-          data_float2[1] = make_float2((*values)[v1][0], (*values)[v1][1]);
-          data_float2[2] = make_float2((*values)[v2][0], (*values)[v2][1]);
-          data_float2 += 3;
-        }
-
-        attribute.data.set_time_sampling(*param.getTimeSampling());
-        attribute.data.add_data(data, time);
-      }
-    }
-  }
-  else if (IC3fProperty::matches(prop->getMetaData())) {
-    const IC3fGeomParam &param = IC3fGeomParam(arb_geom_params, prop->getName());
-
-    CachedData::CachedAttribute &attribute = cached_data.add_attribute(attr_name,
-                                                                       *param.getTimeSampling());
-
-    for (size_t i = 0; i < param.getNumSamples(); ++i) {
-      if (progress.get_cancel()) {
-        return;
-      }
-
-      ISampleSelector iss = ISampleSelector(index_t(i));
-
-      IC3fGeomParam::Sample sample;
-      param.getIndexed(sample, iss);
-
-      const chrono_t time = param.getTimeSampling()->getSampleTime(index_t(i));
-
-      C3fArraySamplePtr values = sample.getVals();
-
-      attribute.std = ATTR_STD_NONE;
-
-      if (param.getScope() == kVaryingScope) {
-        attribute.element = ATTR_ELEMENT_CORNER_BYTE;
-        attribute.type_desc = TypeRGBA;
-
-        const array<int3> *triangles =
-            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
-
-        if (!triangles) {
-          return;
-        }
-
-        array<char> data;
-        data.resize(triangles->size() * 3 * sizeof(uchar4));
-
-        uchar4 *data_uchar4 = reinterpret_cast<uchar4 *>(data.data());
-
-        int offset = 0;
-        for (const int3 &tri : *triangles) {
-          Imath::C3f v = (*values)[tri.x];
-          data_uchar4[offset + 0] = color_float_to_byte(make_float3(v.x, v.y, v.z));
-
-          v = (*values)[tri.y];
-          data_uchar4[offset + 1] = color_float_to_byte(make_float3(v.x, v.y, v.z));
-
-          v = (*values)[tri.z];
-          data_uchar4[offset + 2] = color_float_to_byte(make_float3(v.x, v.y, v.z));
-
-          offset += 3;
-        }
-
-        attribute.data.set_time_sampling(*param.getTimeSampling());
-        attribute.data.add_data(data, time);
-      }
-    }
-  }
-  else if (IC4fProperty::matches(prop->getMetaData())) {
-    const IC4fGeomParam &param = IC4fGeomParam(arb_geom_params, prop->getName());
-
-    CachedData::CachedAttribute &attribute = cached_data.add_attribute(attr_name,
-                                                                       *param.getTimeSampling());
-
-    for (size_t i = 0; i < param.getNumSamples(); ++i) {
-      if (progress.get_cancel()) {
-        return;
-      }
-
-      ISampleSelector iss = ISampleSelector(index_t(i));
-
-      IC4fGeomParam::Sample sample;
-      param.getIndexed(sample, iss);
-
-      const chrono_t time = param.getTimeSampling()->getSampleTime(index_t(i));
-
-      C4fArraySamplePtr values = sample.getVals();
-
-      attribute.std = ATTR_STD_NONE;
-
-      if (param.getScope() == kVaryingScope) {
-        attribute.element = ATTR_ELEMENT_CORNER_BYTE;
-        attribute.type_desc = TypeRGBA;
-
-        const array<int3> *triangles =
-            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
-
-        if (!triangles) {
-          return;
-        }
-
-        array<char> data;
-        data.resize(triangles->size() * 3 * sizeof(uchar4));
-
-        uchar4 *data_uchar4 = reinterpret_cast<uchar4 *>(data.data());
-
-        int offset = 0;
-        for (const int3 &tri : *triangles) {
-          Imath::C4f v = (*values)[tri.x];
-          data_uchar4[offset + 0] = color_float4_to_uchar4(make_float4(v.r, v.g, v.b, v.a));
-
-          v = (*values)[tri.y];
-          data_uchar4[offset + 1] = color_float4_to_uchar4(make_float4(v.r, v.g, v.b, v.a));
-
-          v = (*values)[tri.z];
-          data_uchar4[offset + 2] = color_float4_to_uchar4(make_float4(v.r, v.g, v.b, v.a));
-
-          offset += 3;
-        }
-
-        attribute.data.set_time_sampling(*param.getTimeSampling());
-        attribute.data.add_data(data, time);
-      }
-    }
-  }
-}
-
 /* Update existing attributes and remove any attribute not in the cached_data, those attributes
  * were added by Cycles (e.g. face normals) */
 static void update_attributes(AttributeSet &attributes, CachedData &cached_data, double frame_time)
@@ -1291,7 +621,11 @@ static void update_attributes(AttributeSet &attributes, CachedData &cached_data,
   set<Attribute *> cached_attributes;
 
   for (CachedData::CachedAttribute &attribute : cached_data.attributes) {
-    const array<char> *attr_data = attribute.data.data_for_time(frame_time).get_data_or_null();
+    const CacheLookupResult<array<char>> result = attribute.data.data_for_time(frame_time);
+
+    if (result.has_no_data_for_time()) {
+      continue;
+    }
 
     Attribute *attr = nullptr;
     if (attribute.std != ATTR_STD_NONE) {
@@ -1304,18 +638,19 @@ static void update_attributes(AttributeSet &attributes, CachedData &cached_data,
 
     cached_attributes.insert(attr);
 
-    if (!attr_data) {
-      /* no new data */
+    if (!result.has_new_data()) {
       continue;
     }
 
+    const ccl::array<char> &attr_data = result.get_data();
+
     /* weak way of detecting if the topology has changed
      * todo: reuse code from device_update patch */
-    if (attr->buffer.size() != attr_data->size()) {
-      attr->buffer.resize(attr_data->size());
+    if (attr->buffer.size() != attr_data.size()) {
+      attr->buffer.resize(attr_data.size());
     }
 
-    memcpy(attr->data(), attr_data->data(), attr_data->size());
+    memcpy(attr->data(), attr_data.data(), attr_data.size());
     attr->modified = true;
   }
 
@@ -1476,6 +811,7 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
       read_subd(object, frame_time);
     }
 
+    object->need_shader_update = false;
     object->clear_modified();
   }
 
@@ -1960,12 +1296,17 @@ void AlembicProcedural::build_caches(Progress &progress)
       if (!object->has_data_loaded()) {
         IPolyMesh polymesh(object->iobject, Alembic::Abc::kWrapExisting);
         IPolyMeshSchema schema = polymesh.getSchema();
-        object->load_all_data(this, schema, progress);
+        object->load_data_in_cache(object->get_cached_data(), this, schema, progress);
       }
       else if (object->need_shader_update) {
         IPolyMesh polymesh(object->iobject, Alembic::Abc::kWrapExisting);
         IPolyMeshSchema schema = polymesh.getSchema();
-        object->update_shader_attributes(schema.getArbGeomParams(), progress);
+        read_attributes(this,
+                        object->get_cached_data(),
+                        schema,
+                        schema.getUVsParam(),
+                        object->get_requested_attributes(),
+                        progress);
       }
     }
     else if (object->schema_type == AlembicObject::CURVES) {
@@ -1973,24 +1314,29 @@ void AlembicProcedural::build_caches(Progress &progress)
           object->radius_scale_is_modified()) {
         ICurves curves(object->iobject, Alembic::Abc::kWrapExisting);
         ICurvesSchema schema = curves.getSchema();
-        object->load_all_data(this, schema, progress, default_radius);
+        object->load_data_in_cache(object->get_cached_data(), this, schema, progress);
       }
     }
     else if (object->schema_type == AlembicObject::SUBD) {
       if (!object->has_data_loaded()) {
         ISubD subd_mesh(object->iobject, Alembic::Abc::kWrapExisting);
         ISubDSchema schema = subd_mesh.getSchema();
-        object->load_all_data(this, schema, progress);
+        object->load_data_in_cache(object->get_cached_data(), this, schema, progress);
       }
       else if (object->need_shader_update) {
         ISubD subd_mesh(object->iobject, Alembic::Abc::kWrapExisting);
         ISubDSchema schema = subd_mesh.getSchema();
-        object->update_shader_attributes(schema.getArbGeomParams(), progress);
+        read_attributes(this,
+                        object->get_cached_data(),
+                        schema,
+                        schema.getUVsParam(),
+                        object->get_requested_attributes(),
+                        progress);
       }
     }
 
     if (scale_is_modified() || object->get_cached_data().transforms.size() == 0) {
-      object->setup_transform_cache(scale);
+      object->setup_transform_cache(object->get_cached_data(), scale);
     }
   }
 }
diff --git a/intern/cycles/render/alembic.h b/intern/cycles/render/alembic.h
index 3bbd10fad61..61c0e40fe4a 100644
--- a/intern/cycles/render/alembic.h
+++ b/intern/cycles/render/alembic.h
@@ -152,6 +152,10 @@ template<typename T> class DataStore {
   double last_loaded_time = std::numeric_limits<double>::max();
 
  public:
+  /* Keys used to compare values. */
+  Alembic::AbcCoreAbstract::ArraySample::Key key1;
+  Alembic::AbcCoreAbstract::ArraySample::Key key2;
+
   void set_time_sampling(Alembic::AbcCoreAbstract::TimeSampling time_sampling_)
   {
     time_sampling = time_sampling_;
@@ -225,6 +229,11 @@ template<typename T> class DataStore {
     index_data_map.push_back({time, data_index.source_time, data_index.index});
   }
 
+  void add_no_data(double time)
+  {
+    index_data_map.push_back({time, time, -1ul});
+  }
+
   bool is_constant() const
   {
     return data.size() <= 1;
@@ -284,7 +293,7 @@ struct CachedData {
   DataStore<array<int3>> triangles{};
   /* triangle "loops" are the polygons' vertices indices used for indexing face varying attributes
    * (like UVs) */
-  DataStore<array<int3>> triangles_loops{};
+  DataStore<array<int>> uv_loops{};
   DataStore<array<int>> shader{};
 
   /* subd data */
@@ -362,16 +371,18 @@ class AlembicObject : public Node {
   void set_object(Object *object);
   Object *get_object();
 
-  void load_all_data(AlembicProcedural *proc,
-                     Alembic::AbcGeom::IPolyMeshSchema &schema,
-                     Progress &progress);
-  void load_all_data(AlembicProcedural *proc,
-                     Alembic::AbcGeom::ISubDSchema &schema,
-                     Progress &progress);
-  void load_all_data(AlembicProcedural *proc,
-                     const Alembic::AbcGeom::ICurvesSchema &schema,
-                     Progress &progress,
-                     float default_radius);
+  void load_data_in_cache(CachedData &cached_data,
+                          AlembicProcedural *proc,
+                          Alembic::AbcGeom::IPolyMeshSchema &schema,
+                          Progress &progress);
+  void load_data_in_cache(CachedData &cached_data,
+                          AlembicProcedural *proc,
+                          Alembic::AbcGeom::ISubDSchema &schema,
+                          Progress &progress);
+  void load_data_in_cache(CachedData &cached_data,
+                          AlembicProcedural *proc,
+                          const Alembic::AbcGeom::ICurvesSchema &schema,
+                          Progress &progress);
 
   bool has_data_loaded() const;
 
@@ -397,33 +408,21 @@ class AlembicObject : public Node {
 
   CachedData &get_cached_data()
   {
-    return cached_data;
+    return cached_data_;
   }
 
   bool is_constant() const
   {
-    return cached_data.is_constant();
+    return cached_data_.is_constant();
   }
 
   Object *object = nullptr;
 
   bool data_loaded = false;
 
-  CachedData cached_data;
-
-  void update_shader_attributes(const Alembic::AbcGeom::ICompoundProperty &arb_geom_params,
-                                Progress &progress);
-
-  void read_attribute(const Alembic::AbcGeom::ICompoundProperty &arb_geom_params,
-                      const ustring &attr_name,
-                      Progress &progress);
-
-  template<typename SchemaType>
-  void read_face_sets(SchemaType &schema,
-                      array<int> &polygon_to_shader,
-                      Alembic::AbcGeom::ISampleSelector sample_sel);
+  CachedData cached_data_;
 
-  void setup_transform_cache(float scale);
+  void setup_transform_cache(CachedData &cached_data, float scale);
 
   AttributeRequestSet get_requested_attributes();
 };
diff --git a/intern/cycles/render/alembic_read.cpp b/intern/cycles/render/alembic_read.cpp
new file mode 100644
index 00000000000..0a80e34b23e
--- /dev/null
+++ b/intern/cycles/render/alembic_read.cpp
@@ -0,0 +1,947 @@
+/*
+ * Copyright 2021 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "render/alembic_read.h"
+
+#include "render/alembic.h"
+#include "render/mesh.h"
+
+#include "util/util_progress.h"
+
+using namespace Alembic::AbcGeom;
+
+CCL_NAMESPACE_BEGIN
+
+static float3 make_float3_from_yup(const V3f &v)
+{
+  return make_float3(v.x, -v.z, v.y);
+}
+
+/* get the sample times to load data for the given the start and end frame of the procedural */
+static set<chrono_t> get_relevant_sample_times(AlembicProcedural *proc,
+                                               const TimeSampling &time_sampling,
+                                               size_t num_samples)
+{
+  set<chrono_t> result;
+
+  if (num_samples < 2) {
+    result.insert(0.0);
+    return result;
+  }
+
+  // load the data for the entire animation
+  const double start_frame = static_cast<double>(proc->get_start_frame());
+  const double end_frame = static_cast<double>(proc->get_end_frame());
+
+  const double frame_rate = static_cast<double>(proc->get_frame_rate());
+  const double start_time = start_frame / frame_rate;
+  const double end_time = (end_frame + 1) / frame_rate;
+
+  const size_t start_index = time_sampling.getFloorIndex(start_time, num_samples).first;
+  const size_t end_index = time_sampling.getCeilIndex(end_time, num_samples).first;
+
+  for (size_t i = start_index; i < end_index; ++i) {
+    result.insert(time_sampling.getSampleTime(i));
+  }
+
+  return result;
+}
+
+/* Main function to read data, this will iterate over all the relevant sample times for the
+ * duration of the requested animation, and call the DataReadingFunc for each of those sample time.
+ */
+template<typename Params, typename DataReadingFunc>
+static void read_data_loop(AlembicProcedural *proc,
+                           CachedData &cached_data,
+                           const Params &params,
+                           DataReadingFunc &&func,
+                           Progress &progress)
+{
+  const std::set<chrono_t> times = get_relevant_sample_times(
+      proc, *params.time_sampling, params.num_samples);
+
+  cached_data.set_time_sampling(*params.time_sampling);
+
+  for (chrono_t time : times) {
+    if (progress.get_cancel()) {
+      return;
+    }
+
+    func(cached_data, params, time);
+  }
+}
+
+/* Polygon Mesh Geometries. */
+
+static void add_normals(const Int32ArraySamplePtr face_indices,
+                        const IN3fGeomParam &normals,
+                        double time,
+                        CachedData &cached_data)
+{
+  switch (normals.getScope()) {
+    case kFacevaryingScope: {
+      const ISampleSelector iss = ISampleSelector(time);
+      const IN3fGeomParam::Sample sample = normals.getExpandedValue(iss);
+
+      if (!sample.valid()) {
+        return;
+      }
+
+      CachedData::CachedAttribute &attr = cached_data.add_attribute(ustring(normals.getName()),
+                                                                    *normals.getTimeSampling());
+      attr.std = ATTR_STD_VERTEX_NORMAL;
+
+      const array<float3> *vertices =
+          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
+
+      if (!vertices) {
+        return;
+      }
+
+      array<char> data;
+      data.resize(vertices->size() * sizeof(float3));
+
+      float3 *data_float3 = reinterpret_cast<float3 *>(data.data());
+
+      const int *face_indices_array = face_indices->get();
+      const N3fArraySamplePtr values = sample.getVals();
+
+      for (size_t i = 0; i < face_indices->size(); ++i) {
+        int point_index = face_indices_array[i];
+        data_float3[point_index] = make_float3_from_yup(values->get()[i]);
+      }
+
+      attr.data.add_data(data, time);
+      break;
+    }
+    case kVaryingScope:
+    case kVertexScope: {
+      const ISampleSelector iss = ISampleSelector(time);
+      const IN3fGeomParam::Sample sample = normals.getExpandedValue(iss);
+
+      if (!sample.valid()) {
+        return;
+      }
+
+      CachedData::CachedAttribute &attr = cached_data.add_attribute(ustring(normals.getName()),
+                                                                    *normals.getTimeSampling());
+      attr.std = ATTR_STD_VERTEX_NORMAL;
+
+      const array<float3> *vertices =
+          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
+
+      if (!vertices) {
+        return;
+      }
+
+      array<char> data;
+      data.resize(vertices->size() * sizeof(float3));
+
+      float3 *data_float3 = reinterpret_cast<float3 *>(data.data());
+
+      const Imath::V3f *values = sample.getVals()->get();
+
+      for (size_t i = 0; i < vertices->size(); ++i) {
+        data_float3[i] = make_float3_from_yup(values[i]);
+      }
+
+      attr.data.add_data(data, time);
+
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+static void add_positions(const P3fArraySamplePtr positions, double time, CachedData &cached_data)
+{
+  if (!positions) {
+    return;
+  }
+
+  array<float3> vertices;
+  vertices.reserve(positions->size());
+
+  for (size_t i = 0; i < positions->size(); i++) {
+    V3f f = positions->get()[i];
+    vertices.push_back_reserved(make_float3_from_yup(f));
+  }
+
+  cached_data.vertices.add_data(vertices, time);
+}
+
+static void add_triangles(const Int32ArraySamplePtr face_counts,
+                          const Int32ArraySamplePtr face_indices,
+                          double time,
+                          CachedData &cached_data,
+                          const array<int> &polygon_to_shader)
+{
+  if (!face_counts || !face_indices) {
+    return;
+  }
+
+  const size_t num_faces = face_counts->size();
+  const int *face_counts_array = face_counts->get();
+  const int *face_indices_array = face_indices->get();
+
+  size_t num_triangles = 0;
+  for (size_t i = 0; i < face_counts->size(); i++) {
+    num_triangles += face_counts_array[i] - 2;
+  }
+
+  array<int> shader;
+  array<int3> triangles;
+  array<int> uv_loops;
+  shader.reserve(num_triangles);
+  triangles.reserve(num_triangles);
+  uv_loops.reserve(num_triangles * 3);
+  int index_offset = 0;
+
+  for (size_t i = 0; i < num_faces; i++) {
+    int current_shader = 0;
+
+    if (!polygon_to_shader.empty()) {
+      current_shader = polygon_to_shader[i];
+    }
+
+    for (int j = 0; j < face_counts_array[i] - 2; j++) {
+      int v0 = face_indices_array[index_offset];
+      int v1 = face_indices_array[index_offset + j + 1];
+      int v2 = face_indices_array[index_offset + j + 2];
+
+      shader.push_back_reserved(current_shader);
+
+      /* Alembic orders the loops following the RenderMan convention, so need to go in reverse. */
+      triangles.push_back_reserved(make_int3(v2, v1, v0));
+      uv_loops.push_back_reserved(index_offset + j + 2);
+      uv_loops.push_back_reserved(index_offset + j + 1);
+      uv_loops.push_back_reserved(index_offset);
+    }
+
+    index_offset += face_counts_array[i];
+  }
+
+  cached_data.triangles.add_data(triangles, time);
+  cached_data.uv_loops.add_data(uv_loops, time);
+  cached_data.shader.add_data(shader, time);
+}
+
+static array<int> compute_polygon_to_shader_map(
+    const Int32ArraySamplePtr &face_counts,
+    const vector<FaceSetShaderIndexPair> &face_set_shader_index,
+    ISampleSelector sample_sel)
+{
+  if (face_set_shader_index.empty()) {
+    return {};
+  }
+
+  if (!face_counts) {
+    return {};
+  }
+
+  if (face_counts->size() == 0) {
+    return {};
+  }
+
+  array<int> polygon_to_shader(face_counts->size());
+
+  for (const FaceSetShaderIndexPair &pair : face_set_shader_index) {
+    const IFaceSet &face_set = pair.face_set;
+    const IFaceSetSchema face_schem = face_set.getSchema();
+    const IFaceSetSchema::Sample face_sample = face_schem.getValue(sample_sel);
+    const Int32ArraySamplePtr group_faces = face_sample.getFaces();
+    const size_t num_group_faces = group_faces->size();
+
+    for (size_t l = 0; l < num_group_faces; l++) {
+      size_t pos = (*group_faces)[l];
+
+      if (pos >= polygon_to_shader.size()) {
+        continue;
+      }
+
+      polygon_to_shader[pos] = pair.shader_index;
+    }
+  }
+
+  return polygon_to_shader;
+}
+
+static void read_poly_mesh_geometry(CachedData &cached_data,
+                                    const PolyMeshSchemaData &data,
+                                    chrono_t time)
+{
+  const ISampleSelector iss = ISampleSelector(time);
+
+  add_positions(data.positions.getValue(iss), time, cached_data);
+
+  const Int32ArraySamplePtr face_counts = data.face_counts.getValue(iss);
+  const Int32ArraySamplePtr face_indices = data.face_indices.getValue(iss);
+
+  /* Only copy triangles for other frames if the topology is changing over time as well. */
+  if (data.topology_variance != kHomogeneousTopology || cached_data.triangles.size() == 0) {
+    bool do_triangles = true;
+
+    /* Compare key with last one to check whether the topology changed. */
+    if (cached_data.triangles.size() > 0) {
+      const ArraySample::Key key = face_indices->getKey();
+
+      if (key == cached_data.triangles.key1) {
+        do_triangles = false;
+      }
+
+      cached_data.triangles.key1 = key;
+    }
+
+    if (do_triangles) {
+      const array<int> polygon_to_shader = compute_polygon_to_shader_map(
+          face_counts, data.shader_face_sets, iss);
+      add_triangles(face_counts, face_indices, time, cached_data, polygon_to_shader);
+    }
+    else {
+      cached_data.triangles.reuse_data_for_last_time(time);
+      cached_data.uv_loops.reuse_data_for_last_time(time);
+      cached_data.shader.reuse_data_for_last_time(time);
+    }
+
+    /* Initialize the first key. */
+    if (data.topology_variance != kHomogeneousTopology && cached_data.triangles.size() == 1) {
+      cached_data.triangles.key1 = face_indices->getKey();
+    }
+  }
+
+  if (data.normals.valid()) {
+    add_normals(face_indices, data.normals, time, cached_data);
+  }
+}
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const PolyMeshSchemaData &data,
+                        Progress &progress)
+{
+  read_data_loop(proc, cached_data, data, read_poly_mesh_geometry, progress);
+}
+
+/* Subdivision Geometries */
+
+static void add_subd_polygons(CachedData &cached_data, const SubDSchemaData &data, chrono_t time)
+{
+  const ISampleSelector iss = ISampleSelector(time);
+
+  const Int32ArraySamplePtr face_counts = data.face_counts.getValue(iss);
+  const Int32ArraySamplePtr face_indices = data.face_indices.getValue(iss);
+
+  array<int> subd_start_corner;
+  array<int> shader;
+  array<int> subd_num_corners;
+  array<bool> subd_smooth;
+  array<int> subd_ptex_offset;
+  array<int> subd_face_corners;
+  array<int> uv_loops;
+
+  const size_t num_faces = face_counts->size();
+  const int *face_counts_array = face_counts->get();
+  const int *face_indices_array = face_indices->get();
+
+  int num_ngons = 0;
+  int num_corners = 0;
+  for (size_t i = 0; i < face_counts->size(); i++) {
+    num_ngons += (face_counts_array[i] == 4 ? 0 : 1);
+    num_corners += face_counts_array[i];
+  }
+
+  subd_start_corner.reserve(num_faces);
+  subd_num_corners.reserve(num_faces);
+  subd_smooth.reserve(num_faces);
+  subd_ptex_offset.reserve(num_faces);
+  shader.reserve(num_faces);
+  subd_face_corners.reserve(num_corners);
+  uv_loops.reserve(num_corners);
+
+  int start_corner = 0;
+  int current_shader = 0;
+  int ptex_offset = 0;
+
+  const array<int> polygon_to_shader = compute_polygon_to_shader_map(
+      face_counts, data.shader_face_sets, iss);
+
+  for (size_t i = 0; i < face_counts->size(); i++) {
+    num_corners = face_counts_array[i];
+
+    if (!polygon_to_shader.empty()) {
+      current_shader = polygon_to_shader[i];
+    }
+
+    subd_start_corner.push_back_reserved(start_corner);
+    subd_num_corners.push_back_reserved(num_corners);
+
+    for (int j = 0; j < num_corners; ++j) {
+      subd_face_corners.push_back_reserved(face_indices_array[start_corner + j]);
+      uv_loops.push_back_reserved(start_corner + j);
+    }
+
+    shader.push_back_reserved(current_shader);
+    subd_smooth.push_back_reserved(1);
+    subd_ptex_offset.push_back_reserved(ptex_offset);
+
+    ptex_offset += (num_corners == 4 ? 1 : num_corners);
+
+    start_corner += num_corners;
+  }
+
+  cached_data.shader.add_data(shader, time);
+  cached_data.subd_start_corner.add_data(subd_start_corner, time);
+  cached_data.subd_num_corners.add_data(subd_num_corners, time);
+  cached_data.subd_smooth.add_data(subd_smooth, time);
+  cached_data.subd_ptex_offset.add_data(subd_ptex_offset, time);
+  cached_data.subd_face_corners.add_data(subd_face_corners, time);
+  cached_data.num_ngons.add_data(num_ngons, time);
+  cached_data.uv_loops.add_data(uv_loops, time);
+}
+
+static void add_subd_creases(CachedData &cached_data, const SubDSchemaData &data, chrono_t time)
+{
+  if (!(data.crease_indices.valid() && data.crease_indices.valid() &&
+        data.crease_sharpnesses.valid())) {
+    return;
+  }
+
+  const ISampleSelector iss = ISampleSelector(time);
+
+  const Int32ArraySamplePtr creases_length = data.crease_lengths.getValue(iss);
+  const Int32ArraySamplePtr creases_indices = data.crease_indices.getValue(iss);
+  const FloatArraySamplePtr creases_sharpnesses = data.crease_sharpnesses.getValue(iss);
+
+  if (creases_length && creases_indices && creases_sharpnesses) {
+    array<int> creases_edge;
+    array<float> creases_weight;
+
+    creases_edge.reserve(creases_sharpnesses->size() * 2);
+    creases_weight.reserve(creases_sharpnesses->size());
+
+    int length_offset = 0;
+    int weight_offset = 0;
+    for (size_t c = 0; c < creases_length->size(); ++c) {
+      const int crease_length = creases_length->get()[c];
+
+      for (size_t j = 0; j < crease_length - 1; ++j) {
+        creases_edge.push_back_reserved(creases_indices->get()[length_offset + j]);
+        creases_edge.push_back_reserved(creases_indices->get()[length_offset + j + 1]);
+        creases_weight.push_back_reserved(creases_sharpnesses->get()[weight_offset++]);
+      }
+
+      length_offset += crease_length;
+    }
+
+    cached_data.subd_creases_edge.add_data(creases_edge, time);
+    cached_data.subd_creases_weight.add_data(creases_weight, time);
+  }
+}
+
+static void read_subd_geometry(CachedData &cached_data, const SubDSchemaData &data, chrono_t time)
+{
+  const ISampleSelector iss = ISampleSelector(time);
+
+  add_positions(data.positions.getValue(iss), time, cached_data);
+
+  if (data.topology_variance != kHomogenousTopology || cached_data.shader.size() == 0) {
+    add_subd_polygons(cached_data, data, time);
+    add_subd_creases(cached_data, data, time);
+  }
+}
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const SubDSchemaData &data,
+                        Progress &progress)
+{
+  read_data_loop(proc, cached_data, data, read_subd_geometry, progress);
+}
+
+/* Curve Geometries. */
+
+static void read_curves_data(CachedData &cached_data, const CurvesSchemaData &data, chrono_t time)
+{
+  const ISampleSelector iss = ISampleSelector(time);
+
+  const Int32ArraySamplePtr curves_num_vertices = data.num_vertices.getValue(iss);
+  const P3fArraySamplePtr position = data.positions.getValue(iss);
+
+  FloatArraySamplePtr radiuses;
+
+  if (data.widths.valid()) {
+    IFloatGeomParam::Sample wsample = data.widths.getExpandedValue(iss);
+    radiuses = wsample.getVals();
+  }
+
+  const bool do_radius = (radiuses != nullptr) && (radiuses->size() > 1);
+  float radius = (radiuses && radiuses->size() == 1) ? (*radiuses)[0] : data.default_radius;
+
+  array<float3> curve_keys;
+  array<float> curve_radius;
+  array<int> curve_first_key;
+  array<int> curve_shader;
+
+  const bool is_homogenous = data.topology_variance == kHomogenousTopology;
+
+  curve_keys.reserve(position->size());
+  curve_radius.reserve(position->size());
+  curve_first_key.reserve(curves_num_vertices->size());
+  curve_shader.reserve(curves_num_vertices->size());
+
+  int offset = 0;
+  for (size_t i = 0; i < curves_num_vertices->size(); i++) {
+    const int num_vertices = curves_num_vertices->get()[i];
+
+    for (int j = 0; j < num_vertices; j++) {
+      const V3f &f = position->get()[offset + j];
+      // todo(@kevindietrich): we are reading too much data?
+      curve_keys.push_back_slow(make_float3_from_yup(f));
+
+      if (do_radius) {
+        radius = (*radiuses)[offset + j];
+      }
+
+      curve_radius.push_back_slow(radius * data.radius_scale);
+    }
+
+    if (!is_homogenous || cached_data.curve_first_key.size() == 0) {
+      curve_first_key.push_back_reserved(offset);
+      curve_shader.push_back_reserved(0);
+    }
+
+    offset += num_vertices;
+  }
+
+  cached_data.curve_keys.add_data(curve_keys, time);
+  cached_data.curve_radius.add_data(curve_radius, time);
+
+  if (!is_homogenous || cached_data.curve_first_key.size() == 0) {
+    cached_data.curve_first_key.add_data(curve_first_key, time);
+    cached_data.curve_shader.add_data(curve_shader, time);
+  }
+}
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const CurvesSchemaData &data,
+                        Progress &progress)
+{
+  read_data_loop(proc, cached_data, data, read_curves_data, progress);
+}
+
+/* Attributes conversions. */
+
+/* Type traits for converting between Alembic and Cycles types.
+ */
+
+template<typename T> struct value_type_converter {
+  using cycles_type = float;
+  static constexpr TypeDesc type_desc = TypeFloat;
+  static constexpr const char *type_name = "float (default)";
+
+  static cycles_type convert_value(T value)
+  {
+    return static_cast<float>(value);
+  }
+};
+
+template<> struct value_type_converter<Imath::V2f> {
+  using cycles_type = float2;
+  static constexpr TypeDesc type_desc = TypeFloat2;
+  static constexpr const char *type_name = "float2";
+
+  static cycles_type convert_value(Imath::V2f value)
+  {
+    return make_float2(value.x, value.y);
+  }
+};
+
+template<> struct value_type_converter<Imath::V3f> {
+  using cycles_type = float3;
+  static constexpr TypeDesc type_desc = TypeVector;
+  static constexpr const char *type_name = "float3";
+
+  static cycles_type convert_value(Imath::V3f value)
+  {
+    return make_float3_from_yup(value);
+  }
+};
+
+template<> struct value_type_converter<Imath::C3f> {
+  using cycles_type = uchar4;
+  static constexpr TypeDesc type_desc = TypeRGBA;
+  static constexpr const char *type_name = "rgb";
+
+  static cycles_type convert_value(Imath::C3f value)
+  {
+    return color_float_to_byte(make_float3(value.x, value.y, value.z));
+  }
+};
+
+template<> struct value_type_converter<Imath::C4f> {
+  using cycles_type = uchar4;
+  static constexpr TypeDesc type_desc = TypeRGBA;
+  static constexpr const char *type_name = "rgba";
+
+  static cycles_type convert_value(Imath::C4f value)
+  {
+    return color_float4_to_uchar4(make_float4(value.r, value.g, value.b, value.a));
+  }
+};
+
+/* Main function used to read attributes of any type. */
+template<typename TRAIT>
+static void process_attribute(CachedData &cache,
+                              CachedData::CachedAttribute &attribute,
+                              GeometryScope scope,
+                              const typename ITypedGeomParam<TRAIT>::Sample &sample,
+                              double time)
+{
+  using abc_type = typename TRAIT::value_type;
+  using cycles_type = typename value_type_converter<abc_type>::cycles_type;
+
+  const TypedArraySample<TRAIT> &values = *sample.getVals();
+
+  switch (scope) {
+    case kConstantScope:
+    case kVertexScope: {
+      const array<float3> *vertices =
+          cache.vertices.data_for_time_no_check(time).get_data_or_null();
+
+      if (!vertices) {
+        attribute.data.add_no_data(time);
+        return;
+      }
+
+      if (vertices->size() != values.size()) {
+        attribute.data.add_no_data(time);
+        return;
+      }
+
+      array<char> data(vertices->size() * sizeof(cycles_type));
+
+      cycles_type *pod_typed_data = reinterpret_cast<cycles_type *>(data.data());
+
+      for (size_t i = 0; i < values.size(); ++i) {
+        *pod_typed_data++ = value_type_converter<abc_type>::convert_value(values[i]);
+      }
+
+      attribute.data.add_data(data, time);
+      break;
+    }
+    case kVaryingScope: {
+      const array<int3> *triangles =
+          cache.triangles.data_for_time_no_check(time).get_data_or_null();
+
+      if (!triangles) {
+        attribute.data.add_no_data(time);
+        return;
+      }
+
+      array<char> data(triangles->size() * 3 * sizeof(cycles_type));
+
+      cycles_type *pod_typed_data = reinterpret_cast<cycles_type *>(data.data());
+
+      for (const int3 &tri : *triangles) {
+        *pod_typed_data++ = value_type_converter<abc_type>::convert_value(values[tri.x]);
+        *pod_typed_data++ = value_type_converter<abc_type>::convert_value(values[tri.y]);
+        *pod_typed_data++ = value_type_converter<abc_type>::convert_value(values[tri.z]);
+      }
+
+      attribute.data.add_data(data, time);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+/* UVs are processed separately as their indexing is based on loops, instead of vertices or
+ * corners. */
+static void process_uvs(CachedData &cache,
+                        CachedData::CachedAttribute &attribute,
+                        GeometryScope scope,
+                        const IV2fGeomParam::Sample &sample,
+                        double time)
+{
+  if (scope != kFacevaryingScope) {
+    return;
+  }
+
+  const array<int> *uv_loops = cache.uv_loops.data_for_time_no_check(time).get_data_or_null();
+
+  if (!uv_loops) {
+    return;
+  }
+
+  const array<int3> *triangles = cache.triangles.data_for_time_no_check(time).get_data_or_null();
+  const array<int> *corners =
+      cache.subd_face_corners.data_for_time_no_check(time).get_data_or_null();
+
+  array<char> data;
+  if (triangles) {
+    data.resize(triangles->size() * 3 * sizeof(float2));
+  }
+  else if (corners) {
+    data.resize(corners->size() * sizeof(float2));
+  }
+  else {
+    return;
+  }
+
+  float2 *data_float2 = reinterpret_cast<float2 *>(data.data());
+
+  const uint32_t *indices = sample.getIndices()->get();
+  const V2f *values = sample.getVals()->get();
+
+  for (const int uv_loop_index : *uv_loops) {
+    const uint32_t index = indices[uv_loop_index];
+    *data_float2++ = make_float2(values[index][0], values[index][1]);
+  }
+
+  attribute.data.add_data(data, time);
+}
+
+/* Type of the function used to parse one time worth of data, either process_uvs or
+ * process_attribute_generic. */
+template<typename TRAIT>
+using process_callback_type = void (*)(CachedData &,
+                                       CachedData::CachedAttribute &,
+                                       GeometryScope,
+                                       const typename ITypedGeomParam<TRAIT>::Sample &,
+                                       double);
+
+/* Main loop to process the attributes, this will look at the given param's TimeSampling and
+ * extract data based on which frame time is requested by the procedural and execute the callback
+ * for each of those requested time. */
+template<typename TRAIT>
+static void read_attribute_loop(AlembicProcedural *proc,
+                                CachedData &cache,
+                                const ITypedGeomParam<TRAIT> &param,
+                                process_callback_type<TRAIT> callback,
+                                Progress &progress,
+                                AttributeStandard std = ATTR_STD_NONE)
+{
+  const std::set<chrono_t> times = get_relevant_sample_times(
+      proc, *param.getTimeSampling(), param.getNumSamples());
+
+  if (times.empty()) {
+    return;
+  }
+
+  std::string name = param.getName();
+
+  if (std == ATTR_STD_UV) {
+    std::string uv_source_name = Alembic::Abc::GetSourceName(param.getMetaData());
+
+    /* According to the convention, primary UVs should have had their name
+     * set using Alembic::Abc::SetSourceName, but you can't expect everyone
+     * to follow it! :) */
+    if (!uv_source_name.empty()) {
+      name = uv_source_name;
+    }
+  }
+
+  CachedData::CachedAttribute &attribute = cache.add_attribute(ustring(name),
+                                                               *param.getTimeSampling());
+
+  using abc_type = typename TRAIT::value_type;
+
+  attribute.data.set_time_sampling(*param.getTimeSampling());
+  attribute.std = std;
+  attribute.type_desc = value_type_converter<abc_type>::type_desc;
+
+  if (attribute.type_desc == TypeRGBA) {
+    attribute.element = ATTR_ELEMENT_CORNER_BYTE;
+  }
+  else {
+    if (param.getScope() == kVaryingScope || param.getScope() == kFacevaryingScope) {
+      attribute.element = ATTR_ELEMENT_CORNER;
+    }
+    else {
+      attribute.element = ATTR_ELEMENT_VERTEX;
+    }
+  }
+
+  for (const chrono_t time : times) {
+    if (progress.get_cancel()) {
+      return;
+    }
+
+    ISampleSelector iss = ISampleSelector(time);
+    typename ITypedGeomParam<TRAIT>::Sample sample;
+    param.getIndexed(sample, iss);
+
+    if (!sample.valid()) {
+      continue;
+    }
+
+    if (!sample.getVals()) {
+      attribute.data.add_no_data(time);
+      continue;
+    }
+
+    /* Check whether we already loaded constant data. */
+    if (attribute.data.size() != 0) {
+      if (param.isConstant()) {
+        return;
+      }
+
+      const ArraySample::Key indices_key = sample.getIndices()->getKey();
+      const ArraySample::Key values_key = sample.getVals()->getKey();
+
+      const bool is_same_as_last_time = (indices_key == attribute.data.key1 &&
+                                         values_key == attribute.data.key2);
+
+      attribute.data.key1 = indices_key;
+      attribute.data.key2 = values_key;
+
+      if (is_same_as_last_time) {
+        attribute.data.reuse_data_for_last_time(time);
+        continue;
+      }
+    }
+
+    callback(cache, attribute, param.getScope(), sample, time);
+  }
+}
+
+/* Attributes requests. */
+
+/* This structure is used to tell which ICoumpoundProperty the PropertyHeader comes from, as we
+ * need the parent when downcasting to the proper type. */
+struct PropHeaderAndParent {
+  const PropertyHeader *prop;
+  ICompoundProperty parent;
+};
+
+/* Parse the ICompoundProperty to look for properties whose names appear in the
+ * AttributeRequestSet. This also looks into any child ICompoundProperty of the given
+ * ICompoundProperty. If no property of the given name is found, let it be that way, Cycles will
+ * use a zero value for the missing attribute. */
+static void parse_requested_attributes_recursive(const AttributeRequestSet &requested_attributes,
+                                                 const ICompoundProperty &arb_geom_params,
+                                                 vector<PropHeaderAndParent> &requested_properties)
+{
+  for (const AttributeRequest &req : requested_attributes.requests) {
+    const PropertyHeader *property_header = arb_geom_params.getPropertyHeader(req.name.c_str());
+
+    if (!property_header) {
+      continue;
+    }
+
+    requested_properties.push_back({property_header, arb_geom_params});
+  }
+
+  /* Look into children compound properties. */
+  for (size_t i = 0; i < arb_geom_params.getNumProperties(); ++i) {
+    const PropertyHeader &property_header = arb_geom_params.getPropertyHeader(i);
+
+    if (property_header.isCompound()) {
+      ICompoundProperty compound_property = ICompoundProperty(arb_geom_params,
+                                                              property_header.getName());
+      parse_requested_attributes_recursive(
+          requested_attributes, compound_property, requested_properties);
+    }
+  }
+}
+
+/* Main entry point for parsing requested attributes from an ICompoundProperty, this exists so that
+ * we can simply return the list of properties instead of allocating it on the stack and passing it
+ * as a parameter. */
+static vector<PropHeaderAndParent> parse_requested_attributes(
+    const AttributeRequestSet &requested_attributes, const ICompoundProperty &arb_geom_params)
+{
+  vector<PropHeaderAndParent> requested_properties;
+  parse_requested_attributes_recursive(
+      requested_attributes, arb_geom_params, requested_properties);
+  return requested_properties;
+}
+
+/* Read the attributes requested by the shaders from the archive. This will recursively find named
+ * attributes from the AttributeRequestSet in the ICompoundProperty and any of its compound child.
+ * The attributes are added to the CachedData's attribute list. For each attribute we will try to
+ * deduplicate data across consecutive frames. */
+void read_attributes(AlembicProcedural *proc,
+                     CachedData &cache,
+                     const ICompoundProperty &arb_geom_params,
+                     const IV2fGeomParam &default_uvs_param,
+                     const AttributeRequestSet &requested_attributes,
+                     Progress &progress)
+{
+  if (default_uvs_param.valid()) {
+    /* Only the default UVs should be treated as the standard UV attribute. */
+    read_attribute_loop(proc, cache, default_uvs_param, process_uvs, progress, ATTR_STD_UV);
+  }
+
+  vector<PropHeaderAndParent> requested_properties = parse_requested_attributes(
+      requested_attributes, arb_geom_params);
+
+  for (const PropHeaderAndParent &prop_and_parent : requested_properties) {
+    if (progress.get_cancel()) {
+      return;
+    }
+
+    const PropertyHeader *prop = prop_and_parent.prop;
+    const ICompoundProperty &parent = prop_and_parent.parent;
+
+    if (IBoolGeomParam::matches(*prop)) {
+      const IBoolGeomParam &param = IBoolGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<BooleanTPTraits>, progress);
+    }
+    else if (IInt32GeomParam::matches(*prop)) {
+      const IInt32GeomParam &param = IInt32GeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<Int32TPTraits>, progress);
+    }
+    else if (IFloatGeomParam::matches(*prop)) {
+      const IFloatGeomParam &param = IFloatGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<Float32TPTraits>, progress);
+    }
+    else if (IV2fGeomParam::matches(*prop)) {
+      const IV2fGeomParam &param = IV2fGeomParam(parent, prop->getName());
+      if (Alembic::AbcGeom::isUV(*prop)) {
+        read_attribute_loop(proc, cache, param, process_uvs, progress);
+      }
+      else {
+        read_attribute_loop(proc, cache, param, process_attribute<V2fTPTraits>, progress);
+      }
+    }
+    else if (IV3fGeomParam::matches(*prop)) {
+      const IV3fGeomParam &param = IV3fGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<V3fTPTraits>, progress);
+    }
+    else if (IN3fGeomParam::matches(*prop)) {
+      const IN3fGeomParam &param = IN3fGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<N3fTPTraits>, progress);
+    }
+    else if (IC3fGeomParam::matches(*prop)) {
+      const IC3fGeomParam &param = IC3fGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<C3fTPTraits>, progress);
+    }
+    else if (IC4fGeomParam::matches(*prop)) {
+      const IC4fGeomParam &param = IC4fGeomParam(parent, prop->getName());
+      read_attribute_loop(proc, cache, param, process_attribute<C4fTPTraits>, progress);
+    }
+  }
+
+  cache.invalidate_last_loaded_time(true);
+}
+
+CCL_NAMESPACE_END
diff --git a/intern/cycles/render/alembic_read.h b/intern/cycles/render/alembic_read.h
new file mode 100644
index 00000000000..9cc8622a1ba
--- /dev/null
+++ b/intern/cycles/render/alembic_read.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2021 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifdef WITH_ALEMBIC
+
+#  include <Alembic/AbcCoreFactory/All.h>
+#  include <Alembic/AbcGeom/All.h>
+
+#  include "util/util_vector.h"
+
+CCL_NAMESPACE_BEGIN
+
+class AlembicProcedural;
+class AttributeRequestSet;
+class Progress;
+struct CachedData;
+
+/* Maps a FaceSet whose name matches that of a Shader to the index of said shader in the Geometry's
+ * used_shaders list. */
+struct FaceSetShaderIndexPair {
+  Alembic::AbcGeom::IFaceSet face_set;
+  int shader_index;
+};
+
+/* Data of an IPolyMeshSchema that we need to read. */
+struct PolyMeshSchemaData {
+  Alembic::AbcGeom::TimeSamplingPtr time_sampling;
+  size_t num_samples;
+  Alembic::AbcGeom::MeshTopologyVariance topology_variance;
+
+  Alembic::AbcGeom::IP3fArrayProperty positions;
+  Alembic::AbcGeom::IInt32ArrayProperty face_indices;
+  Alembic::AbcGeom::IInt32ArrayProperty face_counts;
+
+  Alembic::AbcGeom::IN3fGeomParam normals;
+
+  vector<FaceSetShaderIndexPair> shader_face_sets;
+
+  // Unsupported for now.
+  Alembic::AbcGeom::IV3fArrayProperty velocities;
+};
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const PolyMeshSchemaData &data,
+                        Progress &progress);
+
+/* Data of an ISubDSchema that we need to read. */
+struct SubDSchemaData {
+  Alembic::AbcGeom::TimeSamplingPtr time_sampling;
+  size_t num_samples;
+  Alembic::AbcGeom::MeshTopologyVariance topology_variance;
+
+  Alembic::AbcGeom::IInt32ArrayProperty face_counts;
+  Alembic::AbcGeom::IInt32ArrayProperty face_indices;
+  Alembic::AbcGeom::IP3fArrayProperty positions;
+
+  Alembic::AbcGeom::IInt32ArrayProperty crease_indices;
+  Alembic::AbcGeom::IInt32ArrayProperty crease_lengths;
+  Alembic::AbcGeom::IFloatArrayProperty crease_sharpnesses;
+
+  vector<FaceSetShaderIndexPair> shader_face_sets;
+
+  // Those are unsupported for now.
+  Alembic::AbcGeom::IInt32ArrayProperty corner_indices;
+  Alembic::AbcGeom::IFloatArrayProperty corner_sharpnesses;
+  Alembic::AbcGeom::IInt32Property face_varying_interpolate_boundary;
+  Alembic::AbcGeom::IInt32Property face_varying_propagate_corners;
+  Alembic::AbcGeom::IInt32Property interpolate_boundary;
+  Alembic::AbcGeom::IInt32ArrayProperty holes;
+  Alembic::AbcGeom::IStringProperty subdivision_scheme;
+  Alembic::AbcGeom::IV3fArrayProperty velocities;
+};
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const SubDSchemaData &data,
+                        Progress &progress);
+
+/* Data of a ICurvesSchema that we need to read. */
+struct CurvesSchemaData {
+  Alembic::AbcGeom::TimeSamplingPtr time_sampling;
+  size_t num_samples;
+  Alembic::AbcGeom::MeshTopologyVariance topology_variance;
+
+  Alembic::AbcGeom::IP3fArrayProperty positions;
+
+  Alembic::AbcGeom::IInt32ArrayProperty num_vertices;
+
+  float default_radius;
+  float radius_scale;
+
+  // Those are unsupported for now.
+  Alembic::AbcGeom::IV3fArrayProperty velocities;
+  // if this property is invalid then the weight for every point is 1
+  Alembic::AbcGeom::IFloatArrayProperty position_weights;
+  Alembic::AbcGeom::IN3fGeomParam normals;
+  Alembic::AbcGeom::IFloatGeomParam widths;
+  Alembic::AbcGeom::IUcharArrayProperty orders;
+  Alembic::AbcGeom::IFloatArrayProperty knots;
+
+  // TODO(@kevindietrich): type, basis, wrap
+};
+
+void read_geometry_data(AlembicProcedural *proc,
+                        CachedData &cached_data,
+                        const CurvesSchemaData &data,
+                        Progress &progress);
+
+void read_attributes(AlembicProcedural *proc,
+                     CachedData &cache,
+                     const Alembic::AbcGeom::ICompoundProperty &arb_geom_params,
+                     const Alembic::AbcGeom::IV2fGeomParam &default_uvs_param,
+                     const AttributeRequestSet &requested_attributes,
+                     Progress &progress);
+
+CCL_NAMESPACE_END
+
+#endif