Merge remote-tracking branch 'origin/blender-v2.81-release'
[blender.git] / source / blender / alembic / intern / abc_mesh.cc
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup balembic
19  */
20
21 #include "abc_mesh.h"
22
23 #include <algorithm>
24
25 #include "abc_transform.h"
26 #include "abc_util.h"
27
28 extern "C" {
29 #include "DNA_material_types.h"
30 #include "DNA_mesh_types.h"
31 #include "DNA_meshdata_types.h"
32 #include "DNA_modifier_types.h"
33 #include "DNA_object_fluidsim_types.h"
34 #include "DNA_object_types.h"
35
36 #include "BLI_math_geom.h"
37 #include "BLI_string.h"
38
39 #include "BKE_animsys.h"
40 #include "BKE_key.h"
41 #include "BKE_library.h"
42 #include "BKE_main.h"
43 #include "BKE_material.h"
44 #include "BKE_mesh.h"
45 #include "BKE_mesh_runtime.h"
46 #include "BKE_modifier.h"
47 #include "BKE_object.h"
48
49 #include "MEM_guardedalloc.h"
50
51 #include "WM_api.h"
52 #include "WM_types.h"
53
54 #include "ED_mesh.h"
55
56 #include "bmesh.h"
57 #include "bmesh_tools.h"
58
59 #include "DEG_depsgraph_query.h"
60 }
61
62 using Alembic::Abc::C4fArraySample;
63 using Alembic::Abc::FloatArraySample;
64 using Alembic::Abc::ICompoundProperty;
65 using Alembic::Abc::Int32ArraySample;
66 using Alembic::Abc::Int32ArraySamplePtr;
67 using Alembic::Abc::P3fArraySamplePtr;
68 using Alembic::Abc::V2fArraySample;
69 using Alembic::Abc::V3fArraySample;
70
71 using Alembic::AbcGeom::IFaceSet;
72 using Alembic::AbcGeom::IFaceSetSchema;
73 using Alembic::AbcGeom::IObject;
74 using Alembic::AbcGeom::IPolyMesh;
75 using Alembic::AbcGeom::IPolyMeshSchema;
76 using Alembic::AbcGeom::ISampleSelector;
77 using Alembic::AbcGeom::ISubD;
78 using Alembic::AbcGeom::ISubDSchema;
79 using Alembic::AbcGeom::IV2fGeomParam;
80
81 using Alembic::AbcGeom::OArrayProperty;
82 using Alembic::AbcGeom::OBoolProperty;
83 using Alembic::AbcGeom::OC3fArrayProperty;
84 using Alembic::AbcGeom::OC3fGeomParam;
85 using Alembic::AbcGeom::OC4fGeomParam;
86 using Alembic::AbcGeom::OCompoundProperty;
87 using Alembic::AbcGeom::OFaceSet;
88 using Alembic::AbcGeom::OFaceSetSchema;
89 using Alembic::AbcGeom::OFloatGeomParam;
90 using Alembic::AbcGeom::OInt32GeomParam;
91 using Alembic::AbcGeom::ON3fArrayProperty;
92 using Alembic::AbcGeom::ON3fGeomParam;
93 using Alembic::AbcGeom::OPolyMesh;
94 using Alembic::AbcGeom::OPolyMeshSchema;
95 using Alembic::AbcGeom::OSubD;
96 using Alembic::AbcGeom::OSubDSchema;
97 using Alembic::AbcGeom::OV2fGeomParam;
98 using Alembic::AbcGeom::OV3fGeomParam;
99
100 using Alembic::AbcGeom::IN3fGeomParam;
101 using Alembic::AbcGeom::kFacevaryingScope;
102 using Alembic::AbcGeom::kVaryingScope;
103 using Alembic::AbcGeom::kVertexScope;
104 using Alembic::AbcGeom::kWrapExisting;
105 using Alembic::AbcGeom::N3fArraySample;
106 using Alembic::AbcGeom::N3fArraySamplePtr;
107 using Alembic::AbcGeom::UInt32ArraySample;
108
109 /* ************************************************************************** */
110
111 /* NOTE: Alembic's polygon winding order is clockwise, to match with Renderman. */
112
113 static void get_vertices(struct Mesh *mesh, std::vector<Imath::V3f> &points)
114 {
115   points.clear();
116   points.resize(mesh->totvert);
117
118   MVert *verts = mesh->mvert;
119
120   for (int i = 0, e = mesh->totvert; i < e; i++) {
121     copy_yup_from_zup(points[i].getValue(), verts[i].co);
122   }
123 }
124
125 static void get_topology(struct Mesh *mesh,
126                          std::vector<int32_t> &poly_verts,
127                          std::vector<int32_t> &loop_counts,
128                          bool &r_has_flat_shaded_poly)
129 {
130   const int num_poly = mesh->totpoly;
131   const int num_loops = mesh->totloop;
132   MLoop *mloop = mesh->mloop;
133   MPoly *mpoly = mesh->mpoly;
134   r_has_flat_shaded_poly = false;
135
136   poly_verts.clear();
137   loop_counts.clear();
138   poly_verts.reserve(num_loops);
139   loop_counts.reserve(num_poly);
140
141   /* NOTE: data needs to be written in the reverse order. */
142   for (int i = 0; i < num_poly; i++) {
143     MPoly &poly = mpoly[i];
144     loop_counts.push_back(poly.totloop);
145
146     r_has_flat_shaded_poly |= (poly.flag & ME_SMOOTH) == 0;
147
148     MLoop *loop = mloop + poly.loopstart + (poly.totloop - 1);
149
150     for (int j = 0; j < poly.totloop; j++, loop--) {
151       poly_verts.push_back(loop->v);
152     }
153   }
154 }
155
156 static void get_creases(struct Mesh *mesh,
157                         std::vector<int32_t> &indices,
158                         std::vector<int32_t> &lengths,
159                         std::vector<float> &sharpnesses)
160 {
161   const float factor = 1.0f / 255.0f;
162
163   indices.clear();
164   lengths.clear();
165   sharpnesses.clear();
166
167   MEdge *edge = mesh->medge;
168
169   for (int i = 0, e = mesh->totedge; i < e; i++) {
170     const float sharpness = static_cast<float>(edge[i].crease) * factor;
171
172     if (sharpness != 0.0f) {
173       indices.push_back(edge[i].v1);
174       indices.push_back(edge[i].v2);
175       sharpnesses.push_back(sharpness);
176     }
177   }
178
179   lengths.resize(sharpnesses.size(), 2);
180 }
181
182 static void get_loop_normals(struct Mesh *mesh,
183                              std::vector<Imath::V3f> &normals,
184                              bool has_flat_shaded_poly)
185 {
186   normals.clear();
187
188   /* If all polygons are smooth shaded, and there are no custom normals, we don't need to export
189    * normals at all. This is also done by other software, see T71246. */
190   if (!has_flat_shaded_poly && !CustomData_has_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL)) {
191     return;
192   }
193
194   BKE_mesh_calc_normals_split(mesh);
195   const float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
196   BLI_assert(lnors != NULL || !"BKE_mesh_calc_normals_split() should have computed CD_NORMAL");
197
198   normals.resize(mesh->totloop);
199
200   /* NOTE: data needs to be written in the reverse order. */
201   int abc_index = 0;
202   MPoly *mp = mesh->mpoly;
203   for (int i = 0, e = mesh->totpoly; i < e; i++, mp++) {
204     for (int j = mp->totloop - 1; j >= 0; j--, abc_index++) {
205       int blender_index = mp->loopstart + j;
206       copy_yup_from_zup(normals[abc_index].getValue(), lnors[blender_index]);
207     }
208   }
209 }
210
211 /* *************** Modifiers *************** */
212
213 /* check if the mesh is a subsurf, ignoring disabled modifiers and
214  * displace if it's after subsurf. */
215 static ModifierData *get_subsurf_modifier(Scene *scene, Object *ob)
216 {
217   ModifierData *md = static_cast<ModifierData *>(ob->modifiers.last);
218
219   for (; md; md = md->prev) {
220     if (!modifier_isEnabled(scene, md, eModifierMode_Render)) {
221       continue;
222     }
223
224     if (md->type == eModifierType_Subsurf) {
225       SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
226
227       if (smd->subdivType == ME_CC_SUBSURF) {
228         return md;
229       }
230     }
231
232     /* mesh is not a subsurf. break */
233     if ((md->type != eModifierType_Displace) && (md->type != eModifierType_ParticleSystem)) {
234       return NULL;
235     }
236   }
237
238   return NULL;
239 }
240
241 static ModifierData *get_liquid_sim_modifier(Scene *scene, Object *ob)
242 {
243   ModifierData *md = modifiers_findByType(ob, eModifierType_Fluidsim);
244
245   if (md && (modifier_isEnabled(scene, md, eModifierMode_Render))) {
246     FluidsimModifierData *fsmd = reinterpret_cast<FluidsimModifierData *>(md);
247
248     if (fsmd->fss && fsmd->fss->type == OB_FLUIDSIM_DOMAIN) {
249       return md;
250     }
251   }
252
253   return NULL;
254 }
255
256 /* ************************************************************************** */
257
258 AbcGenericMeshWriter::AbcGenericMeshWriter(Object *ob,
259                                            AbcTransformWriter *parent,
260                                            uint32_t time_sampling,
261                                            ExportSettings &settings)
262     : AbcObjectWriter(ob, time_sampling, settings, parent)
263 {
264   m_is_animated = isAnimated();
265   m_subsurf_mod = NULL;
266   m_is_subd = false;
267
268   /* If the object is static, use the default static time sampling. */
269   if (!m_is_animated) {
270     time_sampling = 0;
271   }
272
273   if (!m_settings.apply_subdiv) {
274     m_subsurf_mod = get_subsurf_modifier(m_settings.scene, m_object);
275     m_is_subd = (m_subsurf_mod != NULL);
276   }
277
278   m_is_liquid = (get_liquid_sim_modifier(m_settings.scene, m_object) != NULL);
279
280   while (parent->alembicXform().getChildHeader(m_name)) {
281     m_name.append("_");
282   }
283
284   if (m_settings.use_subdiv_schema && m_is_subd) {
285     OSubD subd(parent->alembicXform(), m_name, m_time_sampling);
286     m_subdiv_schema = subd.getSchema();
287   }
288   else {
289     OPolyMesh mesh(parent->alembicXform(), m_name, m_time_sampling);
290     m_mesh_schema = mesh.getSchema();
291
292     OCompoundProperty typeContainer = m_mesh_schema.getUserProperties();
293     OBoolProperty type(typeContainer, "meshtype");
294     type.set(m_is_subd);
295   }
296 }
297
298 AbcGenericMeshWriter::~AbcGenericMeshWriter()
299 {
300   if (m_subsurf_mod) {
301     m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
302   }
303 }
304
305 bool AbcGenericMeshWriter::isAnimated() const
306 {
307   if (m_object->data != NULL) {
308     AnimData *adt = BKE_animdata_from_id(static_cast<ID *>(m_object->data));
309     /* TODO(Sybren): make this check more strict, as the AnimationData may
310      * actually be empty (no fcurves, drivers, etc.) and thus effectively
311      * have no animation at all. */
312     if (adt != NULL) {
313       return true;
314     }
315   }
316   if (BKE_key_from_object(m_object) != NULL) {
317     return true;
318   }
319
320   /* Test modifiers. */
321   ModifierData *md = static_cast<ModifierData *>(m_object->modifiers.first);
322   while (md) {
323
324     if (md->type != eModifierType_Subsurf) {
325       return true;
326     }
327
328     md = md->next;
329   }
330
331   return false;
332 }
333
334 void AbcGenericMeshWriter::setIsAnimated(bool is_animated)
335 {
336   m_is_animated = is_animated;
337 }
338
339 void AbcGenericMeshWriter::do_write()
340 {
341   /* We have already stored a sample for this object. */
342   if (!m_first_frame && !m_is_animated) {
343     return;
344   }
345
346   bool needsfree;
347   struct Mesh *mesh = getFinalMesh(needsfree);
348
349   try {
350     if (m_settings.use_subdiv_schema && m_subdiv_schema.valid()) {
351       writeSubD(mesh);
352     }
353     else {
354       writeMesh(mesh);
355     }
356
357     if (needsfree) {
358       freeEvaluatedMesh(mesh);
359     }
360   }
361   catch (...) {
362     if (needsfree) {
363       freeEvaluatedMesh(mesh);
364     }
365     throw;
366   }
367 }
368
369 void AbcGenericMeshWriter::freeEvaluatedMesh(struct Mesh *mesh)
370 {
371   BKE_id_free(NULL, mesh);
372 }
373
374 void AbcGenericMeshWriter::writeMesh(struct Mesh *mesh)
375 {
376   std::vector<Imath::V3f> points, normals;
377   std::vector<int32_t> poly_verts, loop_counts;
378   std::vector<Imath::V3f> velocities;
379   bool has_flat_shaded_poly = false;
380
381   get_vertices(mesh, points);
382   get_topology(mesh, poly_verts, loop_counts, has_flat_shaded_poly);
383
384   if (m_first_frame && m_settings.export_face_sets) {
385     writeFaceSets(mesh, m_mesh_schema);
386   }
387
388   m_mesh_sample = OPolyMeshSchema::Sample(
389       V3fArraySample(points), Int32ArraySample(poly_verts), Int32ArraySample(loop_counts));
390
391   UVSample sample;
392   if (m_first_frame && m_settings.export_uvs) {
393     const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
394
395     if (!sample.indices.empty() && !sample.uvs.empty()) {
396       OV2fGeomParam::Sample uv_sample;
397       uv_sample.setVals(V2fArraySample(sample.uvs));
398       uv_sample.setIndices(UInt32ArraySample(sample.indices));
399       uv_sample.setScope(kFacevaryingScope);
400
401       m_mesh_schema.setUVSourceName(name);
402       m_mesh_sample.setUVs(uv_sample);
403     }
404
405     write_custom_data(
406         m_mesh_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
407   }
408
409   if (m_settings.export_normals) {
410     get_loop_normals(mesh, normals, has_flat_shaded_poly);
411
412     ON3fGeomParam::Sample normals_sample;
413     if (!normals.empty()) {
414       normals_sample.setScope(kFacevaryingScope);
415       normals_sample.setVals(V3fArraySample(normals));
416     }
417
418     m_mesh_sample.setNormals(normals_sample);
419   }
420
421   if (m_is_liquid) {
422     getVelocities(mesh, velocities);
423     m_mesh_sample.setVelocities(V3fArraySample(velocities));
424   }
425
426   m_mesh_sample.setSelfBounds(bounds());
427
428   m_mesh_schema.set(m_mesh_sample);
429
430   writeArbGeoParams(mesh);
431 }
432
433 void AbcGenericMeshWriter::writeSubD(struct Mesh *mesh)
434 {
435   std::vector<float> crease_sharpness;
436   std::vector<Imath::V3f> points;
437   std::vector<int32_t> poly_verts, loop_counts;
438   std::vector<int32_t> crease_indices, crease_lengths;
439   bool has_flat_poly = false;
440
441   get_vertices(mesh, points);
442   get_topology(mesh, poly_verts, loop_counts, has_flat_poly);
443   get_creases(mesh, crease_indices, crease_lengths, crease_sharpness);
444
445   if (m_first_frame && m_settings.export_face_sets) {
446     writeFaceSets(mesh, m_subdiv_schema);
447   }
448
449   m_subdiv_sample = OSubDSchema::Sample(
450       V3fArraySample(points), Int32ArraySample(poly_verts), Int32ArraySample(loop_counts));
451
452   UVSample sample;
453   if (m_first_frame && m_settings.export_uvs) {
454     const char *name = get_uv_sample(sample, m_custom_data_config, &mesh->ldata);
455
456     if (!sample.indices.empty() && !sample.uvs.empty()) {
457       OV2fGeomParam::Sample uv_sample;
458       uv_sample.setVals(V2fArraySample(sample.uvs));
459       uv_sample.setIndices(UInt32ArraySample(sample.indices));
460       uv_sample.setScope(kFacevaryingScope);
461
462       m_subdiv_schema.setUVSourceName(name);
463       m_subdiv_sample.setUVs(uv_sample);
464     }
465
466     write_custom_data(
467         m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &mesh->ldata, CD_MLOOPUV);
468   }
469
470   if (!crease_indices.empty()) {
471     m_subdiv_sample.setCreaseIndices(Int32ArraySample(crease_indices));
472     m_subdiv_sample.setCreaseLengths(Int32ArraySample(crease_lengths));
473     m_subdiv_sample.setCreaseSharpnesses(FloatArraySample(crease_sharpness));
474   }
475
476   m_subdiv_sample.setSelfBounds(bounds());
477   m_subdiv_schema.set(m_subdiv_sample);
478
479   writeArbGeoParams(mesh);
480 }
481
482 template<typename Schema> void AbcGenericMeshWriter::writeFaceSets(struct Mesh *me, Schema &schema)
483 {
484   std::map<std::string, std::vector<int32_t>> geo_groups;
485   getGeoGroups(me, geo_groups);
486
487   std::map<std::string, std::vector<int32_t>>::iterator it;
488   for (it = geo_groups.begin(); it != geo_groups.end(); ++it) {
489     OFaceSet face_set = schema.createFaceSet(it->first);
490     OFaceSetSchema::Sample samp;
491     samp.setFaces(Int32ArraySample(it->second));
492     face_set.getSchema().set(samp);
493   }
494 }
495
496 Mesh *AbcGenericMeshWriter::getFinalMesh(bool &r_needsfree)
497 {
498   /* We don't want subdivided mesh data */
499   if (m_subsurf_mod) {
500     m_subsurf_mod->mode |= eModifierMode_DisableTemporary;
501   }
502
503   r_needsfree = false;
504
505   Scene *scene = DEG_get_evaluated_scene(m_settings.depsgraph);
506   Object *ob_eval = DEG_get_evaluated_object(m_settings.depsgraph, m_object);
507   struct Mesh *mesh = getEvaluatedMesh(scene, ob_eval, r_needsfree);
508
509   if (m_subsurf_mod) {
510     m_subsurf_mod->mode &= ~eModifierMode_DisableTemporary;
511   }
512
513   if (m_settings.triangulate) {
514     const bool tag_only = false;
515     const int quad_method = m_settings.quad_method;
516     const int ngon_method = m_settings.ngon_method;
517
518     struct BMeshCreateParams bmcp = {false};
519     struct BMeshFromMeshParams bmfmp = {true, false, false, 0};
520     BMesh *bm = BKE_mesh_to_bmesh_ex(mesh, &bmcp, &bmfmp);
521
522     BM_mesh_triangulate(bm, quad_method, ngon_method, 4, tag_only, NULL, NULL, NULL);
523
524     Mesh *result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL, mesh);
525     BM_mesh_free(bm);
526
527     if (r_needsfree) {
528       BKE_id_free(NULL, mesh);
529     }
530
531     mesh = result;
532     r_needsfree = true;
533   }
534
535   m_custom_data_config.pack_uvs = m_settings.pack_uv;
536   m_custom_data_config.mpoly = mesh->mpoly;
537   m_custom_data_config.mloop = mesh->mloop;
538   m_custom_data_config.totpoly = mesh->totpoly;
539   m_custom_data_config.totloop = mesh->totloop;
540   m_custom_data_config.totvert = mesh->totvert;
541
542   return mesh;
543 }
544
545 void AbcGenericMeshWriter::writeArbGeoParams(struct Mesh *me)
546 {
547   if (m_is_liquid) {
548     /* We don't need anything more for liquid meshes. */
549     return;
550   }
551
552   if (m_first_frame && m_settings.export_vcols) {
553     if (m_subdiv_schema.valid()) {
554       write_custom_data(
555           m_subdiv_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
556     }
557     else {
558       write_custom_data(
559           m_mesh_schema.getArbGeomParams(), m_custom_data_config, &me->ldata, CD_MLOOPCOL);
560     }
561   }
562 }
563
564 void AbcGenericMeshWriter::getVelocities(struct Mesh *mesh, std::vector<Imath::V3f> &vels)
565 {
566   const int totverts = mesh->totvert;
567
568   vels.clear();
569   vels.resize(totverts);
570
571   ModifierData *md = get_liquid_sim_modifier(m_settings.scene, m_object);
572   FluidsimModifierData *fmd = reinterpret_cast<FluidsimModifierData *>(md);
573   FluidsimSettings *fss = fmd->fss;
574
575   if (fss->meshVelocities) {
576     float *mesh_vels = reinterpret_cast<float *>(fss->meshVelocities);
577
578     for (int i = 0; i < totverts; i++) {
579       copy_yup_from_zup(vels[i].getValue(), mesh_vels);
580       mesh_vels += 3;
581     }
582   }
583   else {
584     std::fill(vels.begin(), vels.end(), Imath::V3f(0.0f));
585   }
586 }
587
588 void AbcGenericMeshWriter::getGeoGroups(struct Mesh *mesh,
589                                         std::map<std::string, std::vector<int32_t>> &geo_groups)
590 {
591   const int num_poly = mesh->totpoly;
592   MPoly *polygons = mesh->mpoly;
593
594   for (int i = 0; i < num_poly; i++) {
595     MPoly &current_poly = polygons[i];
596     short mnr = current_poly.mat_nr;
597
598     Material *mat = give_current_material(m_object, mnr + 1);
599
600     if (!mat) {
601       continue;
602     }
603
604     std::string name = get_id_name(&mat->id);
605
606     if (geo_groups.find(name) == geo_groups.end()) {
607       std::vector<int32_t> faceArray;
608       geo_groups[name] = faceArray;
609     }
610
611     geo_groups[name].push_back(i);
612   }
613
614   if (geo_groups.size() == 0) {
615     Material *mat = give_current_material(m_object, 1);
616
617     std::string name = (mat) ? get_id_name(&mat->id) : "default";
618
619     std::vector<int32_t> faceArray;
620
621     for (int i = 0, e = mesh->totface; i < e; i++) {
622       faceArray.push_back(i);
623     }
624
625     geo_groups[name] = faceArray;
626   }
627 }
628
629 AbcMeshWriter::AbcMeshWriter(Object *ob,
630                              AbcTransformWriter *parent,
631                              uint32_t time_sampling,
632                              ExportSettings &settings)
633     : AbcGenericMeshWriter(ob, parent, time_sampling, settings)
634 {
635 }
636
637 AbcMeshWriter::~AbcMeshWriter()
638 {
639 }
640
641 Mesh *AbcMeshWriter::getEvaluatedMesh(Scene *scene_eval,
642                                       Object *ob_eval,
643                                       bool &UNUSED(r_needsfree))
644 {
645   return mesh_get_eval_final(m_settings.depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
646 }
647
648 /* ************************************************************************** */
649
650 /* Some helpers for mesh generation */
651 namespace utils {
652
653 static void build_mat_map(const Main *bmain, std::map<std::string, Material *> &mat_map)
654 {
655   Material *material = static_cast<Material *>(bmain->materials.first);
656
657   for (; material; material = static_cast<Material *>(material->id.next)) {
658     mat_map[material->id.name + 2] = material;
659   }
660 }
661
662 static void assign_materials(Main *bmain,
663                              Object *ob,
664                              const std::map<std::string, int> &mat_index_map)
665 {
666   bool can_assign = true;
667   std::map<std::string, int>::const_iterator it = mat_index_map.begin();
668
669   int matcount = 0;
670   for (; it != mat_index_map.end(); ++it, matcount++) {
671     if (!BKE_object_material_slot_add(bmain, ob)) {
672       can_assign = false;
673       break;
674     }
675   }
676
677   /* TODO(kevin): use global map? */
678   std::map<std::string, Material *> mat_map;
679   build_mat_map(bmain, mat_map);
680
681   std::map<std::string, Material *>::iterator mat_iter;
682
683   if (can_assign) {
684     it = mat_index_map.begin();
685
686     for (; it != mat_index_map.end(); ++it) {
687       std::string mat_name = it->first;
688       mat_iter = mat_map.find(mat_name.c_str());
689
690       Material *assigned_mat;
691
692       if (mat_iter == mat_map.end()) {
693         assigned_mat = BKE_material_add(bmain, mat_name.c_str());
694         mat_map[mat_name] = assigned_mat;
695       }
696       else {
697         assigned_mat = mat_iter->second;
698       }
699
700       assign_material(bmain, ob, assigned_mat, it->second, BKE_MAT_ASSIGN_OBDATA);
701     }
702   }
703 }
704
705 } /* namespace utils */
706
707 /* ************************************************************************** */
708
709 using Alembic::AbcGeom::UInt32ArraySamplePtr;
710 using Alembic::AbcGeom::V2fArraySamplePtr;
711
712 struct AbcMeshData {
713   Int32ArraySamplePtr face_indices;
714   Int32ArraySamplePtr face_counts;
715
716   P3fArraySamplePtr positions;
717   P3fArraySamplePtr ceil_positions;
718
719   V2fArraySamplePtr uvs;
720   UInt32ArraySamplePtr uvs_indices;
721 };
722
723 static void read_mverts_interp(MVert *mverts,
724                                const P3fArraySamplePtr &positions,
725                                const P3fArraySamplePtr &ceil_positions,
726                                const float weight)
727 {
728   float tmp[3];
729   for (int i = 0; i < positions->size(); i++) {
730     MVert &mvert = mverts[i];
731     const Imath::V3f &floor_pos = (*positions)[i];
732     const Imath::V3f &ceil_pos = (*ceil_positions)[i];
733
734     interp_v3_v3v3(tmp, floor_pos.getValue(), ceil_pos.getValue(), weight);
735     copy_zup_from_yup(mvert.co, tmp);
736
737     mvert.bweight = 0;
738   }
739 }
740
741 static void read_mverts(CDStreamConfig &config, const AbcMeshData &mesh_data)
742 {
743   MVert *mverts = config.mvert;
744   const P3fArraySamplePtr &positions = mesh_data.positions;
745
746   if (config.weight != 0.0f && mesh_data.ceil_positions != NULL &&
747       mesh_data.ceil_positions->size() == positions->size()) {
748     read_mverts_interp(mverts, positions, mesh_data.ceil_positions, config.weight);
749     return;
750   }
751
752   read_mverts(mverts, positions, nullptr);
753 }
754
755 void read_mverts(MVert *mverts, const P3fArraySamplePtr positions, const N3fArraySamplePtr normals)
756 {
757   for (int i = 0; i < positions->size(); i++) {
758     MVert &mvert = mverts[i];
759     Imath::V3f pos_in = (*positions)[i];
760
761     copy_zup_from_yup(mvert.co, pos_in.getValue());
762
763     mvert.bweight = 0;
764
765     if (normals) {
766       Imath::V3f nor_in = (*normals)[i];
767
768       short no[3];
769       normal_float_to_short_v3(no, nor_in.getValue());
770
771       copy_zup_from_yup(mvert.no, no);
772     }
773   }
774 }
775
776 static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
777 {
778   MPoly *mpolys = config.mpoly;
779   MLoop *mloops = config.mloop;
780   MLoopUV *mloopuvs = config.mloopuv;
781
782   const Int32ArraySamplePtr &face_indices = mesh_data.face_indices;
783   const Int32ArraySamplePtr &face_counts = mesh_data.face_counts;
784   const V2fArraySamplePtr &uvs = mesh_data.uvs;
785   const size_t uvs_size = uvs == nullptr ? 0 : uvs->size();
786
787   const UInt32ArraySamplePtr &uvs_indices = mesh_data.uvs_indices;
788
789   const bool do_uvs = (mloopuvs && uvs && uvs_indices) &&
790                       (uvs_indices->size() == face_indices->size());
791   unsigned int loop_index = 0;
792   unsigned int rev_loop_index = 0;
793   unsigned int uv_index = 0;
794
795   for (int i = 0; i < face_counts->size(); i++) {
796     const int face_size = (*face_counts)[i];
797
798     MPoly &poly = mpolys[i];
799     poly.loopstart = loop_index;
800     poly.totloop = face_size;
801
802     /* Polygons are always assumed to be smooth-shaded. If the Alembic mesh should be flat-shaded,
803      * this is encoded in custom loop normals. See T71246. */
804     poly.flag |= ME_SMOOTH;
805
806     /* NOTE: Alembic data is stored in the reverse order. */
807     rev_loop_index = loop_index + (face_size - 1);
808
809     for (int f = 0; f < face_size; f++, loop_index++, rev_loop_index--) {
810       MLoop &loop = mloops[rev_loop_index];
811       loop.v = (*face_indices)[loop_index];
812
813       if (do_uvs) {
814         MLoopUV &loopuv = mloopuvs[rev_loop_index];
815
816         uv_index = (*uvs_indices)[loop_index];
817
818         /* Some Alembic files are broken (or at least export UVs in a way we don't expect). */
819         if (uv_index >= uvs_size) {
820           continue;
821         }
822
823         loopuv.uv[0] = (*uvs)[uv_index][0];
824         loopuv.uv[1] = (*uvs)[uv_index][1];
825       }
826     }
827   }
828
829   BKE_mesh_calc_edges(config.mesh, false, false);
830 }
831
832 static void process_no_normals(CDStreamConfig &config)
833 {
834   /* Absense of normals in the Alembic mesh is interpreted as 'smooth'. */
835   BKE_mesh_calc_normals(config.mesh);
836 }
837
838 static void process_loop_normals(CDStreamConfig &config, const N3fArraySamplePtr loop_normals_ptr)
839 {
840   size_t loop_count = loop_normals_ptr->size();
841
842   if (loop_count == 0) {
843     process_no_normals(config);
844     return;
845   }
846
847   float(*lnors)[3] = static_cast<float(*)[3]>(
848       MEM_malloc_arrayN(loop_count, sizeof(float[3]), "ABC::FaceNormals"));
849
850   Mesh *mesh = config.mesh;
851   MPoly *mpoly = mesh->mpoly;
852   const N3fArraySample &loop_normals = *loop_normals_ptr;
853   int abc_index = 0;
854   for (int i = 0, e = mesh->totpoly; i < e; i++, mpoly++) {
855     /* As usual, ABC orders the loops in reverse. */
856     for (int j = mpoly->totloop - 1; j >= 0; j--, abc_index++) {
857       int blender_index = mpoly->loopstart + j;
858       copy_zup_from_yup(lnors[blender_index], loop_normals[abc_index].getValue());
859     }
860   }
861
862   mesh->flag |= ME_AUTOSMOOTH;
863   BKE_mesh_set_custom_normals(mesh, lnors);
864
865   MEM_freeN(lnors);
866 }
867
868 static void process_vertex_normals(CDStreamConfig &config,
869                                    const N3fArraySamplePtr vertex_normals_ptr)
870 {
871   size_t normals_count = vertex_normals_ptr->size();
872   if (normals_count == 0) {
873     process_no_normals(config);
874     return;
875   }
876
877   float(*vnors)[3] = static_cast<float(*)[3]>(
878       MEM_malloc_arrayN(normals_count, sizeof(float[3]), "ABC::VertexNormals"));
879
880   const N3fArraySample &vertex_normals = *vertex_normals_ptr;
881   for (int index = 0; index < normals_count; index++) {
882     copy_zup_from_yup(vnors[index], vertex_normals[index].getValue());
883   }
884
885   config.mesh->flag |= ME_AUTOSMOOTH;
886   BKE_mesh_set_custom_normals_from_vertices(config.mesh, vnors);
887   MEM_freeN(vnors);
888 }
889
890 static void process_normals(CDStreamConfig &config,
891                             const IN3fGeomParam &normals,
892                             const ISampleSelector &selector)
893 {
894   if (!normals.valid()) {
895     process_no_normals(config);
896     return;
897   }
898
899   IN3fGeomParam::Sample normsamp = normals.getExpandedValue(selector);
900   Alembic::AbcGeom::GeometryScope scope = normals.getScope();
901
902   switch (scope) {
903     case Alembic::AbcGeom::kFacevaryingScope:  // 'Vertex Normals' in Houdini.
904       process_loop_normals(config, normsamp.getVals());
905       break;
906     case Alembic::AbcGeom::kVertexScope:
907     case Alembic::AbcGeom::kVaryingScope:  // 'Point Normals' in Houdini.
908       process_vertex_normals(config, normsamp.getVals());
909       break;
910     case Alembic::AbcGeom::kConstantScope:
911     case Alembic::AbcGeom::kUniformScope:
912     case Alembic::AbcGeom::kUnknownScope:
913       process_no_normals(config);
914       break;
915   }
916 }
917
918 ABC_INLINE void read_uvs_params(CDStreamConfig &config,
919                                 AbcMeshData &abc_data,
920                                 const IV2fGeomParam &uv,
921                                 const ISampleSelector &selector)
922 {
923   if (!uv.valid()) {
924     return;
925   }
926
927   IV2fGeomParam::Sample uvsamp;
928   uv.getIndexed(uvsamp, selector);
929
930   abc_data.uvs = uvsamp.getVals();
931   abc_data.uvs_indices = uvsamp.getIndices();
932
933   if (abc_data.uvs_indices->size() == config.totloop) {
934     std::string name = Alembic::Abc::GetSourceName(uv.getMetaData());
935
936     /* According to the convention, primary UVs should have had their name
937      * set using Alembic::Abc::SetSourceName, but you can't expect everyone
938      * to follow it! :) */
939     if (name.empty()) {
940       name = uv.getName();
941     }
942
943     void *cd_ptr = config.add_customdata_cb(config.mesh, name.c_str(), CD_MLOOPUV);
944     config.mloopuv = static_cast<MLoopUV *>(cd_ptr);
945   }
946 }
947
948 static void *add_customdata_cb(Mesh *mesh, const char *name, int data_type)
949 {
950   CustomDataType cd_data_type = static_cast<CustomDataType>(data_type);
951   void *cd_ptr;
952   CustomData *loopdata;
953   int numloops;
954
955   /* unsupported custom data type -- don't do anything. */
956   if (!ELEM(cd_data_type, CD_MLOOPUV, CD_MLOOPCOL)) {
957     return NULL;
958   }
959
960   loopdata = &mesh->ldata;
961   cd_ptr = CustomData_get_layer_named(loopdata, cd_data_type, name);
962   if (cd_ptr != NULL) {
963     /* layer already exists, so just return it. */
964     return cd_ptr;
965   }
966
967   /* Create a new layer. */
968   numloops = mesh->totloop;
969   cd_ptr = CustomData_add_layer_named(loopdata, cd_data_type, CD_DEFAULT, NULL, numloops, name);
970   return cd_ptr;
971 }
972
973 static void get_weight_and_index(CDStreamConfig &config,
974                                  Alembic::AbcCoreAbstract::TimeSamplingPtr time_sampling,
975                                  size_t samples_number)
976 {
977   Alembic::AbcGeom::index_t i0, i1;
978
979   config.weight = get_weight_and_index(config.time, time_sampling, samples_number, i0, i1);
980
981   config.index = i0;
982   config.ceil_index = i1;
983 }
984
985 static void read_mesh_sample(const std::string &iobject_full_name,
986                              ImportSettings *settings,
987                              const IPolyMeshSchema &schema,
988                              const ISampleSelector &selector,
989                              CDStreamConfig &config)
990 {
991   const IPolyMeshSchema::Sample sample = schema.getValue(selector);
992
993   AbcMeshData abc_mesh_data;
994   abc_mesh_data.face_counts = sample.getFaceCounts();
995   abc_mesh_data.face_indices = sample.getFaceIndices();
996   abc_mesh_data.positions = sample.getPositions();
997
998   get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
999
1000   if (config.weight != 0.0f) {
1001     Alembic::AbcGeom::IPolyMeshSchema::Sample ceil_sample;
1002     schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
1003     abc_mesh_data.ceil_positions = ceil_sample.getPositions();
1004   }
1005
1006   if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
1007     read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
1008   }
1009
1010   if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
1011     read_mverts(config, abc_mesh_data);
1012   }
1013
1014   if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
1015     read_mpolys(config, abc_mesh_data);
1016     process_normals(config, schema.getNormalsParam(), selector);
1017   }
1018
1019   if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
1020     read_custom_data(iobject_full_name, schema.getArbGeomParams(), config, selector);
1021   }
1022 }
1023
1024 CDStreamConfig get_config(Mesh *mesh)
1025 {
1026   CDStreamConfig config;
1027
1028   BLI_assert(mesh->mvert || mesh->totvert == 0);
1029
1030   config.mesh = mesh;
1031   config.mvert = mesh->mvert;
1032   config.mloop = mesh->mloop;
1033   config.mpoly = mesh->mpoly;
1034   config.totloop = mesh->totloop;
1035   config.totpoly = mesh->totpoly;
1036   config.loopdata = &mesh->ldata;
1037   config.add_customdata_cb = add_customdata_cb;
1038
1039   return config;
1040 }
1041
1042 /* ************************************************************************** */
1043
1044 AbcMeshReader::AbcMeshReader(const IObject &object, ImportSettings &settings)
1045     : AbcObjectReader(object, settings)
1046 {
1047   m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
1048
1049   IPolyMesh ipoly_mesh(m_iobject, kWrapExisting);
1050   m_schema = ipoly_mesh.getSchema();
1051
1052   get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
1053 }
1054
1055 bool AbcMeshReader::valid() const
1056 {
1057   return m_schema.valid();
1058 }
1059
1060 void AbcMeshReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel)
1061 {
1062   Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
1063
1064   m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
1065   m_object->data = mesh;
1066
1067   Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
1068   if (read_mesh != mesh) {
1069     /* XXX fixme after 2.80; mesh->flag isn't copied by BKE_mesh_nomain_to_mesh() */
1070     /* read_mesh can be freed by BKE_mesh_nomain_to_mesh(), so get the flag before that happens. */
1071     short autosmooth = (read_mesh->flag & ME_AUTOSMOOTH);
1072     BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
1073     mesh->flag |= autosmooth;
1074   }
1075
1076   if (m_settings->validate_meshes) {
1077     BKE_mesh_validate(mesh, false, false);
1078   }
1079
1080   readFaceSetsSample(bmain, mesh, sample_sel);
1081
1082   if (has_animations(m_schema, m_settings)) {
1083     addCacheModifier();
1084   }
1085 }
1086
1087 bool AbcMeshReader::accepts_object_type(
1088     const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
1089     const Object *const ob,
1090     const char **err_str) const
1091 {
1092   if (!Alembic::AbcGeom::IPolyMesh::matches(alembic_header)) {
1093     *err_str =
1094         "Object type mismatch, Alembic object path pointed to PolyMesh when importing, but not "
1095         "any more.";
1096     return false;
1097   }
1098
1099   if (ob->type != OB_MESH) {
1100     *err_str = "Object type mismatch, Alembic object path points to PolyMesh.";
1101     return false;
1102   }
1103
1104   return true;
1105 }
1106
1107 bool AbcMeshReader::topology_changed(Mesh *existing_mesh, const ISampleSelector &sample_sel)
1108 {
1109   IPolyMeshSchema::Sample sample;
1110   try {
1111     sample = m_schema.getValue(sample_sel);
1112   }
1113   catch (Alembic::Util::Exception &ex) {
1114     printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
1115            m_iobject.getFullName().c_str(),
1116            m_schema.getName().c_str(),
1117            sample_sel.getRequestedTime(),
1118            ex.what());
1119     // A similar error in read_mesh() would just return existing_mesh.
1120     return false;
1121   }
1122
1123   const P3fArraySamplePtr &positions = sample.getPositions();
1124   const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
1125   const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
1126
1127   return positions->size() != existing_mesh->totvert ||
1128          face_counts->size() != existing_mesh->totpoly ||
1129          face_indices->size() != existing_mesh->totloop;
1130 }
1131
1132 Mesh *AbcMeshReader::read_mesh(Mesh *existing_mesh,
1133                                const ISampleSelector &sample_sel,
1134                                int read_flag,
1135                                const char **err_str)
1136 {
1137   IPolyMeshSchema::Sample sample;
1138   try {
1139     sample = m_schema.getValue(sample_sel);
1140   }
1141   catch (Alembic::Util::Exception &ex) {
1142     if (err_str != nullptr) {
1143       *err_str = "Error reading mesh sample; more detail on the console";
1144     }
1145     printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
1146            m_iobject.getFullName().c_str(),
1147            m_schema.getName().c_str(),
1148            sample_sel.getRequestedTime(),
1149            ex.what());
1150     return existing_mesh;
1151   }
1152
1153   const P3fArraySamplePtr &positions = sample.getPositions();
1154   const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
1155   const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
1156
1157   Mesh *new_mesh = NULL;
1158
1159   /* Only read point data when streaming meshes, unless we need to create new ones. */
1160   ImportSettings settings;
1161   settings.read_flag |= read_flag;
1162
1163   if (topology_changed(existing_mesh, sample_sel)) {
1164     new_mesh = BKE_mesh_new_nomain_from_template(
1165         existing_mesh, positions->size(), 0, 0, face_indices->size(), face_counts->size());
1166
1167     settings.read_flag |= MOD_MESHSEQ_READ_ALL;
1168   }
1169   else {
1170     /* If the face count changed (e.g. by triangulation), only read points.
1171      * This prevents crash from T49813.
1172      * TODO(kevin): perhaps find a better way to do this? */
1173     if (face_counts->size() != existing_mesh->totpoly ||
1174         face_indices->size() != existing_mesh->totloop) {
1175       settings.read_flag = MOD_MESHSEQ_READ_VERT;
1176
1177       if (err_str) {
1178         *err_str =
1179             "Topology has changed, perhaps by triangulating the"
1180             " mesh. Only vertices will be read!";
1181       }
1182     }
1183   }
1184
1185   CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
1186   config.time = sample_sel.getRequestedTime();
1187
1188   read_mesh_sample(m_iobject.getFullName(), &settings, m_schema, sample_sel, config);
1189
1190   if (new_mesh) {
1191     /* Here we assume that the number of materials doesn't change, i.e. that
1192      * the material slots that were created when the object was loaded from
1193      * Alembic are still valid now. */
1194     size_t num_polys = new_mesh->totpoly;
1195     if (num_polys > 0) {
1196       std::map<std::string, int> mat_map;
1197       assign_facesets_to_mpoly(sample_sel, new_mesh->mpoly, num_polys, mat_map);
1198     }
1199
1200     return new_mesh;
1201   }
1202
1203   return existing_mesh;
1204 }
1205
1206 void AbcMeshReader::assign_facesets_to_mpoly(const ISampleSelector &sample_sel,
1207                                              MPoly *mpoly,
1208                                              int totpoly,
1209                                              std::map<std::string, int> &r_mat_map)
1210 {
1211   std::vector<std::string> face_sets;
1212   m_schema.getFaceSetNames(face_sets);
1213
1214   if (face_sets.empty()) {
1215     return;
1216   }
1217
1218   int current_mat = 0;
1219
1220   for (int i = 0; i < face_sets.size(); i++) {
1221     const std::string &grp_name = face_sets[i];
1222
1223     if (r_mat_map.find(grp_name) == r_mat_map.end()) {
1224       r_mat_map[grp_name] = 1 + current_mat++;
1225     }
1226
1227     const int assigned_mat = r_mat_map[grp_name];
1228
1229     const IFaceSet faceset = m_schema.getFaceSet(grp_name);
1230
1231     if (!faceset.valid()) {
1232       std::cerr << " Face set " << grp_name << " invalid for " << m_object_name << "\n";
1233       continue;
1234     }
1235
1236     const IFaceSetSchema face_schem = faceset.getSchema();
1237     const IFaceSetSchema::Sample face_sample = face_schem.getValue(sample_sel);
1238     const Int32ArraySamplePtr group_faces = face_sample.getFaces();
1239     const size_t num_group_faces = group_faces->size();
1240
1241     for (size_t l = 0; l < num_group_faces; l++) {
1242       size_t pos = (*group_faces)[l];
1243
1244       if (pos >= totpoly) {
1245         std::cerr << "Faceset overflow on " << faceset.getName() << '\n';
1246         break;
1247       }
1248
1249       MPoly &poly = mpoly[pos];
1250       poly.mat_nr = assigned_mat - 1;
1251     }
1252   }
1253 }
1254
1255 void AbcMeshReader::readFaceSetsSample(Main *bmain, Mesh *mesh, const ISampleSelector &sample_sel)
1256 {
1257   std::map<std::string, int> mat_map;
1258   assign_facesets_to_mpoly(sample_sel, mesh->mpoly, mesh->totpoly, mat_map);
1259   utils::assign_materials(bmain, m_object, mat_map);
1260 }
1261
1262 /* ************************************************************************** */
1263
1264 ABC_INLINE MEdge *find_edge(MEdge *edges, int totedge, int v1, int v2)
1265 {
1266   for (int i = 0, e = totedge; i < e; i++) {
1267     MEdge &edge = edges[i];
1268
1269     if (edge.v1 == v1 && edge.v2 == v2) {
1270       return &edge;
1271     }
1272   }
1273
1274   return NULL;
1275 }
1276
1277 static void read_subd_sample(const std::string &iobject_full_name,
1278                              ImportSettings *settings,
1279                              const ISubDSchema &schema,
1280                              const ISampleSelector &selector,
1281                              CDStreamConfig &config)
1282 {
1283   const ISubDSchema::Sample sample = schema.getValue(selector);
1284
1285   AbcMeshData abc_mesh_data;
1286   abc_mesh_data.face_counts = sample.getFaceCounts();
1287   abc_mesh_data.face_indices = sample.getFaceIndices();
1288   abc_mesh_data.positions = sample.getPositions();
1289
1290   get_weight_and_index(config, schema.getTimeSampling(), schema.getNumSamples());
1291
1292   if (config.weight != 0.0f) {
1293     Alembic::AbcGeom::ISubDSchema::Sample ceil_sample;
1294     schema.get(ceil_sample, Alembic::Abc::ISampleSelector(config.ceil_index));
1295     abc_mesh_data.ceil_positions = ceil_sample.getPositions();
1296   }
1297
1298   if ((settings->read_flag & MOD_MESHSEQ_READ_UV) != 0) {
1299     read_uvs_params(config, abc_mesh_data, schema.getUVsParam(), selector);
1300   }
1301
1302   if ((settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) {
1303     read_mverts(config, abc_mesh_data);
1304   }
1305
1306   if ((settings->read_flag & MOD_MESHSEQ_READ_POLY) != 0) {
1307     /* Alembic's 'SubD' scheme is used to store subdivision surfaces, i.e. the pre-subdivision
1308      * mesh. Currently we don't add a subdivision modifier when we load such data. This code is
1309      * assuming that the subdivided surface should be smooth. */
1310     read_mpolys(config, abc_mesh_data);
1311     process_no_normals(config);
1312   }
1313
1314   if ((settings->read_flag & (MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)) != 0) {
1315     read_custom_data(iobject_full_name, schema.getArbGeomParams(), config, selector);
1316   }
1317 }
1318
1319 /* ************************************************************************** */
1320
1321 AbcSubDReader::AbcSubDReader(const IObject &object, ImportSettings &settings)
1322     : AbcObjectReader(object, settings)
1323 {
1324   m_settings->read_flag |= MOD_MESHSEQ_READ_ALL;
1325
1326   ISubD isubd_mesh(m_iobject, kWrapExisting);
1327   m_schema = isubd_mesh.getSchema();
1328
1329   get_min_max_time(m_iobject, m_schema, m_min_time, m_max_time);
1330 }
1331
1332 bool AbcSubDReader::valid() const
1333 {
1334   return m_schema.valid();
1335 }
1336
1337 bool AbcSubDReader::accepts_object_type(
1338     const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header,
1339     const Object *const ob,
1340     const char **err_str) const
1341 {
1342   if (!Alembic::AbcGeom::ISubD::matches(alembic_header)) {
1343     *err_str =
1344         "Object type mismatch, Alembic object path pointed to SubD when importing, but not any "
1345         "more.";
1346     return false;
1347   }
1348
1349   if (ob->type != OB_MESH) {
1350     *err_str = "Object type mismatch, Alembic object path points to SubD.";
1351     return false;
1352   }
1353
1354   return true;
1355 }
1356
1357 void AbcSubDReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel)
1358 {
1359   Mesh *mesh = BKE_mesh_add(bmain, m_data_name.c_str());
1360
1361   m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
1362   m_object->data = mesh;
1363
1364   Mesh *read_mesh = this->read_mesh(mesh, sample_sel, MOD_MESHSEQ_READ_ALL, NULL);
1365   if (read_mesh != mesh) {
1366     BKE_mesh_nomain_to_mesh(read_mesh, mesh, m_object, &CD_MASK_MESH, true);
1367   }
1368
1369   ISubDSchema::Sample sample;
1370   try {
1371     sample = m_schema.getValue(sample_sel);
1372   }
1373   catch (Alembic::Util::Exception &ex) {
1374     printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
1375            m_iobject.getFullName().c_str(),
1376            m_schema.getName().c_str(),
1377            sample_sel.getRequestedTime(),
1378            ex.what());
1379     return;
1380   }
1381
1382   Int32ArraySamplePtr indices = sample.getCreaseIndices();
1383   Alembic::Abc::FloatArraySamplePtr sharpnesses = sample.getCreaseSharpnesses();
1384
1385   if (indices && sharpnesses) {
1386     MEdge *edges = mesh->medge;
1387     int totedge = mesh->totedge;
1388
1389     for (int i = 0, s = 0, e = indices->size(); i < e; i += 2, s++) {
1390       int v1 = (*indices)[i];
1391       int v2 = (*indices)[i + 1];
1392
1393       if (v2 < v1) {
1394         /* It appears to be common to store edges with the smallest index first, in which case this
1395          * prevents us from doing the second search below. */
1396         std::swap(v1, v2);
1397       }
1398
1399       MEdge *edge = find_edge(edges, totedge, v1, v2);
1400       if (edge == NULL) {
1401         edge = find_edge(edges, totedge, v2, v1);
1402       }
1403
1404       if (edge) {
1405         edge->crease = unit_float_to_uchar_clamp((*sharpnesses)[s]);
1406       }
1407     }
1408
1409     mesh->cd_flag |= ME_CDFLAG_EDGE_CREASE;
1410   }
1411
1412   if (m_settings->validate_meshes) {
1413     BKE_mesh_validate(mesh, false, false);
1414   }
1415
1416   if (has_animations(m_schema, m_settings)) {
1417     addCacheModifier();
1418   }
1419 }
1420
1421 Mesh *AbcSubDReader::read_mesh(Mesh *existing_mesh,
1422                                const ISampleSelector &sample_sel,
1423                                int read_flag,
1424                                const char **err_str)
1425 {
1426   ISubDSchema::Sample sample;
1427   try {
1428     sample = m_schema.getValue(sample_sel);
1429   }
1430   catch (Alembic::Util::Exception &ex) {
1431     if (err_str != nullptr) {
1432       *err_str = "Error reading mesh sample; more detail on the console";
1433     }
1434     printf("Alembic: error reading mesh sample for '%s/%s' at time %f: %s\n",
1435            m_iobject.getFullName().c_str(),
1436            m_schema.getName().c_str(),
1437            sample_sel.getRequestedTime(),
1438            ex.what());
1439     return existing_mesh;
1440   }
1441
1442   const P3fArraySamplePtr &positions = sample.getPositions();
1443   const Alembic::Abc::Int32ArraySamplePtr &face_indices = sample.getFaceIndices();
1444   const Alembic::Abc::Int32ArraySamplePtr &face_counts = sample.getFaceCounts();
1445
1446   Mesh *new_mesh = NULL;
1447
1448   ImportSettings settings;
1449   settings.read_flag |= read_flag;
1450
1451   if (existing_mesh->totvert != positions->size()) {
1452     new_mesh = BKE_mesh_new_nomain_from_template(
1453         existing_mesh, positions->size(), 0, 0, face_indices->size(), face_counts->size());
1454
1455     settings.read_flag |= MOD_MESHSEQ_READ_ALL;
1456   }
1457   else {
1458     /* If the face count changed (e.g. by triangulation), only read points.
1459      * This prevents crash from T49813.
1460      * TODO(kevin): perhaps find a better way to do this? */
1461     if (face_counts->size() != existing_mesh->totpoly ||
1462         face_indices->size() != existing_mesh->totloop) {
1463       settings.read_flag = MOD_MESHSEQ_READ_VERT;
1464
1465       if (err_str) {
1466         *err_str =
1467             "Topology has changed, perhaps by triangulating the"
1468             " mesh. Only vertices will be read!";
1469       }
1470     }
1471   }
1472
1473   /* Only read point data when streaming meshes, unless we need to create new ones. */
1474   CDStreamConfig config = get_config(new_mesh ? new_mesh : existing_mesh);
1475   config.time = sample_sel.getRequestedTime();
1476   read_subd_sample(m_iobject.getFullName(), &settings, m_schema, sample_sel, config);
1477
1478   return config.mesh;
1479 }