ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 980 insertions, 982 deletions

diff --git a/source/blender/alembic/intern/abc_mesh.cc b/source/blender/alembic/intern/abc_mesh.cc
index 97cd6ffc0e3..5ccb9be02a3 100644
--- a/source/blender/alembic/intern/abc_mesh.cc
+++ b/source/blender/alembic/intern/abc_mesh.cc
@@ -57,6 +57,7 @@ extern "C" {
 #include "DEG_depsgraph_query.h"
 }
 
+using Alembic::Abc::C4fArraySample;
 using Alembic::Abc::FloatArraySample;
 using Alembic::Abc::ICompoundProperty;
 using Alembic::Abc::Int32ArraySample;
@@ -64,7 +65,6 @@ using Alembic::Abc::Int32ArraySamplePtr;
 using Alembic::Abc::P3fArraySamplePtr;
 using Alembic::Abc::V2fArraySample;
 using Alembic::Abc::V3fArraySample;
-using Alembic::Abc::C4fArraySample;
 
 using Alembic::AbcGeom::IFaceSet;
 using Alembic::AbcGeom::IFaceSetSchema;
@@ -95,13 +95,13 @@ using Alembic::AbcGeom::OSubDSchema;
 using Alembic::AbcGeom::OV2fGeomParam;
 using Alembic::AbcGeom::OV3fGeomParam;
 
+using Alembic::AbcGeom::IN3fGeomParam;
 using Alembic::AbcGeom::kFacevaryingScope;
 using Alembic::AbcGeom::kVaryingScope;
 using Alembic::AbcGeom::kVertexScope;
 using Alembic::AbcGeom::kWrapExisting;
-using Alembic::AbcGeom::UInt32ArraySample;
 using Alembic::AbcGeom::N3fArraySamplePtr;
-using Alembic::AbcGeom::IN3fGeomParam;
+using Alembic::AbcGeom::UInt32ArraySample;
 
 /* ************************************************************************** */
 
@@ -109,14 +109,14 @@ using Alembic::AbcGeom::IN3fGeomParam;
 
 static void get_vertices(struct Mesh *mesh, std::vector<Imath::V3f> &points)
 {
-	points.clear();
-	points.resize(mesh->totvert);
+  points.clear();
+  points.resize(mesh->totvert);
 
-	MVert *verts = mesh->mvert;
+  MVert *verts = mesh->mvert;
 
-	for (int i = 0, e = mesh->totvert; i < e; ++i) {
-		copy_yup_from_zup(points[i].getValue(), verts[i].co);
-	}
+  for (int i = 0, e = mesh->totvert; i < e; ++i) {
+    copy_yup_from_zup(points[i].getValue(), verts[i].co);
+  }
 }
 
 static void get_topology(struct Mesh *mesh,
@@ -124,29 +124,29 @@ static void get_topology(struct Mesh *mesh,
                          std::vector<int32_t> &loop_counts,
                          bool &smooth_normal)
 {
-	const int num_poly = mesh->totpoly;
-	const int num_loops = mesh->totloop;
-	MLoop *mloop = mesh->mloop;
-	MPoly *mpoly = mesh->mpoly;
+  const int num_poly = mesh->totpoly;
+  const int num_loops = mesh->totloop;
+  MLoop *mloop = mesh->mloop;
+  MPoly *mpoly = mesh->mpoly;
 
-	poly_verts.clear();
-	loop_counts.clear();
-	poly_verts.reserve(num_loops);
-	loop_counts.reserve(num_poly);
+  poly_verts.clear();
+  loop_counts.clear();
+  poly_verts.reserve(num_loops);
+  loop_counts.reserve(num_poly);
 
-	/* NOTE: data needs to be written in the reverse order. */
-	for (int i = 0; i < num_poly; ++i) {
-		MPoly &poly = mpoly[i];
-		loop_counts.push_back(poly.totloop);
+  /* NOTE: data needs to be written in the reverse order. */
+  for (int i = 0; i < num_poly; ++i) {
+    MPoly &poly = mpoly[i];
+    loop_counts.push_back(poly.totloop);
 
-		smooth_normal |= ((poly.flag & ME_SMOOTH) != 0);
+    smooth_normal |= ((poly.flag & ME_SMOOTH) != 0);
 
-		MLoop *loop = mloop + poly.loopstart + (poly.totloop - 1);
+    MLoop *loop = mloop + poly.loopstart + (poly.totloop - 1);
 
-		for (int j = 0; j < poly.totloop; ++j, --loop) {
-			poly_verts.push_back(loop->v);
-		}
-	}
+    for (int j = 0; j < poly.totloop; ++j, --loop) {
+      poly_verts.push_back(loop->v);
+    }
+  }
 }
 
 static void get_creases(struct Mesh *mesh,
@@ -154,92 +154,92 @@ static void get_creases(struct Mesh *mesh,
                         std::vector<int32_t> &lengths,
                         std::vector<float> &sharpnesses)
 {
-	const float factor = 1.0f / 255.0f;
+  const float factor = 1.0f / 255.0f;
 
-	indices.clear();
-	lengths.clear();
-	sharpnesses.clear();
+  indices.clear();
+  lengths.clear();
+  sharpnesses.clear();
 
-	MEdge *edge = mesh->medge;
+  MEdge *edge = mesh->medge;
 
-	for (int i = 0, e = mesh->totedge; i < e; ++i) {
-		const float sharpness = static_cast<float>(edge[i].crease) * factor;
+  for (int i = 0, e = mesh->totedge; i < e; ++i) {
+    const float sharpness = static_cast<float>(edge[i].crease) * factor;
 
-		if (sharpness != 0.0f) {
-			indices.push_back(edge[i].v1);
-			indices.push_back(edge[i].v2);
-			sharpnesses.push_back(sharpness);
-		}
-	}
+    if (sharpness != 0.0f) {
+      indices.push_back(edge[i].v1);
+      indices.push_back(edge[i].v2);
+      sharpnesses.push_back(sharpness);
+    }
+  }
 
-	lengths.resize(sharpnesses.size(), 2);
+  lengths.resize(sharpnesses.size(), 2);
 }
 
 static void get_vertex_normals(struct Mesh *mesh, std::vector<Imath::V3f> &normals)
 {
-	normals.clear();
-	normals.resize(mesh->totvert);
+  normals.clear();
+  normals.resize(mesh->totvert);
 
-	MVert *verts = mesh->mvert;
-	float no[3];
+  MVert *verts = mesh->mvert;
+  float no[3];
 
-	for (int i = 0, e = mesh->totvert; i < e; ++i) {
-		normal_short_to_float_v3(no, verts[i].no);
-		copy_yup_from_zup(normals[i].getValue(), no);
-	}
+  for (int i = 0, e = mesh->totvert; i < e; ++i) {
+    normal_short_to_float_v3(no, verts[i].no);
+    copy_yup_from_zup(normals[i].getValue(), no);
+  }
 }
 
 static void get_loop_normals(struct Mesh *mesh, std::vector<Imath::V3f> &normals)
 {
-	MPoly *mp = mesh->mpoly;
-
-	MLoop *mloop = mesh->mloop;
-	MLoop *ml = mloop;
-
-	MVert *verts = mesh->mvert;
-
-	const float (*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
-
-	normals.clear();
-	normals.resize(mesh->totloop);
-
-	unsigned loop_index = 0;
-
-	/* NOTE: data needs to be written in the reverse order. */
-
-	if (lnors) {
-		for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mp) {
-			ml = mloop + mp->loopstart + (mp->totloop - 1);
-
-			for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
-				const int index = ml->v;
-				copy_yup_from_zup(normals[loop_index].getValue(), lnors[index]);
-			}
-		}
-	}
-	else {
-		float no[3];
-
-		for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mp) {
-			ml = mloop + mp->loopstart + (mp->totloop - 1);
-
-			/* Flat shaded, use common normal for all verts. */
-			if ((mp->flag & ME_SMOOTH) == 0) {
-				BKE_mesh_calc_poly_normal(mp, ml - (mp->totloop - 1), verts, no);
-
-				for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
-					copy_yup_from_zup(normals[loop_index].getValue(), no);
-				}
-			}
-			else {
-				/* Smooth shaded, use individual vert normals. */
-				for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
-					normal_short_to_float_v3(no, verts[ml->v].no);
-					copy_yup_from_zup(normals[loop_index].getValue(), no);
-				}
-			}
-		}
-	}
+  MPoly *mp = mesh->mpoly;
+
+  MLoop *mloop = mesh->mloop;
+  MLoop *ml = mloop;
+
+  MVert *verts = mesh->mvert;
+
+  const float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
+
+  normals.clear();
+  normals.resize(mesh->totloop);
+
+  unsigned loop_index = 0;
+
+  /* NOTE: data needs to be written in the reverse order. */
+
+  if (lnors) {
+    for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mp) {
+      ml = mloop + mp->loopstart + (mp->totloop - 1);
+
+      for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
+        const int index = ml->v;
+        copy_yup_from_zup(normals[loop_index].getValue(), lnors[index]);
+      }
+    }
+  }
+  else {
+    float no[3];
+
+    for (int i = 0, e = mesh->totpoly; i < e; ++i, ++mp) {
+      ml = mloop + mp->loopstart + (mp->totloop - 1);
+
+      /* Flat shaded, use common normal for all verts. */
+      if ((mp->flag & ME_SMOOTH) == 0) {
+        BKE_mesh_calc_poly_normal(mp, ml - (mp->totloop - 1), verts, no);
+
+        for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
+          copy_yup_from_zup(normals[loop_index].getValue(), no);
+        }
+      }
+      else {
+        /* Smooth shaded, use individual vert normals. */
+        for (int j = 0; j < mp->totloop; --ml, ++j, ++loop_index) {
+          normal_short_to_float_v3(no, verts[ml->v].no);
+          copy_yup_from_zup(normals[loop_index].getValue(), no);
+        }
+      }
+    }
+  }
 }
 
 /* *************** Modifiers *************** */
@@ -248,43 +248,43 @@ static void get_loop_normals(struct Mesh *mesh, std::vector<Imath::V3f> &normals
  * displace if it's after subsurf. */
 static ModifierData *get_subsurf_modifier(Scene *scene, Object *ob)
 {
-	ModifierData *md = static_cast<ModifierData *>(ob->modifiers.last);
+  ModifierData *md = static_cast<ModifierData *>(ob->modifiers.last);
 
-	for (; md; md = md->prev) {
-		if (!modifier_isEnabled(scene, md, eModifierMode_Render)) {
-			continue;
-		}
+  for (; md; md = md->prev) {
+    if (!modifier_isEnabled(scene, md, eModifierMode_Render)) {
+      continue;
+    }
 
-		if (md->type == eModifierType_Subsurf) {
-			SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData*>(md);
+    if (md->type == eModifierType_Subsurf) {
+      SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
 
-			if (smd->subdivType == ME_CC_SUBSURF) {
-				return md;
-			}
-		}
+      if (smd->subdivType == ME_CC_SUBSURF) {
+        return md;
+      }
+    }
 
-		/* mesh is not a subsurf. break */
-		if ((md->type != eModifierType_Displace) && (md->type != eModifierType_ParticleSystem)) {
-			return NULL;
-		}
-	}
+    /* mesh is not a subsurf. break */
+    if ((md->type != eModifierType_Displace) && (md->type != eModifierType_ParticleSystem)) {
+      return NULL;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 static ModifierData *get_liquid_sim_modifier(Scene *scene, Object *ob)
 {
-	ModifierData *md = modifiers_findByType(ob, eModifierType_Fluidsim);
+  ModifierData *md = modifiers_findByType(ob, eModifierType_Fluidsim);
 
-	if (md && (modifier_isEnabled(scene, md, eModifierMode_Render))) {
-		FluidsimModifierData *fsmd = reinterpret_cast<FluidsimModifierData *>(md);
+  if (md && (modifier_isEnabled(scene, md, eModifierMode_Render))) {
+    FluidsimModifierData *fsmd = reinterpret_cast<FluidsimModifierData *>(md);
 
-		if (fsmd->fss && fsmd->fss->type == OB_FLUIDSIM_DOMAIN) {
-			return md;
-		}
-	}
+    if (fsmd->fss && fsmd->fss->type == OB_FLUIDSIM_DOMAIN) {
+      return md;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 /* ************************************************************************** */
@@ -295,390 +295,394 @@ AbcGenericMeshWriter::AbcGenericMeshWriter(Object *ob,
                                            ExportSettings &settings)
     : AbcObjectWriter(ob, time_sampling, settings, parent)
 {
-	m_is_animated = isAnimated();
-	m_subsurf_mod = NULL;
-	m_is_subd = false;
-
-	/* If the object is static, use the default static time sampling. */
-	if (!m_is_animated) {
-		time_sampling = 0;
-	}
-
-	if (!m_settings.apply_subdiv) {
-		m_subsurf_mod = get_subsurf_modifier(m_settings.scene, m_object);
-		m_is_subd = (m_subsurf_mod != NULL);
-	}
-
-	m_is_liquid = (get_liquid_sim_modifier(m_settings.scene, m_object) != NULL);
-
-	while (parent->alembicXform().getChildHeader(m_name)) {
-		m_name.append("_");
-	}
-
-	if (m_settings.use_subdiv_schema && m_is_subd) {
-		OSubD subd(parent->alembicXform(), m_name, m_time_sampling);
-		m_subdiv_schema = subd.getSchema();
-	}
-	else {
-		OPolyMesh mesh(parent->alembicXform(), m_name, m_time_sampling);
-		m_mesh_schema = mesh.getSchema();
-
-		OCompoundProperty typeContainer = m_mesh_schema.getUserProperties();
-		OBoolProperty type(typeContainer, "meshtype");
-		type.set(m_is_subd);
-	}
+  m_is_animated = isAnimated();
+  m_subsurf_mod = NULL;
+  m_is_subd = false;
+
+  /* If the object is static, use the default static time sampling. */
+  if (!m_is_animated) {
+    time_sampling = 0;
+  }
+
+  if (!m_settings.apply_subdiv) {
+    m_subsurf_mod = get_subsurf_modifier(m_settings.scene, m_object);
+    m_is_subd = (m_subsurf_mod != NULL);
+  }
+
+  m_is_liquid = (get_liquid_sim_modifier(m_settings.scene, m_object) != NULL);
+
+  while (parent->alembicXform().getChildHeader(m_name)) {
+    m_name.append("_");
+  }
+
+  if (m_settings.use_subdiv_schema && m_is_subd) {
+    OSubD subd(parent->alembicXform(), m_name, m_time_sampling);
+    m_subdiv_schema = subd.getSchema();
+  }
+  else {
+    OPolyMesh mesh(parent->alembicXform(), m_name, m_time_sampling);
+    m_mesh_schema = mesh.getSchema();
+
+    OCompoundProperty typeContainer = m_mesh_schema.getUserProperties();
+    OBoolProperty type(typeContainer, "meshtype");
+    type.set(m_is_subd);
+  }
 }
 
 AbcGenericMeshWriter::~AbcGenericMeshWriter()
 {
-	if (m_subsurf_mod) {
-		m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
-	}
+  if (m_subsurf_mod) {
+    m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
+  }
 }
 
 bool AbcGenericMeshWriter::isAnimated() const
 {
-	if (m_object->data != NULL) {
-		AnimData *adt = BKE_animdata_from_id(static_cast<ID*>(m_object->data));
-		/* TODO(Sybren): make this check more strict, as the AnimationData may
-		 * actually be empty (no fcurves, drivers, etc.) and thus effectively
-		 * have no animation at all. */
-		if (adt != NULL) {
-			return true;
-		}
-	}
-	if (BKE_key_from_object(m_object) != NULL) {
-		return true;
-	}
-
-	/* Test modifiers. */
-	ModifierData *md = static_cast<ModifierData *>(m_object->modifiers.first);
-	while (md) {
-
-		if (md->type != eModifierType_Subsurf) {
-			return true;
-		}
-
-		md = md->next;
-	}
-
-	return false;
+  if (m_object->data != NULL) {
+    AnimData *adt = BKE_animdata_from_id(static_cast<ID *>(m_object->data));
+    /* TODO(Sybren): make this check more strict, as the AnimationData may
+     * actually be empty (no fcurves, drivers, etc.) and thus effectively
+     * have no animation at all. */
+    if (adt != NULL) {
+      return true;
+    }
+  }
+  if (BKE_key_from_object(m_object) != NULL) {
+    return true;
+  }
+
+  /* Test modifiers. */
+  ModifierData *md = static_cast<ModifierData *>(m_object->modifiers.first);
+  while (md) {
+
+    if (md->type != eModifierType_Subsurf) {
+      return true;
+    }
+
+    md = md->next;
+  }
+
+  return false;
 }
 
 void AbcGenericMeshWriter::setIsAnimated(bool is_animated)
 {
-	m_is_animated = is_animated;
+  m_is_animated = is_animated;
 }
 
 void AbcGenericMeshWriter::do_write()
 {
-	/* We have already stored a sample for this object. */
-	if (!m_first_frame && !m_is_animated)
-		return;
-
-	bool needsfree;
-	struct Mesh *mesh = getFinalMesh(needsfree);
-
-	try {
-		if (m_settings.use_subdiv_schema && m_subdiv_schema.valid()) {
-			writeSubD(mesh);
-		}
-		else {
-			writeMesh(mesh);
-		}
-
-		if (needsfree) freeEvaluatedMesh(mesh);
-	}
-	catch (...) {
-		if (needsfree) freeEvaluatedMesh(mesh);
-		throw;
-	}
+  /* We have already stored a sample for this object. */
+  if (!m_first_frame && !m_is_animated)
+    return;
+
+  bool needsfree;
+  struct Mesh *mesh = getFinalMesh(needsfree);
+
+  try {
+    if (m_settings.use_subdiv_schema && m_subdiv_schema.valid()) {
+      writeSubD(mesh);
+    }
+    else {
+      writeMesh(mesh);
+    }
+
+    if (needsfree)
+      freeEvaluatedMesh(mesh);
+  }
+  catch (...) {
+    if (needsfree)
+      freeEvaluatedMesh(mesh);
+    throw;
+  }
 }
 
 void AbcGenericMeshWriter::freeEvaluatedMesh(struct Mesh *mesh)
 {
-	BKE_id_free(NULL, mesh);
+  BKE_id_free(NULL, mesh);
 }
 
 void AbcGenericMeshWriter::writeMesh(struct Mesh *mesh)
 {
-	std::vector<Imath::V3f> points, normals;
-	std::vector<int32_t> poly_verts, loop_counts;
+  std::vector<Imath::V3f> points, normals;
+  std::vector<int32_t> poly_verts, loop_counts;
 
-	bool smooth_normal = false;
+  bool smooth_normal = false;
 
-	get_vertices(mesh, points);
-	get_topology(mesh, poly_verts, loop_counts, smooth_normal);
+  get_vertices(mesh, points);
+  get_topology(mesh, poly_verts, loop_counts, smooth_normal);
 
-	if (m_first_frame && m_settings.export_face_sets) {
-		writeFaceSets(mesh, m_mesh_schema);
-	}
+  if (m_first_frame && m_settings.export_face_sets) {
+    writeFaceSets(mesh, m_mesh_schema);
+  }
 
-	m_mesh_sample = OPolyMeshSchema::Sample(V3fArraySample(points),
-	                                        Int32ArraySample(poly_verts),
-	                                        Int32ArraySample(loop_counts));
+  m_mesh_sample = OPolyMeshSchema::Sample(
+      V3fArraySample(points), Int32ArraySample(poly_verts), Int32ArraySample(loop_counts));
 
-	UVSample sample;
-	if (m_first_frame && m_settings.export_uvs) {
-		const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
+  UVSample sample;
+  if (m_first_frame && m_settings.export_uvs) {
+    const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
 
-		if (!sample.indices.empty() && !sample.uvs.empty()) {
-			OV2fGeomParam::Sample uv_sample;
-			uv_sample.setVals(V2fArraySample(sample.uvs));
-			uv_sample.setIndices(UInt32ArraySample(sample.indices));
-			uv_sample.setScope(kFacevaryingScope);
+    if (!sample.indices.empty() && !sample.uvs.empty()) {
+      OV2fGeomParam::Sample uv_sample;
+      uv_sample.setVals(V2fArraySample(sample.uvs));
+      uv_sample.setIndices(UInt32ArraySample(sample.indices));
+      uv_sample.setScope(kFacevaryingScope);
 
-			m_mesh_schema.setUVSourceName(name);
-			m_mesh_sample.setUVs(uv_sample);
-		}
+      m_mesh_schema.setUVSourceName(name);
+      m_mesh_sample.setUVs(uv_sample);
+    }
 
-		write_custom_data(m_mesh_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
-	}
+    write_custom_data(
+        m_mesh_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
+  }
 
-	if (m_settings.export_normals) {
-		if (smooth_normal) {
-			get_loop_normals(mesh, normals);
-		}
-		else {
-			get_vertex_normals(mesh, normals);
-		}
+  if (m_settings.export_normals) {
+    if (smooth_normal) {
+      get_loop_normals(mesh, normals);
+    }
+    else {
+      get_vertex_normals(mesh, normals);
+    }
 
-		ON3fGeomParam::Sample normals_sample;
-		if (!normals.empty()) {
-			normals_sample.setScope((smooth_normal) ? kFacevaryingScope : kVertexScope);
-			normals_sample.setVals(V3fArraySample(normals));
-		}
+    ON3fGeomParam::Sample normals_sample;
+    if (!normals.empty()) {
+      normals_sample.setScope((smooth_normal) ? kFacevaryingScope : kVertexScope);
+      normals_sample.setVals(V3fArraySample(normals));
+    }
 
-		m_mesh_sample.setNormals(normals_sample);
-	}
+    m_mesh_sample.setNormals(normals_sample);
+  }
 
-	if (m_is_liquid) {
-		std::vector<Imath::V3f> velocities;
-		getVelocities(mesh, velocities);
+  if (m_is_liquid) {
+    std::vector<Imath::V3f> velocities;
+    getVelocities(mesh, velocities);
 
-		m_mesh_sample.setVelocities(V3fArraySample(velocities));
-	}
+    m_mesh_sample.setVelocities(V3fArraySample(velocities));
+  }
 
-	m_mesh_sample.setSelfBounds(bounds());
+  m_mesh_sample.setSelfBounds(bounds());
 
-	m_mesh_schema.set(m_mesh_sample);
+  m_mesh_schema.set(m_mesh_sample);
 
-	writeArbGeoParams(mesh);
+  writeArbGeoParams(mesh);
 }
 
 void AbcGenericMeshWriter::writeSubD(struct Mesh *mesh)
 {
-	std::vector<float> crease_sharpness;
-	std::vector<Imath::V3f> points;
-	std::vector<int32_t> poly_verts, loop_counts;
-	std::vector<int32_t> crease_indices, crease_lengths;
+  std::vector<float> crease_sharpness;
+  std::vector<Imath::V3f> points;
+  std::vector<int32_t> poly_verts, loop_counts;
+  std::vector<int32_t> crease_indices, crease_lengths;
 
-	bool smooth_normal = false;
+  bool smooth_normal = false;
 
-	get_vertices(mesh, points);
-	get_topology(mesh, poly_verts, loop_counts, smooth_normal);
-	get_creases(mesh, crease_indices, crease_lengths, crease_sharpness);
+  get_vertices(mesh, points);
+  get_topology(mesh, poly_verts, loop_counts, smooth_normal);
+  get_creases(mesh, crease_indices, crease_lengths, crease_sharpness);
 
-	if (m_first_frame && m_settings.export_face_sets) {
-		writeFaceSets(mesh, m_subdiv_schema);
-	}
+  if (m_first_frame && m_settings.export_face_sets) {
+    writeFaceSets(mesh, m_subdiv_schema);
+  }
 
-	m_subdiv_sample = OSubDSchema::Sample(V3fArraySample(points),
-	                                      Int32ArraySample(poly_verts),
-	                                      Int32ArraySample(loop_counts));
+  m_subdiv_sample = OSubDSchema::Sample(
+      V3fArraySample(points), Int32ArraySample(poly_verts), Int32ArraySample(loop_counts));
 
-	UVSample sample;
-	if (m_first_frame && m_settings.export_uvs) {
-		const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
+  UVSample sample;
+  if (m_first_frame && m_settings.export_uvs) {
+    const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
 
-		if (!sample.indices.empty() && !sample.uvs.empty()) {
-			OV2fGeomParam::Sample uv_sample;
-			uv_sample.setVals(V2fArraySample(sample.uvs));
-			uv_sample.setIndices(UInt32ArraySample(sample.indices));
-			uv_sample.setScope(kFacevaryingScope);
+    if (!sample.indices.empty() && !sample.uvs.empty()) {
+      OV2fGeomParam::Sample uv_sample;
+      uv_sample.setVals(V2fArraySample(sample.uvs));
+      uv_sample.setIndices(UInt32ArraySample(sample.indices));
+      uv_sample.setScope(kFacevaryingScope);
 
-			m_subdiv_schema.setUVSourceName(name);
-			m_subdiv_sample.setUVs(uv_sample);
-		}
+      m_subdiv_schema.setUVSourceName(name);
+      m_subdiv_sample.setUVs(uv_sample);
+    }
 
-		write_custom_data(m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
-	}
+    write_custom_data(
+        m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
+  }
 
-	if (!crease_indices.empty()) {
-		m_subdiv_sample.setCreaseIndices(Int32ArraySample(crease_indices));
-		m_subdiv_sample.setCreaseLengths(Int32ArraySample(crease_lengths));
-		m_subdiv_sample.setCreaseSharpnesses(FloatArraySample(crease_sharpness));
-	}
+  if (!crease_indices.empty()) {
+    m_subdiv_sample.setCreaseIndices(Int32ArraySample(crease_indices));
+    m_subdiv_sample.setCreaseLengths(Int32ArraySample(crease_lengths));
+    m_subdiv_sample.setCreaseSharpnesses(FloatArraySample(crease_sharpness));
+  }
 
-	m_subdiv_sample.setSelfBounds(bounds());
-	m_subdiv_schema.set(m_subdiv_sample);
+  m_subdiv_sample.setSelfBounds(bounds());
+  m_subdiv_schema.set(m_subdiv_sample);
 
-	writeArbGeoParams(mesh);
+  writeArbGeoParams(mesh);
 }
 
-template <typename Schema>
-void AbcGenericMeshWriter::writeFaceSets(struct Mesh *me, Schema &schema)
+template<typename Schema> void AbcGenericMeshWriter::writeFaceSets(struct Mesh *me, Schema &schema)
 {
-	std::map< std::string, std::vector<int32_t>> geo_groups;
-	getGeoGroups(me, geo_groups);
-
-	std::map< std::string, std::vector<int32_t>>::iterator it;
-	for (it = geo_groups.begin(); it != geo_groups.end(); ++it) {
-		OFaceSet face_set = schema.createFaceSet(it->first);
-		OFaceSetSchema::Sample samp;
-		samp.setFaces(Int32ArraySample(it->second));
-		face_set.getSchema().set(samp);
-	}
+  std::map<std::string, std::vector<int32_t>> geo_groups;
+  getGeoGroups(me, geo_groups);
+
+  std::map<std::string, std::vector<int32_t>>::iterator it;
+  for (it = geo_groups.begin(); it != geo_groups.end(); ++it) {
+    OFaceSet face_set = schema.createFaceSet(it->first);
+    OFaceSetSchema::Sample samp;
+    samp.setFaces(Int32ArraySample(it->second));
+    face_set.getSchema().set(samp);
+  }
 }
 
 Mesh *AbcGenericMeshWriter::getFinalMesh(bool &r_needsfree)
 {
-	/* We don't want subdivided mesh data */
-	if (m_subsurf_mod) {
-		m_subsurf_mod->mode |= eModifierMode_DisableTemporary;
-	}
+  /* We don't want subdivided mesh data */
+  if (m_subsurf_mod) {
+    m_subsurf_mod->mode |= eModifierMode_DisableTemporary;
+  }
 
-	r_needsfree = false;
+  r_needsfree = false;
 
-	Scene *scene = DEG_get_evaluated_scene(m_settings.depsgraph);
-	Object *ob_eval = DEG_get_evaluated_object(m_settings.depsgraph, m_object);
-	struct Mesh *mesh = getEvaluatedMesh(scene, ob_eval, r_needsfree);
+  Scene *scene = DEG_get_evaluated_scene(m_settings.depsgraph);
+  Object *ob_eval = DEG_get_evaluated_object(m_settings.depsgraph, m_object);
+  struct Mesh *mesh = getEvaluatedMesh(scene, ob_eval, r_needsfree);
 
-	if (m_subsurf_mod) {
-		m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
-	}
+  if (m_subsurf_mod) {
+    m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
+  }
 
-	if (m_settings.triangulate) {
-		const bool tag_only = false;
-		const int quad_method = m_settings.quad_method;
-		const int ngon_method = m_settings.ngon_method;
+  if (m_settings.triangulate) {
+    const bool tag_only = false;
+    const int quad_method = m_settings.quad_method;
+    const int ngon_method = m_settings.ngon_method;
 
-		struct BMeshCreateParams bmcp = {false};
-		struct BMeshFromMeshParams bmfmp = {true, false, false, 0};
-		BMesh *bm = BKE_mesh_to_bmesh_ex(mesh, &bmcp, &bmfmp);
+    struct BMeshCreateParams bmcp = {false};
+    struct BMeshFromMeshParams bmfmp = {true, false, false, 0};
+    BMesh *bm = BKE_mesh_to_bmesh_ex(mesh, &bmcp, &bmfmp);
 
-		BM_mesh_triangulate(bm, quad_method, ngon_method, 4, tag_only, NULL, NULL, NULL);
+    BM_mesh_triangulate(bm, quad_method, ngon_method, 4, tag_only, NULL, NULL, NULL);
 
-		Mesh *result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
-		BM_mesh_free(bm);
+    Mesh *result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL);
+    BM_mesh_free(bm);
 
-		if (r_needsfree) {
-			BKE_id_free(NULL, mesh);
-		}
+    if (r_needsfree) {
+      BKE_id_free(NULL, mesh);
+    }
 
-		mesh = result;
-		r_needsfree = true;
-	}
+    mesh = result;
+    r_needsfree = true;
+  }
 
-	m_custom_data_config.pack_uvs = m_settings.pack_uv;
-	m_custom_data_config.mpoly = mesh->mpoly;
-	m_custom_data_config.mloop = mesh->mloop;
-	m_custom_data_config.totpoly = mesh->totpoly;
-	m_custom_data_config.totloop = mesh->totloop;
-	m_custom_data_config.totvert = mesh->totvert;
+  m_custom_data_config.pack_uvs = m_settings.pack_uv;
+  m_custom_data_config.mpoly = mesh->mpoly;
+  m_custom_data_config.mloop = mesh->mloop;
+  m_custom_data_config.totpoly = mesh->totpoly;
+  m_custom_data_config.totloop = mesh->totloop;
+  m_custom_data_config.totvert = mesh->totvert;
 
-	return mesh;
+  return mesh;
 }
 
 void AbcGenericMeshWriter::writeArbGeoParams(struct Mesh *me)
 {
-	if (m_is_liquid) {
-		/* We don't need anything more for liquid meshes. */
-		return;
-	}
-
-	if (m_first_frame && m_settings.export_vcols) {
-		if (m_subdiv_schema.valid()) {
-			write_custom_data(m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
-		}
-		else {
-			write_custom_data(m_mesh_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
-		}
-	}
+  if (m_is_liquid) {
+    /* We don't need anything more for liquid meshes. */
+    return;
+  }
+
+  if (m_first_frame && m_settings.export_vcols) {
+    if (m_subdiv_schema.valid()) {
+      write_custom_data(
+          m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
+    }
+    else {
+      write_custom_data(
+          m_mesh_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
+    }
+  }
 }
 
 void AbcGenericMeshWriter::getVelocities(struct Mesh *mesh, std::vector<Imath::V3f> &vels)
 {
-	const int totverts = mesh->totvert;
-
-	vels.clear();
-	vels.resize(totverts);
-
-	ModifierData *md = get_liquid_sim_modifier(m_settings.scene, m_object);
-	FluidsimModifierData *fmd = reinterpret_cast<FluidsimModifierData *>(md);
-	FluidsimSettings *fss = fmd->fss;
-
-	if (fss->meshVelocities) {
-		float *mesh_vels = reinterpret_cast<float *>(fss->meshVelocities);
-
-		for (int i = 0; i < totverts; ++i) {
-			copy_yup_from_zup(vels[i].getValue(), mesh_vels);
-			mesh_vels += 3;
-		}
-	}
-	else {
-		std::fill(vels.begin(), vels.end(), Imath::V3f(0.0f));
-	}
+  const int totverts = mesh->totvert;
+
+  vels.clear();
+  vels.resize(totverts);
+
+  ModifierData *md = get_liquid_sim_modifier(m_settings.scene, m_object);
+  FluidsimModifierData *fmd = reinterpret_cast<FluidsimModifierData *>(md);
+  FluidsimSettings *fss = fmd->fss;
+
+  if (fss->meshVelocities) {
+    float *mesh_vels = reinterpret_cast<float *>(fss->meshVelocities);
+
+    for (int i = 0; i < totverts; ++i) {
+      copy_yup_from_zup(vels[i].getValue(), mesh_vels);
+      mesh_vels += 3;
+    }
+  }
+  else {
+    std::fill(vels.begin(), vels.end(), Imath::V3f(0.0f));
+  }
 }
 
-void AbcGenericMeshWriter::getGeoGroups(
-        struct Mesh *mesh,
-        std::map<std::string, std::vector<int32_t>> &geo_groups)
+void AbcGenericMeshWriter::getGeoGroups(struct Mesh *mesh,
+                                        std::map<std::string, std::vector<int32_t>> &geo_groups)
 {
-	const int num_poly = mesh->totpoly;
-	MPoly *polygons = mesh->mpoly;
+  const int num_poly = mesh->totpoly;
+  MPoly *polygons = mesh->mpoly;
 
-	for (int i = 0; i < num_poly; ++i) {
-		MPoly &current_poly = polygons[i];
-		short mnr = current_poly.mat_nr;
+  for (int i = 0; i < num_poly; ++i) {
+    MPoly &current_poly = polygons[i];
+    short mnr = current_poly.mat_nr;
 
-		Material *mat = give_current_material(m_object, mnr + 1);
+    Material *mat = give_current_material(m_object, mnr + 1);
 
-		if (!mat) {
-			continue;
-		}
+    if (!mat) {
+      continue;
+    }
 
-		std::string name = get_id_name(&mat->id);
+    std::string name = get_id_name(&mat->id);
 
-		if (geo_groups.find(name) == geo_groups.end()) {
-			std::vector<int32_t> faceArray;
-			geo_groups[name] = faceArray;
-		}
+    if (geo_groups.find(name) == geo_groups.end()) {
+      std::vector<int32_t> faceArray;
+      geo_groups[name] = faceArray;
+    }
 
-		geo_groups[name].push_back(i);
-	}
+    geo_groups[name].push_back(i);
+  }
 
-	if (geo_groups.size() == 0) {
-		Material *mat = give_current_material(m_object, 1);
+  if (geo_groups.size() == 0) {
+    Material *mat = give_current_material(m_object, 1);
 
-		std::string name = (mat) ? get_id_name(&mat->id) : "default";
+    std::string name = (mat) ? get_id_name(&mat->id) : "default";
 
-		std::vector<int32_t> faceArray;
+    std::vector<int32_t> faceArray;
 
-		for (int i = 0, e = mesh->totface; i < e; ++i) {
-			faceArray.push_back(i);
-		}
+    for (int i = 0, e = mesh->totface; i < e; ++i) {
+      faceArray.push_back(i);
+    }
 
-		geo_groups[name] = faceArray;
-	}
+    geo_groups[name] = faceArray;
+  }
 }
 
-
 AbcMeshWriter::AbcMeshWriter(Object *ob,
                              AbcTransformWriter *parent,
                              uint32_t time_sampling,
                              ExportSettings &settings)
     : AbcGenericMeshWriter(ob, parent, time_sampling, settings)
-{}
+{
+}
 
 AbcMeshWriter::~AbcMeshWriter()
-{}
-
-Mesh *AbcMeshWriter::getEvaluatedMesh(Scene *scene_eval, Object *ob_eval, bool &UNUSED(r_needsfree))
 {
-	return mesh_get_eval_final(m_settings.depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
 }
 
+Mesh *AbcMeshWriter::getEvaluatedMesh(Scene *scene_eval,
+                                      Object *ob_eval,
+                                      bool &UNUSED(r_needsfree))
+{
+  return mesh_get_eval_final(m_settings.depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
+}
 
 /* ************************************************************************** */
 
@@ -687,55 +691,57 @@ namespace utils {
 
 static void build_mat_map(const Main *bmain, std::map<std::string, Material *> &mat_map)
 {
-	Material *material = static_cast<Material *>(bmain->materials.first);
+  Material *material = static_cast<Material *>(bmain->materials.first);
 
-	for (; material; material = static_cast<Material *>(material->id.next)) {
-		mat_map[material->id.name + 2] = material;
-	}
+  for (; material; material = static_cast<Material *>(material->id.next)) {
+    mat_map[material->id.name + 2] = material;
+  }
 }
 
-static void assign_materials(Main *bmain, Object *ob, const std::map<std::string, int> &mat_index_map)
+static void assign_materials(Main *bmain,
+                             Object *ob,
+                             const std::map<std::string, int> &mat_index_map)
 {
-	bool can_assign = true;
-	std::map<std::string, int>::const_iterator it = mat_index_map.begin();
-
-	int matcount = 0;
-	for (; it != mat_index_map.end(); ++it, ++matcount) {
-		if (!BKE_object_material_slot_add(bmain, ob)) {
-			can_assign = false;
-			break;
-		}
-	}
-
-	/* TODO(kevin): use global map? */
-	std::map<std::string, Material *> mat_map;
-	build_mat_map(bmain, mat_map);
-
-	std::map<std::string, Material *>::iterator mat_iter;
-
-	if (can_assign) {
-		it = mat_index_map.begin();
-
-		for (; it != mat_index_map.end(); ++it) {
-			std::string mat_name = it->first;
-			mat_iter = mat_map.find(mat_name.c_str());
-
-			Material *assigned_mat;
-
-			if (mat_iter == mat_map.end()) {
-				assigned_mat = BKE_material_add(bmain, mat_name.c_str());
-				mat_map[mat_name] = assigned_mat;
-			}
-			else {
-				assigned_mat = mat_iter->second;
-			}
-
-			assign_material(bmain, ob, assigned_mat, it->second, BKE_MAT_ASSIGN_OBDATA);
-		}
-	}
+  bool can_assign = true;
+  std::map<std::string, int>::const_iterator it = mat_index_map.begin();
+
+  int matcount = 0;
+  for (; it != mat_index_map.end(); ++it, ++matcount) {
+    if (!BKE_object_material_slot_add(bmain, ob)) {
+      can_assign = false;
+      break;
+    }
+  }
+
+  /* TODO(kevin): use global map? */
+  std::map<std::string, Material *> mat_map;
+  build_mat_map(bmain, mat_map);
+
+  std::map<std::string, Material *>::iterator mat_iter;
+
+  if (can_assign) {
+    it = mat_index_map.begin();
+
+    for (; it != mat_index_map.end(); ++it) {
+      std::string mat_name = it->first;
+      mat_iter = mat_map.find(mat_name.c_str());
+
+      Material *assigned_mat;
+
+      if (mat_iter == mat_map.end()) {
+        assigned_mat = BKE_material_add(bmain, mat_name.c_str());
+        mat_map[mat_name] = assigned_mat;
+      }
+      else {
+        assigned_mat = mat_iter->second;
+      }
+
+      assign_material(bmain, ob, assigned_mat, it->second, BKE_MAT_ASSIGN_OBDATA);
+    }
+  }
 }
 
-}  /* namespace utils */
+} /* namespace utils */
 
 /* ************************************************************************** */
 
@@ -743,116 +749,120 @@ using Alembic::AbcGeom::UInt32ArraySamplePtr;
 using Alembic::AbcGeom::V2fArraySamplePtr;
 
 struct AbcMeshData {
-	Int32ArraySamplePtr face_indices;
-	Int32ArraySamplePtr face_counts;
+  Int32ArraySamplePtr face_indices;
+  Int32ArraySamplePtr face_counts;
 
-	P3fArraySamplePtr positions;
-	P3fArraySamplePtr ceil_positions;
+  P3fArraySamplePtr positions;
+  P3fArraySamplePtr ceil_positions;
 
-	N3fArraySamplePtr vertex_normals;
-	N3fArraySamplePtr face_normals;
+  N3fArraySamplePtr vertex_normals;
+  N3fArraySamplePtr face_normals;
 
-	V2fArraySamplePtr uvs;
-	UInt32ArraySamplePtr uvs_indices;
+  V2fArraySamplePtr uvs;
+  UInt32ArraySamplePtr uvs_indices;
 };
 
-static void read_mverts_interp(MVert *mverts, const P3fArraySamplePtr &positions, const P3fArraySamplePtr &ceil_positions, const float weight)
+static void read_mverts_interp(MVert *mverts,
+                               const P3fArraySamplePtr &positions,
+                               const P3fArraySamplePtr &ceil_positions,
+                               const float weight)
 {
-	float tmp[3];
-	for (int i = 0; i < positions->size(); ++i) {
-		MVert &mvert = mverts[i];
-		const Imath::V3f &floor_pos = (*positions)[i];
-		const Imath::V3f &ceil_pos = (*ceil_positions)[i];
+  float tmp[3];
+  for (int i = 0; i < positions->size(); ++i) {
+    MVert &mvert = mverts[i];
+    const Imath::V3f &floor_pos = (*positions)[i];
+    const Imath::V3f &ceil_pos = (*ceil_positions)[i];
 
-		interp_v3_v3v3(tmp, floor_pos.getValue(), ceil_pos.getValue(), weight);
-		copy_zup_from_yup(mvert.co, tmp);
+    interp_v3_v3v3(tmp, floor_pos.getValue(), ceil_pos.getValue(), weight);
+    copy_zup_from_yup(mvert.co, tmp);
 
-		mvert.bweight = 0;
-	}
+    mvert.bweight = 0;
+  }
 }
 
 static void read_mverts(CDStreamConfig &config, const AbcMeshData &mesh_data)
 {
-	MVert *mverts = config.mvert;
-	const P3fArraySamplePtr &positions = mesh_data.positions;
-	const N3fArraySamplePtr &normals = mesh_data.vertex_normals;
-
-	if (   config.weight != 0.0f
-	    && mesh_data.ceil_positions != NULL
-	    && mesh_data.ceil_positions->size() == positions->size())
-	{
-		read_mverts_interp(mverts, positions, mesh_data.ceil_positions, config.weight);
-		return;
-	}
-
-	read_mverts(mverts, positions, normals);
+  MVert *mverts = config.mvert;
+  const P3fArraySamplePtr &positions = mesh_data.positions;
+  const N3fArraySamplePtr &normals = mesh_data.vertex_normals;
+
+  if (config.weight != 0.0f && mesh_data.ceil_positions != NULL &&
+      mesh_data.ceil_positions->size() == positions->size()) {
+    read_mverts_interp(mverts, positions, mesh_data.ceil_positions, config.weight);
+    return;
+  }
+
+  read_mverts(mverts, positions, normals);
 }
 
-void read_mverts(MVert *mverts, const P3fArraySamplePtr &positions, const N3fArraySamplePtr &normals)
+void read_mverts(MVert *mverts,
+                 const P3fArraySamplePtr &positions,
+                 const N3fArraySamplePtr &normals)
 {
-	for (int i = 0; i < positions->size(); ++i) {
-		MVert &mvert = mverts[i];
-		Imath::V3f pos_in = (*positions)[i];
+  for (int i = 0; i < positions->size(); ++i) {
+    MVert &mvert = mverts[i];
+    Imath::V3f pos_in = (*positions)[i];
 
-		copy_zup_from_yup(mvert.co, pos_in.getValue());
+    copy_zup_from_yup(mvert.co, pos_in.getValue());
 
-		mvert.bweight = 0;
+    mvert.bweight = 0;
 
-		if (normals) {
-			Imath::V3f nor_in = (*normals)[i];
+    if (normals) {
+      Imath::V3f nor_in = (*normals)[i];
 
-			short no[3];
-			normal_float_to_short_v3(no, nor_in.getValue());
+      short no[3];
+      normal_float_to_short_v3(no, nor_in.getValue());
 
-			copy_zup_from_yup(mvert.no, no);
-		}
-	}
+      copy_zup_from_yup(mvert.no, no);
+    }
+  }
 }
 
 static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
 {
-	MPoly *mpolys = config.mpoly;
-	MLoop *mloops = config.mloop;
-	MLoopUV *mloopuvs = config.mloopuv;
-
-	const Int32ArraySamplePtr &face_indices = mesh_data.face_indices;
-	const Int32ArraySamplePtr &face_counts = mesh_data.face_counts;
-	const V2fArraySamplePtr &uvs = mesh_data.uvs;
-	const UInt32ArraySamplePtr &uvs_indices = mesh_data.uvs_indices;
-	const N3fArraySamplePtr &normals = mesh_data.face_normals;
-
-	const bool do_uvs = (mloopuvs && uvs && uvs_indices) && (uvs_indices->size() == face_indices->size());
-	unsigned int loop_index = 0;
-	unsigned int rev_loop_index = 0;
-	unsigned int uv_index = 0;
-
-	for (int i = 0; i < face_counts->size(); ++i) {
-		const int face_size = (*face_counts)[i];
-
-		MPoly &poly = mpolys[i];
-		poly.loopstart = loop_index;
-		poly.totloop = face_size;
-
-		if (normals != NULL) {
-			poly.flag |= ME_SMOOTH;
-		}
-
-		/* NOTE: Alembic data is stored in the reverse order. */
-		rev_loop_index = loop_index + (face_size - 1);
-
-		for (int f = 0; f < face_size; ++f, ++loop_index, --rev_loop_index) {
-			MLoop &loop = mloops[rev_loop_index];
-			loop.v = (*face_indices)[loop_index];
-
-			if (do_uvs) {
-				MLoopUV &loopuv = mloopuvs[rev_loop_index];
-
-				uv_index = (*uvs_indices)[loop_index];
-				loopuv.uv[0] = (*uvs)[uv_index][0];
-				loopuv.uv[1] = (*uvs)[uv_index][1];
-			}
-		}
-	}
+  MPoly *mpolys = config.mpoly;
+  MLoop *mloops = config.mloop;
+  MLoopUV *mloopuvs = config.mloopuv;
+
+  const Int32ArraySamplePtr &face_indices = mesh_data.face_indices;
+  const Int32ArraySamplePtr &face_counts = mesh_data.face_counts;
+  const V2fArraySamplePtr &uvs = mesh_data.uvs;
+  const UInt32ArraySamplePtr &uvs_indices = mesh_data.uvs_indices;
+  const N3fArraySamplePtr &normals = mesh_data.face_normals;
+
+  const bool do_uvs = (mloopuvs && uvs && uvs_indices) &&
+                      (uvs_indices->size() == face_indices->size());
+  unsigned int loop_index = 0;
+  unsigned int rev_loop_index = 0;
+  unsigned int uv_index = 0;
+
+  for (int i = 0; i < face_counts->size(); ++i) {
+    const int face_size = (*face_counts)[i];
+
+    MPoly &poly = mpolys[i];
+    poly.loopstart = loop_index;
+    poly.totloop = face_size;
+
+    if (normals != NULL) {
+      poly.flag |= ME_SMOOTH;
+    }
+
+    /* NOTE: Alembic data is stored in the reverse order. */
+    rev_loop_index = loop_index + (face_size - 1);
+
+    for (int f = 0; f < face_size; ++f, ++loop_index, --rev_loop_index) {
+      MLoop &loop = mloops[rev_loop_index];
+      loop.v = (*face_indices)[loop_index];
+
+      if (do_uvs) {
+        MLoopUV &loopuv = mloopuvs[rev_loop_index];
+
+        uv_index = (*uvs_indices)[loop_index];
+        loopuv.uv[0] = (*uvs)[uv_index][0];
+        loopuv.uv[1] = (*uvs)[uv_index][1];
+      }
+    }
+  }
 }
 
 ABC_INLINE void read_uvs_params(CDStreamConfig &config,
@@ -860,29 +870,29 @@ ABC_INLINE void read_uvs_params(CDStreamConfig &config,
                                 const IV2fGeomParam &uv,
                                 const ISampleSelector &selector)
 {
-	if (!uv.valid()) {
-		return;
-	}
+  if (!uv.valid()) {
+    return;
+  }
 
-	IV2fGeomParam::Sample uvsamp;
-	uv.getIndexed(uvsamp, selector);
+  IV2fGeomParam::Sample uvsamp;
+  uv.getIndexed(uvsamp, selector);
 
-	abc_data.uvs = uvsamp.getVals();
-	abc_data.uvs_indices = uvsamp.getIndices();
+  abc_data.uvs = uvsamp.getVals();
+  abc_data.uvs_indices = uvsamp.getIndices();
 
-	if (abc_data.uvs_indices->size() == config.totloop) {
-		std::string name = Alembic::Abc::GetSourceName(uv.getMetaData());
+  if (abc_data.uvs_indices->size() == config.totloop) {
+    std::string name = Alembic::Abc::GetSourceName(uv.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 = uv.getName();
-		}
+    /* 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 = uv.getName();
+    }
 
-		void *cd_ptr = config.add_customdata_cb(config.user_data, name.c_str(), CD_MLOOPUV);
-		config.mloopuv = static_cast<MLoopUV *>(cd_ptr);
-	}
+    void *cd_ptr = config.add_customdata_cb(config.user_data, name.c_str(), CD_MLOOPUV);
+    config.mloopuv = static_cast<MLoopUV *>(cd_ptr);
+  }
 }
 
 /* TODO(kevin): normals from Alembic files are not read in anymore, this is due
@@ -893,149 +903,143 @@ ABC_INLINE void read_normals_params(AbcMeshData &abc_data,
                                     const IN3fGeomParam &normals,
                                     const ISampleSelector &selector)
 {
-	if (!normals.valid()) {
-		return;
-	}
-
-	IN3fGeomParam::Sample normsamp = normals.getExpandedValue(selector);
-
-	if (normals.getScope() == kFacevaryingScope) {
-		abc_data.face_normals = normsamp.getVals();
-	}
-	else if ((normals.getScope() == kVertexScope) || (normals.getScope() == kVaryingScope)) {
-		abc_data.vertex_normals = N3fArraySamplePtr();
-	}
+  if (!normals.valid()) {
+    return;
+  }
+
+  IN3fGeomParam::Sample normsamp = normals.getExpandedValue(selector);
+
+  if (normals.getScope() == kFacevaryingScope) {
+    abc_data.face_normals = normsamp.getVals();
+  }
+  else if ((normals.getScope() == kVertexScope) || (normals.getScope() == kVaryingScope)) {
+    abc_data.vertex_normals = N3fArraySamplePtr();
+  }
 }
 
 static bool check_smooth_poly_flag(Mesh *mesh)
 {
-	MPoly *mpolys = mesh->mpoly;
+  MPoly *mpolys = mesh->mpoly;
 
-	for (int i = 0, e = mesh->totpoly; i < e; ++i) {
-		MPoly &poly = mpolys[i];
+  for (int i = 0, e = mesh->totpoly; i < e; ++i) {
+    MPoly &poly = mpolys[i];
 
-		if ((poly.flag & ME_SMOOTH) != 0) {
-			return true;
-		}
-	}
+    if ((poly.flag & ME_SMOOTH) != 0) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void set_smooth_poly_flag(Mesh *mesh)
 {
-	MPoly *mpolys = mesh->mpoly;
+  MPoly *mpolys = mesh->mpoly;
 
-	for (int i = 0, e = mesh->totpoly; i < e; ++i) {
-		MPoly &poly = mpolys[i];
-		poly.flag |= ME_SMOOTH;
-	}
+  for (int i = 0, e = mesh->totpoly; i < e; ++i) {
+    MPoly &poly = mpolys[i];
+    poly.flag |= ME_SMOOTH;
+  }
 }
 
 static void *add_customdata_cb(void *user_data, const char *name, int data_type)
 {
-	Mesh *mesh = static_cast<Mesh *>(user_data);
-	CustomDataType cd_data_type = static_cast<CustomDataType>(data_type);
-	void *cd_ptr;
-	CustomData *loopdata;
-	int numloops;
-
-	/* unsupported custom data type -- don't do anything. */
-	if (!ELEM(cd_data_type, CD_MLOOPUV, CD_MLOOPCOL)) {
-		return NULL;
-	}
-
-	loopdata = &mesh->ldata;
-	cd_ptr = CustomData_get_layer_named(loopdata, cd_data_type, name);
-	if (cd_ptr != NULL) {
-		/* layer already exists, so just return it. */
-		return cd_ptr;
-	}
-
-	/* create a new layer, taking care to construct the hopefully-soon-to-be-removed
-	 * CD_MTEXPOLY layer too, with the same name. */
-	numloops = mesh->totloop;
-	cd_ptr = CustomData_add_layer_named(loopdata, cd_data_type, CD_DEFAULT,
-	                                    NULL, numloops, name);
-	return cd_ptr;
+  Mesh *mesh = static_cast<Mesh *>(user_data);
+  CustomDataType cd_data_type = static_cast<CustomDataType>(data_type);
+  void *cd_ptr;
+  CustomData *loopdata;
+  int numloops;
+
+  /* unsupported custom data type -- don't do anything. */
+  if (!ELEM(cd_data_type, CD_MLOOPUV, CD_MLOOPCOL)) {
+    return NULL;
+  }
+
+  loopdata = &mesh->ldata;
+  cd_ptr = CustomData_get_layer_named(loopdata, cd_data_type, name);
+  if (cd_ptr != NULL) {
+    /* layer already exists, so just return it. */
+    return cd_ptr;
+  }
+
+  /* create a new layer, taking care to construct the hopefully-soon-to-be-removed
+   * CD_MTEXPOLY layer too, with the same name. */
+  numloops = mesh->totloop;
+  cd_ptr = CustomData_add_layer_named(loopdata, cd_data_type, CD_DEFAULT, NULL, numloops, name);
+  return cd_ptr;
 }
 
 static void get_weight_and_index(CDStreamConfig &config,
                                  Alembic::AbcCoreAbstract::TimeSamplingPtr time_sampling,
                                  size_t samples_number)
 {
-	Alembic::AbcGeom::index_t i0, i1;
+  Alembic::AbcGeom::index_t i0, i1;
 
-	config.weight = get_weight_and_index(config.time,
-	                                     time_sampling,
-	                                     samples_number,
-	                                     i0,
-	                                     i1);
+  config.weight = get_weight_and_index(config.time, time_sampling, samples_number, i0, i1);
 
-	config.index = i0;
-	config.ceil_index = i1;
+  config.index = i0;
+  config.ceil_index = i1;
 }
 
-static void read_mesh_sample(const std::string & iobject_full_name,
+static void read_mesh_sample(const std::string &iobject_full_name,
                              ImportSettings *settings,
                              const IPolyMeshSchema &schema,
                              const ISampleSelector &selector,
                              CDStreamConfig &config,
                              bool &do_normals)
 {
-	const IPolyMeshSchema::Sample sample = schema.getValue(selector);
+  const IPolyMeshSchema::Sample sample = schema.getValue(selector);
 
-	AbcMeshData abc_mesh_data;
-	abc_mesh_data.face_counts = sample.getFaceCounts();
-	abc_mesh_data.face_indices = sample.getFaceIndices();
-	abc_mesh_data.positions = sample.getPositions();
+  AbcMeshData abc_mesh_data;
+  abc_mesh_data.face_counts = sample.getFaceCounts();
+  abc_mesh_data.face_indices = sample.getFaceIndices();
+  abc_mesh_data.positions = sample.getPositions();
 
-	read_normals_params(abc_mesh_data, schema.getNormalsParam(), selector);
+  read_normals_params(abc_mesh_data, schema.getNormalsParam(), selector);
 
-	do_normals = (abc_mesh_data.face_normals != NULL);
+  do_normals = (abc_mesh_data.face_normals != NULL);
 
-	get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
+  get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
 
-	if (config.weight != 0.0f) {
-		Alembic::AbcGeom::IPolyMeshSchema::Sample ceil_sample;
-		schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
-		abc_mesh_data.ceil_positions = ceil_sample.getPositions();
-	}
+  if (config.weight != 0.0f) {
+    Alembic::AbcGeom::IPolyMeshSchema::Sample ceil_sample;
+    schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
+    abc_mesh_data.ceil_positions = ceil_sample.getPositions();
+  }
 
-	if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
-		read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
-	}
+  if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
+    read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
+  }
 
-	if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
-		read_mverts(config, abc_mesh_data);
-	}
+  if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
+    read_mverts(config, abc_mesh_data);
+  }
 
-	if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
-		read_mpolys(config, abc_mesh_data);
-	}
+  if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
+    read_mpolys(config, abc_mesh_data);
+  }
 
-	if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
-		read_custom_data(iobject_full_name,
-		                 schema.getArbGeomParams(), config, selector);
-	}
+  if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
+    read_custom_data(iobject_full_name, schema.getArbGeomParams(), config, selector);
+  }
 }
 
 CDStreamConfig get_config(Mesh *mesh)
 {
-	CDStreamConfig config;
+  CDStreamConfig config;
 
-	BLI_assert(mesh->mvert || mesh->totvert == 0);
+  BLI_assert(mesh->mvert || mesh->totvert == 0);
 
-	config.user_data = mesh;
-	config.mvert = mesh->mvert;
-	config.mloop = mesh->mloop;
-	config.mpoly = mesh->mpoly;
-	config.totloop = mesh->totloop;
-	config.totpoly = mesh->totpoly;
-	config.loopdata = &mesh->ldata;
-	config.add_customdata_cb = add_customdata_cb;
+  config.user_data = mesh;
+  config.mvert = mesh->mvert;
+  config.mloop = mesh->mloop;
+  config.mpoly = mesh->mpoly;
+  config.totloop = mesh->totloop;
+  config.totpoly = mesh->totpoly;
+  config.loopdata = &mesh->ldata;
+  config.add_customdata_cb = add_customdata_cb;
 
-	return config;
+  return config;
 }
 
 /* ************************************************************************** */
@@ -1043,57 +1047,60 @@ CDStreamConfig get_config(Mesh *mesh)
 AbcMeshReader::AbcMeshReader(const IObject &object, ImportSettings &settings)
     : AbcObjectReader(object, settings)
 {
-	m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
+  m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
 
-	IPolyMesh ipoly_mesh(m_iobject, kWrapExisting);
-	m_schema = ipoly_mesh.getSchema();
+  IPolyMesh ipoly_mesh(m_iobject, kWrapExisting);
+  m_schema = ipoly_mesh.getSchema();
 
-	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
+  get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcMeshReader::valid() const
 {
-	return m_schema.valid();
+  return m_schema.valid();
 }
 
 void AbcMeshReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel)
 {
-	Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
+  Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
 
-	m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
-	m_object->data = mesh;
+  m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
+  m_object->data = mesh;
 
-	Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
-	if (read_mesh != mesh) {
-		BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
-	}
+  Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
+  if (read_mesh != mesh) {
+    BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
+  }
 
-	if (m_settings->validate_meshes) {
-		BKE_mesh_validate(mesh, false, false);
-	}
+  if (m_settings->validate_meshes) {
+    BKE_mesh_validate(mesh, false, false);
+  }
 
-	readFaceSetsSample(bmain, mesh, 0, sample_sel);
+  readFaceSetsSample(bmain, mesh, 0, sample_sel);
 
-	if (has_animations(m_schema, m_settings)) {
-		addCacheModifier();
-	}
+  if (has_animations(m_schema, m_settings)) {
+    addCacheModifier();
+  }
 }
 
-bool AbcMeshReader::accepts_object_type(const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
-                                        const Object *const ob,
-                                        const char **err_str) const
+bool AbcMeshReader::accepts_object_type(
+    const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
+    const Object *const ob,
+    const char **err_str) const
 {
-	if (!Alembic::AbcGeom::IPolyMesh::matches(alembic_header)) {
-		*err_str = "Object type mismatch, Alembic object path pointed to PolyMesh when importing, but not any more.";
-		return false;
-	}
-
-	if (ob->type != OB_MESH) {
-		*err_str = "Object type mismatch, Alembic object path points to PolyMesh.";
-		return false;
-	}
-
-	return true;
+  if (!Alembic::AbcGeom::IPolyMesh::matches(alembic_header)) {
+    *err_str =
+        "Object type mismatch, Alembic object path pointed to PolyMesh when importing, but not "
+        "any more.";
+    return false;
+  }
+
+  if (ob->type != OB_MESH) {
+    *err_str = "Object type mismatch, Alembic object path points to PolyMesh.";
+    return false;
+  }
+
+  return true;
 }
 
 Mesh *AbcMeshReader::read_mesh(Mesh *existing_mesh,
@@ -1101,209 +1108,202 @@ Mesh *AbcMeshReader::read_mesh(Mesh *existing_mesh,
                                int read_flag,
                                const char **err_str)
 {
-	IPolyMeshSchema::Sample sample;
-	try {
-		sample = m_schema.getValue(sample_sel);
-	}
-	catch(Alembic::Util::Exception &ex) {
-		*err_str = "Error reading mesh sample; more detail on the console";
-		printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
-		       m_iobject.getFullName().c_str(),
-		       m_schema.getName().c_str(),
-		       sample_sel.getRequestedTime(),
-		       ex.what());
-		return existing_mesh;
-	}
-
-	const P3fArraySamplePtr &positions = sample.getPositions();
-	const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
-	const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
-
-	Mesh *new_mesh = NULL;
-
-	/* Only read point data when streaming meshes, unless we need to create new ones. */
-	ImportSettings settings;
-	settings.read_flag |= read_flag;
-
-	bool topology_changed =  positions->size() != existing_mesh->totvert ||
-	                         face_counts->size() != existing_mesh->totpoly ||
-	                         face_indices->size() != existing_mesh->totloop;
-	if (topology_changed) {
-		new_mesh = BKE_mesh_new_nomain_from_template(existing_mesh,
-		                                             positions->size(),
-		                                             0,
-		                                             0,
-		                                             face_indices->size(),
-		                                             face_counts->size());
-
-		settings.read_flag |= MOD_MESHSEQ_READ_ALL;
-	}
-	else {
-		/* If the face count changed (e.g. by triangulation), only read points.
-		 * This prevents crash from T49813.
-		 * TODO(kevin): perhaps find a better way to do this? */
-		if (face_counts->size() != existing_mesh->totpoly ||
-		    face_indices->size() != existing_mesh->totloop)
-		{
-			settings.read_flag = MOD_MESHSEQ_READ_VERT;
-
-			if (err_str) {
-				*err_str = "Topology has changed, perhaps by triangulating the"
-				           " mesh. Only vertices will be read!";
-			}
-		}
-	}
-
-	CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
-	config.time = sample_sel.getRequestedTime();
-
-	bool do_normals = false;
-	read_mesh_sample(m_iobject.getFullName(),
-	                 &settings, m_schema, sample_sel, config, do_normals);
-
-	if (new_mesh) {
-		/* Check if we had ME_SMOOTH flag set to restore it. */
-		if (!do_normals && check_smooth_poly_flag(existing_mesh)) {
-			set_smooth_poly_flag(new_mesh);
-		}
-
-		BKE_mesh_calc_normals(new_mesh);
-		BKE_mesh_calc_edges(new_mesh, false, false);
-
-		/* Here we assume that the number of materials doesn't change, i.e. that
-		 * the material slots that were created when the object was loaded from
-		 * Alembic are still valid now. */
-		size_t num_polys = new_mesh->totpoly;
-		if (num_polys > 0) {
-			std::map<std::string, int> mat_map;
-			assign_facesets_to_mpoly(sample_sel, 0, new_mesh->mpoly, num_polys, mat_map);
-		}
-
-		return new_mesh;
-	}
-
-	if (do_normals) {
-		BKE_mesh_calc_normals(existing_mesh);
-	}
-
-	return existing_mesh;
+  IPolyMeshSchema::Sample sample;
+  try {
+    sample = m_schema.getValue(sample_sel);
+  }
+  catch (Alembic::Util::Exception &ex) {
+    *err_str = "Error reading mesh sample; more detail on the console";
+    printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
+           m_iobject.getFullName().c_str(),
+           m_schema.getName().c_str(),
+           sample_sel.getRequestedTime(),
+           ex.what());
+    return existing_mesh;
+  }
+
+  const P3fArraySamplePtr &positions = sample.getPositions();
+  const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
+  const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
+
+  Mesh *new_mesh = NULL;
+
+  /* Only read point data when streaming meshes, unless we need to create new ones. */
+  ImportSettings settings;
+  settings.read_flag |= read_flag;
+
+  bool topology_changed = positions->size() != existing_mesh->totvert ||
+                          face_counts->size() != existing_mesh->totpoly ||
+                          face_indices->size() != existing_mesh->totloop;
+  if (topology_changed) {
+    new_mesh = BKE_mesh_new_nomain_from_template(
+        existing_mesh, positions->size(), 0, 0, face_indices->size(), face_counts->size());
+
+    settings.read_flag |= MOD_MESHSEQ_READ_ALL;
+  }
+  else {
+    /* If the face count changed (e.g. by triangulation), only read points.
+     * This prevents crash from T49813.
+     * TODO(kevin): perhaps find a better way to do this? */
+    if (face_counts->size() != existing_mesh->totpoly ||
+        face_indices->size() != existing_mesh->totloop) {
+      settings.read_flag = MOD_MESHSEQ_READ_VERT;
+
+      if (err_str) {
+        *err_str =
+            "Topology has changed, perhaps by triangulating the"
+            " mesh. Only vertices will be read!";
+      }
+    }
+  }
+
+  CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
+  config.time = sample_sel.getRequestedTime();
+
+  bool do_normals = false;
+  read_mesh_sample(m_iobject.getFullName(), &settings, m_schema, sample_sel, config, do_normals);
+
+  if (new_mesh) {
+    /* Check if we had ME_SMOOTH flag set to restore it. */
+    if (!do_normals && check_smooth_poly_flag(existing_mesh)) {
+      set_smooth_poly_flag(new_mesh);
+    }
+
+    BKE_mesh_calc_normals(new_mesh);
+    BKE_mesh_calc_edges(new_mesh, false, false);
+
+    /* Here we assume that the number of materials doesn't change, i.e. that
+     * the material slots that were created when the object was loaded from
+     * Alembic are still valid now. */
+    size_t num_polys = new_mesh->totpoly;
+    if (num_polys > 0) {
+      std::map<std::string, int> mat_map;
+      assign_facesets_to_mpoly(sample_sel, 0, new_mesh->mpoly, num_polys, mat_map);
+    }
+
+    return new_mesh;
+  }
+
+  if (do_normals) {
+    BKE_mesh_calc_normals(existing_mesh);
+  }
+
+  return existing_mesh;
 }
 
-void AbcMeshReader::assign_facesets_to_mpoly(
-        const ISampleSelector &sample_sel,
-        size_t poly_start,
-        MPoly *mpoly, int totpoly,
-        std::map<std::string, int> & r_mat_map)
+void AbcMeshReader::assign_facesets_to_mpoly(const ISampleSelector &sample_sel,
+                                             size_t poly_start,
+                                             MPoly *mpoly,
+                                             int totpoly,
+                                             std::map<std::string, int> &r_mat_map)
 {
-	std::vector<std::string> face_sets;
-	m_schema.getFaceSetNames(face_sets);
-
-	if (face_sets.empty()) {
-		return;
-	}
+  std::vector<std::string> face_sets;
+  m_schema.getFaceSetNames(face_sets);
 
-	int current_mat = 0;
+  if (face_sets.empty()) {
+    return;
+  }
 
-	for (int i = 0; i < face_sets.size(); ++i) {
-		const std::string &grp_name = face_sets[i];
+  int current_mat = 0;
 
-		if (r_mat_map.find(grp_name) == r_mat_map.end()) {
-			r_mat_map[grp_name] = 1 + current_mat++;
-		}
+  for (int i = 0; i < face_sets.size(); ++i) {
+    const std::string &grp_name = face_sets[i];
 
-		const int assigned_mat = r_mat_map[grp_name];
+    if (r_mat_map.find(grp_name) == r_mat_map.end()) {
+      r_mat_map[grp_name] = 1 + current_mat++;
+    }
 
-		const IFaceSet faceset = m_schema.getFaceSet(grp_name);
+    const int assigned_mat = r_mat_map[grp_name];
 
-		if (!faceset.valid()) {
-			std::cerr << " Face set " << grp_name << " invalid for " << m_object_name << "\n";
-			continue;
-		}
+    const IFaceSet faceset = m_schema.getFaceSet(grp_name);
 
-		const IFaceSetSchema face_schem = faceset.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();
+    if (!faceset.valid()) {
+      std::cerr << " Face set " << grp_name << " invalid for " << m_object_name << "\n";
+      continue;
+    }
 
-		for (size_t l = 0; l < num_group_faces; l++) {
-			size_t pos = (*group_faces)[l] + poly_start;
+    const IFaceSetSchema face_schem = faceset.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();
 
-			if (pos >= totpoly) {
-				std::cerr << "Faceset overflow on " << faceset.getName() << '\n';
-				break;
-			}
+    for (size_t l = 0; l < num_group_faces; l++) {
+      size_t pos = (*group_faces)[l] + poly_start;
 
-			MPoly &poly = mpoly[pos];
-			poly.mat_nr = assigned_mat - 1;
-		}
-	}
+      if (pos >= totpoly) {
+        std::cerr << "Faceset overflow on " << faceset.getName() << '\n';
+        break;
+      }
 
+      MPoly &poly = mpoly[pos];
+      poly.mat_nr = assigned_mat - 1;
+    }
+  }
 }
 
-void AbcMeshReader::readFaceSetsSample(Main *bmain, Mesh *mesh, size_t poly_start,
+void AbcMeshReader::readFaceSetsSample(Main *bmain,
+                                       Mesh *mesh,
+                                       size_t poly_start,
                                        const ISampleSelector &sample_sel)
 {
-	std::map<std::string, int> mat_map;
-	assign_facesets_to_mpoly(sample_sel,
-	                         poly_start, mesh->mpoly, mesh->totpoly,
-	                         mat_map);
-	utils::assign_materials(bmain, m_object, mat_map);
+  std::map<std::string, int> mat_map;
+  assign_facesets_to_mpoly(sample_sel, poly_start, mesh->mpoly, mesh->totpoly, mat_map);
+  utils::assign_materials(bmain, m_object, mat_map);
 }
 
 /* ************************************************************************** */
 
 ABC_INLINE MEdge *find_edge(MEdge *edges, int totedge, int v1, int v2)
 {
-	for (int i = 0, e = totedge; i < e; ++i) {
-		MEdge &edge = edges[i];
+  for (int i = 0, e = totedge; i < e; ++i) {
+    MEdge &edge = edges[i];
 
-		if (edge.v1 == v1 && edge.v2 == v2) {
-			return &edge;
-		}
-	}
+    if (edge.v1 == v1 && edge.v2 == v2) {
+      return &edge;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
-static void read_subd_sample(const std::string & iobject_full_name,
+static void read_subd_sample(const std::string &iobject_full_name,
                              ImportSettings *settings,
                              const ISubDSchema &schema,
                              const ISampleSelector &selector,
                              CDStreamConfig &config)
 {
-	const ISubDSchema::Sample sample = schema.getValue(selector);
-
-	AbcMeshData abc_mesh_data;
-	abc_mesh_data.face_counts = sample.getFaceCounts();
-	abc_mesh_data.face_indices = sample.getFaceIndices();
-	abc_mesh_data.vertex_normals = N3fArraySamplePtr();
-	abc_mesh_data.face_normals = N3fArraySamplePtr();
-	abc_mesh_data.positions = sample.getPositions();
-
-	get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
-
-	if (config.weight != 0.0f) {
-		Alembic::AbcGeom::ISubDSchema::Sample ceil_sample;
-		schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
-		abc_mesh_data.ceil_positions = ceil_sample.getPositions();
-	}
-
-	if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
-		read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
-	}
-
-	if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
-		read_mverts(config, abc_mesh_data);
-	}
-
-	if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
-		read_mpolys(config, abc_mesh_data);
-	}
-
-	if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
-		read_custom_data(iobject_full_name,
-		                 schema.getArbGeomParams(), config, selector);
-	}
+  const ISubDSchema::Sample sample = schema.getValue(selector);
+
+  AbcMeshData abc_mesh_data;
+  abc_mesh_data.face_counts = sample.getFaceCounts();
+  abc_mesh_data.face_indices = sample.getFaceIndices();
+  abc_mesh_data.vertex_normals = N3fArraySamplePtr();
+  abc_mesh_data.face_normals = N3fArraySamplePtr();
+  abc_mesh_data.positions = sample.getPositions();
+
+  get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
+
+  if (config.weight != 0.0f) {
+    Alembic::AbcGeom::ISubDSchema::Sample ceil_sample;
+    schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
+    abc_mesh_data.ceil_positions = ceil_sample.getPositions();
+  }
+
+  if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
+    read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
+  }
+
+  if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
+    read_mverts(config, abc_mesh_data);
+  }
+
+  if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
+    read_mpolys(config, abc_mesh_data);
+  }
+
+  if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
+    read_custom_data(iobject_full_name, schema.getArbGeomParams(), config, selector);
+  }
 }
 
 /* ************************************************************************** */
@@ -1311,88 +1311,91 @@ static void read_subd_sample(const std::string & iobject_full_name,
 AbcSubDReader::AbcSubDReader(const IObject &object, ImportSettings &settings)
     : AbcObjectReader(object, settings)
 {
-	m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
+  m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
 
-	ISubD isubd_mesh(m_iobject, kWrapExisting);
-	m_schema = isubd_mesh.getSchema();
+  ISubD isubd_mesh(m_iobject, kWrapExisting);
+  m_schema = isubd_mesh.getSchema();
 
-	get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
+  get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
 }
 
 bool AbcSubDReader::valid() const
 {
-	return m_schema.valid();
+  return m_schema.valid();
 }
 
-bool AbcSubDReader::accepts_object_type(const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
-                                        const Object *const ob,
-                                        const char **err_str) const
+bool AbcSubDReader::accepts_object_type(
+    const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
+    const Object *const ob,
+    const char **err_str) const
 {
-	if (!Alembic::AbcGeom::ISubD::matches(alembic_header)) {
-		*err_str = "Object type mismatch, Alembic object path pointed to SubD when importing, but not any more.";
-		return false;
-	}
-
-	if (ob->type != OB_MESH) {
-		*err_str = "Object type mismatch, Alembic object path points to SubD.";
-		return false;
-	}
-
-	return true;
+  if (!Alembic::AbcGeom::ISubD::matches(alembic_header)) {
+    *err_str =
+        "Object type mismatch, Alembic object path pointed to SubD when importing, but not any "
+        "more.";
+    return false;
+  }
+
+  if (ob->type != OB_MESH) {
+    *err_str = "Object type mismatch, Alembic object path points to SubD.";
+    return false;
+  }
+
+  return true;
 }
 
 void AbcSubDReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel)
 {
-	Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
-
-	m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
-	m_object->data = mesh;
-
-	Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
-	if (read_mesh != mesh) {
-		BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
-	}
-
-	ISubDSchema::Sample sample;
-	try {
-		sample = m_schema.getValue(sample_sel);
-	}
-	catch(Alembic::Util::Exception &ex) {
-		printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
-		       m_iobject.getFullName().c_str(),
-		       m_schema.getName().c_str(),
-		       sample_sel.getRequestedTime(),
-		       ex.what());
-		return;
-	}
-
-	Int32ArraySamplePtr indices = sample.getCreaseIndices();
-	Alembic::Abc::FloatArraySamplePtr sharpnesses = sample.getCreaseSharpnesses();
-
-	MEdge *edges = mesh->medge;
-
-	if (indices && sharpnesses) {
-		for (int i = 0, s = 0, e = indices->size(); i < e; i += 2, ++s) {
-			MEdge *edge = find_edge(edges, mesh->totedge, (*indices)[i], (*indices)[i + 1]);
-
-			if (edge) {
-				edge->crease = unit_float_to_uchar_clamp((*sharpnesses)[s]);
-			}
-		}
-
-		mesh->cd_flag |= ME_CDFLAG_EDGE_CREASE;
-	}
-
-	BKE_mesh_calc_normals(mesh);
-	BKE_mesh_calc_edges(mesh, false, false);
-
-	if (m_settings->validate_meshes) {
-		BKE_mesh_validate(mesh, false, false);
-	}
-
-	if (has_animations(m_schema, m_settings)) {
-		addCacheModifier();
-	}
+  Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
+
+  m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
+  m_object->data = mesh;
+
+  Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
+  if (read_mesh != mesh) {
+    BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
+  }
+
+  ISubDSchema::Sample sample;
+  try {
+    sample = m_schema.getValue(sample_sel);
+  }
+  catch (Alembic::Util::Exception &ex) {
+    printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
+           m_iobject.getFullName().c_str(),
+           m_schema.getName().c_str(),
+           sample_sel.getRequestedTime(),
+           ex.what());
+    return;
+  }
+
+  Int32ArraySamplePtr indices = sample.getCreaseIndices();
+  Alembic::Abc::FloatArraySamplePtr sharpnesses = sample.getCreaseSharpnesses();
+
+  MEdge *edges = mesh->medge;
+
+  if (indices && sharpnesses) {
+    for (int i = 0, s = 0, e = indices->size(); i < e; i += 2, ++s) {
+      MEdge *edge = find_edge(edges, mesh->totedge, (*indices)[i], (*indices)[i + 1]);
+
+      if (edge) {
+        edge->crease = unit_float_to_uchar_clamp((*sharpnesses)[s]);
+      }
+    }
+
+    mesh->cd_flag |= ME_CDFLAG_EDGE_CREASE;
+  }
+
+  BKE_mesh_calc_normals(mesh);
+  BKE_mesh_calc_edges(mesh, false, false);
+
+  if (m_settings->validate_meshes) {
+    BKE_mesh_validate(mesh, false, false);
+  }
+
+  if (has_animations(m_schema, m_settings)) {
+    addCacheModifier();
+  }
 }
 
 Mesh *AbcSubDReader::read_mesh(Mesh *existing_mesh,
@@ -1400,72 +1403,67 @@ Mesh *AbcSubDReader::read_mesh(Mesh *existing_mesh,
                                int read_flag,
                                const char **err_str)
 {
-	ISubDSchema::Sample sample;
-	try {
-		sample = m_schema.getValue(sample_sel);
-	}
-	catch(Alembic::Util::Exception &ex) {
-		*err_str = "Error reading mesh sample; more detail on the console";
-		printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
-		       m_iobject.getFullName().c_str(),
-		       m_schema.getName().c_str(),
-		       sample_sel.getRequestedTime(),
-		       ex.what());
-		return existing_mesh;
-	}
-
-	const P3fArraySamplePtr &positions = sample.getPositions();
-	const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
-	const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
-
-	Mesh *new_mesh = NULL;
-
-	ImportSettings settings;
-	settings.read_flag |= read_flag;
-
-	if (existing_mesh->totvert != positions->size()) {
-		new_mesh = BKE_mesh_new_nomain_from_template(existing_mesh,
-		                                           positions->size(),
-		                                           0,
-		                                           0,
-		                                           face_indices->size(),
-		                                           face_counts->size());
-
-		settings.read_flag |= MOD_MESHSEQ_READ_ALL;
-	}
-	else {
-		/* If the face count changed (e.g. by triangulation), only read points.
-		 * This prevents crash from T49813.
-		 * TODO(kevin): perhaps find a better way to do this? */
-		if (face_counts->size() != existing_mesh->totpoly ||
-		    face_indices->size() != existing_mesh->totpoly)
-		{
-			settings.read_flag = MOD_MESHSEQ_READ_VERT;
-
-			if (err_str) {
-				*err_str = "Topology has changed, perhaps by triangulating the"
-				           " mesh. Only vertices will be read!";
-			}
-		}
-	}
-
-	/* Only read point data when streaming meshes, unless we need to create new ones. */
-	CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
-	config.time = sample_sel.getRequestedTime();
-	read_subd_sample(m_iobject.getFullName(),
-	                 &settings, m_schema, sample_sel, config);
-
-	if (new_mesh) {
-		/* Check if we had ME_SMOOTH flag set to restore it. */
-		if (check_smooth_poly_flag(existing_mesh)) {
-			set_smooth_poly_flag(new_mesh);
-		}
-
-		BKE_mesh_calc_normals(new_mesh);
-		BKE_mesh_calc_edges(new_mesh, false, false);
-
-		return new_mesh;
-	}
-
-	return existing_mesh;
+  ISubDSchema::Sample sample;
+  try {
+    sample = m_schema.getValue(sample_sel);
+  }
+  catch (Alembic::Util::Exception &ex) {
+    *err_str = "Error reading mesh sample; more detail on the console";
+    printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
+           m_iobject.getFullName().c_str(),
+           m_schema.getName().c_str(),
+           sample_sel.getRequestedTime(),
+           ex.what());
+    return existing_mesh;
+  }
+
+  const P3fArraySamplePtr &positions = sample.getPositions();
+  const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
+  const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
+
+  Mesh *new_mesh = NULL;
+
+  ImportSettings settings;
+  settings.read_flag |= read_flag;
+
+  if (existing_mesh->totvert != positions->size()) {
+    new_mesh = BKE_mesh_new_nomain_from_template(
+        existing_mesh, positions->size(), 0, 0, face_indices->size(), face_counts->size());
+
+    settings.read_flag |= MOD_MESHSEQ_READ_ALL;
+  }
+  else {
+    /* If the face count changed (e.g. by triangulation), only read points.
+     * This prevents crash from T49813.
+     * TODO(kevin): perhaps find a better way to do this? */
+    if (face_counts->size() != existing_mesh->totpoly ||
+        face_indices->size() != existing_mesh->totpoly) {
+      settings.read_flag = MOD_MESHSEQ_READ_VERT;
+
+      if (err_str) {
+        *err_str =
+            "Topology has changed, perhaps by triangulating the"
+            " mesh. Only vertices will be read!";
+      }
+    }
+  }
+
+  /* Only read point data when streaming meshes, unless we need to create new ones. */
+  CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
+  config.time = sample_sel.getRequestedTime();
+  read_subd_sample(m_iobject.getFullName(), &settings, m_schema, sample_sel, config);
+
+  if (new_mesh) {
+    /* Check if we had ME_SMOOTH flag set to restore it. */
+    if (check_smooth_poly_flag(existing_mesh)) {
+      set_smooth_poly_flag(new_mesh);
+    }
+
+    BKE_mesh_calc_normals(new_mesh);
+    BKE_mesh_calc_edges(new_mesh, false, false);
+
+    return new_mesh;
+  }
+
+  return existing_mesh;
 }