Cycles: support loading images from arbitrary OpenColorIO color space
[blender.git] / intern / cycles / blender / blender_mesh.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "render/colorspace.h"
18 #include "render/mesh.h"
19 #include "render/object.h"
20 #include "render/scene.h"
21 #include "render/camera.h"
22
23 #include "blender/blender_sync.h"
24 #include "blender/blender_session.h"
25 #include "blender/blender_util.h"
26
27 #include "subd/subd_patch.h"
28 #include "subd/subd_split.h"
29
30 #include "util/util_algorithm.h"
31 #include "util/util_foreach.h"
32 #include "util/util_logging.h"
33 #include "util/util_math.h"
34
35 #include "mikktspace.h"
36
37 CCL_NAMESPACE_BEGIN
38
39 /* Tangent Space */
40
41 struct MikkUserData {
42   MikkUserData(const BL::Mesh &b_mesh,
43                const char *layer_name,
44                const Mesh *mesh,
45                float3 *tangent,
46                float *tangent_sign)
47       : mesh(mesh), texface(NULL), orco(NULL), tangent(tangent), tangent_sign(tangent_sign)
48   {
49     const AttributeSet &attributes = (mesh->subd_faces.size()) ? mesh->subd_attributes :
50                                                                  mesh->attributes;
51
52     Attribute *attr_vN = attributes.find(ATTR_STD_VERTEX_NORMAL);
53     vertex_normal = attr_vN->data_float3();
54
55     if (layer_name == NULL) {
56       Attribute *attr_orco = attributes.find(ATTR_STD_GENERATED);
57
58       if (attr_orco) {
59         orco = attr_orco->data_float3();
60         mesh_texture_space(*(BL::Mesh *)&b_mesh, orco_loc, orco_size);
61       }
62     }
63     else {
64       Attribute *attr_uv = attributes.find(ustring(layer_name));
65       if (attr_uv != NULL) {
66         texface = attr_uv->data_float2();
67       }
68     }
69   }
70
71   const Mesh *mesh;
72   int num_faces;
73
74   float3 *vertex_normal;
75   float2 *texface;
76   float3 *orco;
77   float3 orco_loc, orco_size;
78
79   float3 *tangent;
80   float *tangent_sign;
81 };
82
83 static int mikk_get_num_faces(const SMikkTSpaceContext *context)
84 {
85   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
86   if (userdata->mesh->subd_faces.size()) {
87     return userdata->mesh->subd_faces.size();
88   }
89   else {
90     return userdata->mesh->num_triangles();
91   }
92 }
93
94 static int mikk_get_num_verts_of_face(const SMikkTSpaceContext *context, const int face_num)
95 {
96   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
97   if (userdata->mesh->subd_faces.size()) {
98     const Mesh *mesh = userdata->mesh;
99     return mesh->subd_faces[face_num].num_corners;
100   }
101   else {
102     return 3;
103   }
104 }
105
106 static int mikk_vertex_index(const Mesh *mesh, const int face_num, const int vert_num)
107 {
108   if (mesh->subd_faces.size()) {
109     const Mesh::SubdFace &face = mesh->subd_faces[face_num];
110     return mesh->subd_face_corners[face.start_corner + vert_num];
111   }
112   else {
113     return mesh->triangles[face_num * 3 + vert_num];
114   }
115 }
116
117 static int mikk_corner_index(const Mesh *mesh, const int face_num, const int vert_num)
118 {
119   if (mesh->subd_faces.size()) {
120     const Mesh::SubdFace &face = mesh->subd_faces[face_num];
121     return face.start_corner + vert_num;
122   }
123   else {
124     return face_num * 3 + vert_num;
125   }
126 }
127
128 static void mikk_get_position(const SMikkTSpaceContext *context,
129                               float P[3],
130                               const int face_num,
131                               const int vert_num)
132 {
133   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
134   const Mesh *mesh = userdata->mesh;
135   const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
136   const float3 vP = mesh->verts[vertex_index];
137   P[0] = vP.x;
138   P[1] = vP.y;
139   P[2] = vP.z;
140 }
141
142 static void mikk_get_texture_coordinate(const SMikkTSpaceContext *context,
143                                         float uv[2],
144                                         const int face_num,
145                                         const int vert_num)
146 {
147   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
148   const Mesh *mesh = userdata->mesh;
149   if (userdata->texface != NULL) {
150     const int corner_index = mikk_corner_index(mesh, face_num, vert_num);
151     float2 tfuv = userdata->texface[corner_index];
152     uv[0] = tfuv.x;
153     uv[1] = tfuv.y;
154   }
155   else if (userdata->orco != NULL) {
156     const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
157     const float3 orco_loc = userdata->orco_loc;
158     const float3 orco_size = userdata->orco_size;
159     const float3 orco = (userdata->orco[vertex_index] + orco_loc) / orco_size;
160
161     const float2 tmp = map_to_sphere(orco);
162     uv[0] = tmp.x;
163     uv[1] = tmp.y;
164   }
165   else {
166     uv[0] = 0.0f;
167     uv[1] = 0.0f;
168   }
169 }
170
171 static void mikk_get_normal(const SMikkTSpaceContext *context,
172                             float N[3],
173                             const int face_num,
174                             const int vert_num)
175 {
176   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
177   const Mesh *mesh = userdata->mesh;
178   float3 vN;
179   if (mesh->subd_faces.size()) {
180     const Mesh::SubdFace &face = mesh->subd_faces[face_num];
181     if (face.smooth) {
182       const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
183       vN = userdata->vertex_normal[vertex_index];
184     }
185     else {
186       vN = face.normal(mesh);
187     }
188   }
189   else {
190     if (mesh->smooth[face_num]) {
191       const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
192       vN = userdata->vertex_normal[vertex_index];
193     }
194     else {
195       const Mesh::Triangle tri = mesh->get_triangle(face_num);
196       vN = tri.compute_normal(&mesh->verts[0]);
197     }
198   }
199   N[0] = vN.x;
200   N[1] = vN.y;
201   N[2] = vN.z;
202 }
203
204 static void mikk_set_tangent_space(const SMikkTSpaceContext *context,
205                                    const float T[],
206                                    const float sign,
207                                    const int face_num,
208                                    const int vert_num)
209 {
210   MikkUserData *userdata = (MikkUserData *)context->m_pUserData;
211   const Mesh *mesh = userdata->mesh;
212   const int corner_index = mikk_corner_index(mesh, face_num, vert_num);
213   userdata->tangent[corner_index] = make_float3(T[0], T[1], T[2]);
214   if (userdata->tangent_sign != NULL) {
215     userdata->tangent_sign[corner_index] = sign;
216   }
217 }
218
219 static void mikk_compute_tangents(
220     const BL::Mesh &b_mesh, const char *layer_name, Mesh *mesh, bool need_sign, bool active_render)
221 {
222   /* Create tangent attributes. */
223   AttributeSet &attributes = (mesh->subd_faces.size()) ? mesh->subd_attributes : mesh->attributes;
224   Attribute *attr;
225   ustring name;
226   if (layer_name != NULL) {
227     name = ustring((string(layer_name) + ".tangent").c_str());
228   }
229   else {
230     name = ustring("orco.tangent");
231   }
232   if (active_render) {
233     attr = attributes.add(ATTR_STD_UV_TANGENT, name);
234   }
235   else {
236     attr = attributes.add(name, TypeDesc::TypeVector, ATTR_ELEMENT_CORNER);
237   }
238   float3 *tangent = attr->data_float3();
239   /* Create bitangent sign attribute. */
240   float *tangent_sign = NULL;
241   if (need_sign) {
242     Attribute *attr_sign;
243     ustring name_sign;
244     if (layer_name != NULL) {
245       name_sign = ustring((string(layer_name) + ".tangent_sign").c_str());
246     }
247     else {
248       name_sign = ustring("orco.tangent_sign");
249     }
250
251     if (active_render) {
252       attr_sign = attributes.add(ATTR_STD_UV_TANGENT_SIGN, name_sign);
253     }
254     else {
255       attr_sign = attributes.add(name_sign, TypeDesc::TypeFloat, ATTR_ELEMENT_CORNER);
256     }
257     tangent_sign = attr_sign->data_float();
258   }
259   /* Setup userdata. */
260   MikkUserData userdata(b_mesh, layer_name, mesh, tangent, tangent_sign);
261   /* Setup interface. */
262   SMikkTSpaceInterface sm_interface;
263   memset(&sm_interface, 0, sizeof(sm_interface));
264   sm_interface.m_getNumFaces = mikk_get_num_faces;
265   sm_interface.m_getNumVerticesOfFace = mikk_get_num_verts_of_face;
266   sm_interface.m_getPosition = mikk_get_position;
267   sm_interface.m_getTexCoord = mikk_get_texture_coordinate;
268   sm_interface.m_getNormal = mikk_get_normal;
269   sm_interface.m_setTSpaceBasic = mikk_set_tangent_space;
270   /* Setup context. */
271   SMikkTSpaceContext context;
272   memset(&context, 0, sizeof(context));
273   context.m_pUserData = &userdata;
274   context.m_pInterface = &sm_interface;
275   /* Compute tangents. */
276   genTangSpaceDefault(&context);
277 }
278
279 /* Create Volume Attribute */
280
281 static void create_mesh_volume_attribute(
282     BL::Object &b_ob, Mesh *mesh, ImageManager *image_manager, AttributeStandard std, float frame)
283 {
284   BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
285
286   if (!b_domain)
287     return;
288
289   mesh->volume_isovalue = b_domain.clipping();
290
291   Attribute *attr = mesh->attributes.add(std);
292   VoxelAttribute *volume_data = attr->data_voxel();
293   ImageMetaData metadata;
294   bool animated = false;
295   bool use_alpha = true;
296
297   volume_data->manager = image_manager;
298   volume_data->slot = image_manager->add_image(Attribute::standard_name(std),
299                                                b_ob.ptr.data,
300                                                animated,
301                                                frame,
302                                                INTERPOLATION_LINEAR,
303                                                EXTENSION_CLIP,
304                                                use_alpha,
305                                                u_colorspace_raw,
306                                                metadata);
307 }
308
309 static void create_mesh_volume_attributes(Scene *scene, BL::Object &b_ob, Mesh *mesh, float frame)
310 {
311   /* for smoke volume rendering */
312   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_DENSITY))
313     create_mesh_volume_attribute(b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_DENSITY, frame);
314   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_COLOR))
315     create_mesh_volume_attribute(b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_COLOR, frame);
316   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_FLAME))
317     create_mesh_volume_attribute(b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_FLAME, frame);
318   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_HEAT))
319     create_mesh_volume_attribute(b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_HEAT, frame);
320   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_TEMPERATURE))
321     create_mesh_volume_attribute(
322         b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_TEMPERATURE, frame);
323   if (mesh->need_attribute(scene, ATTR_STD_VOLUME_VELOCITY))
324     create_mesh_volume_attribute(
325         b_ob, mesh, scene->image_manager, ATTR_STD_VOLUME_VELOCITY, frame);
326 }
327
328 /* Create vertex color attributes. */
329 static void attr_create_vertex_color(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, bool subdivision)
330 {
331   if (subdivision) {
332     BL::Mesh::vertex_colors_iterator l;
333
334     for (b_mesh.vertex_colors.begin(l); l != b_mesh.vertex_colors.end(); ++l) {
335       if (!mesh->need_attribute(scene, ustring(l->name().c_str())))
336         continue;
337
338       Attribute *attr = mesh->subd_attributes.add(
339           ustring(l->name().c_str()), TypeDesc::TypeColor, ATTR_ELEMENT_CORNER_BYTE);
340
341       BL::Mesh::polygons_iterator p;
342       uchar4 *cdata = attr->data_uchar4();
343
344       for (b_mesh.polygons.begin(p); p != b_mesh.polygons.end(); ++p) {
345         int n = p->loop_total();
346         for (int i = 0; i < n; i++) {
347           float3 color = get_float3(l->data[p->loop_start() + i].color());
348           /* Compress/encode vertex color using the sRGB curve. */
349           *(cdata++) = color_float_to_byte(color_srgb_to_linear_v3(color));
350         }
351       }
352     }
353   }
354   else {
355     BL::Mesh::vertex_colors_iterator l;
356     for (b_mesh.vertex_colors.begin(l); l != b_mesh.vertex_colors.end(); ++l) {
357       if (!mesh->need_attribute(scene, ustring(l->name().c_str())))
358         continue;
359
360       Attribute *attr = mesh->attributes.add(
361           ustring(l->name().c_str()), TypeDesc::TypeColor, ATTR_ELEMENT_CORNER_BYTE);
362
363       BL::Mesh::loop_triangles_iterator t;
364       uchar4 *cdata = attr->data_uchar4();
365
366       for (b_mesh.loop_triangles.begin(t); t != b_mesh.loop_triangles.end(); ++t) {
367         int3 li = get_int3(t->loops());
368         float3 c1 = get_float3(l->data[li[0]].color());
369         float3 c2 = get_float3(l->data[li[1]].color());
370         float3 c3 = get_float3(l->data[li[2]].color());
371
372         /* Compress/encode vertex color using the sRGB curve. */
373         cdata[0] = color_float_to_byte(color_srgb_to_linear_v3(c1));
374         cdata[1] = color_float_to_byte(color_srgb_to_linear_v3(c2));
375         cdata[2] = color_float_to_byte(color_srgb_to_linear_v3(c3));
376         cdata += 3;
377       }
378     }
379   }
380 }
381
382 /* Create uv map attributes. */
383 static void attr_create_uv_map(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh)
384 {
385   if (b_mesh.uv_layers.length() != 0) {
386     BL::Mesh::uv_layers_iterator l;
387
388     for (b_mesh.uv_layers.begin(l); l != b_mesh.uv_layers.end(); ++l) {
389       const bool active_render = l->active_render();
390       AttributeStandard uv_std = (active_render) ? ATTR_STD_UV : ATTR_STD_NONE;
391       ustring uv_name = ustring(l->name().c_str());
392       AttributeStandard tangent_std = (active_render) ? ATTR_STD_UV_TANGENT : ATTR_STD_NONE;
393       ustring tangent_name = ustring((string(l->name().c_str()) + ".tangent").c_str());
394
395       /* Denotes whether UV map was requested directly. */
396       const bool need_uv = mesh->need_attribute(scene, uv_name) ||
397                            mesh->need_attribute(scene, uv_std);
398       /* Denotes whether tangent was requested directly. */
399       const bool need_tangent = mesh->need_attribute(scene, tangent_name) ||
400                                 (active_render && mesh->need_attribute(scene, tangent_std));
401
402       /* UV map */
403       /* NOTE: We create temporary UV layer if its needed for tangent but
404        * wasn't requested by other nodes in shaders.
405        */
406       Attribute *uv_attr = NULL;
407       if (need_uv || need_tangent) {
408         if (active_render) {
409           uv_attr = mesh->attributes.add(uv_std, uv_name);
410         }
411         else {
412           uv_attr = mesh->attributes.add(uv_name, TypeFloat2, ATTR_ELEMENT_CORNER);
413         }
414
415         BL::Mesh::loop_triangles_iterator t;
416         float2 *fdata = uv_attr->data_float2();
417
418         for (b_mesh.loop_triangles.begin(t); t != b_mesh.loop_triangles.end(); ++t) {
419           int3 li = get_int3(t->loops());
420           fdata[0] = get_float2(l->data[li[0]].uv());
421           fdata[1] = get_float2(l->data[li[1]].uv());
422           fdata[2] = get_float2(l->data[li[2]].uv());
423           fdata += 3;
424         }
425       }
426
427       /* UV tangent */
428       if (need_tangent) {
429         AttributeStandard sign_std = (active_render) ? ATTR_STD_UV_TANGENT_SIGN : ATTR_STD_NONE;
430         ustring sign_name = ustring((string(l->name().c_str()) + ".tangent_sign").c_str());
431         bool need_sign = (mesh->need_attribute(scene, sign_name) ||
432                           mesh->need_attribute(scene, sign_std));
433         mikk_compute_tangents(b_mesh, l->name().c_str(), mesh, need_sign, active_render);
434       }
435       /* Remove temporarily created UV attribute. */
436       if (!need_uv && uv_attr != NULL) {
437         mesh->attributes.remove(uv_attr);
438       }
439     }
440   }
441   else if (mesh->need_attribute(scene, ATTR_STD_UV_TANGENT)) {
442     bool need_sign = mesh->need_attribute(scene, ATTR_STD_UV_TANGENT_SIGN);
443     mikk_compute_tangents(b_mesh, NULL, mesh, need_sign, true);
444     if (!mesh->need_attribute(scene, ATTR_STD_GENERATED)) {
445       mesh->attributes.remove(ATTR_STD_GENERATED);
446     }
447   }
448 }
449
450 static void attr_create_subd_uv_map(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, bool subdivide_uvs)
451 {
452   if (b_mesh.uv_layers.length() != 0) {
453     BL::Mesh::uv_layers_iterator l;
454     int i = 0;
455
456     for (b_mesh.uv_layers.begin(l); l != b_mesh.uv_layers.end(); ++l, ++i) {
457       bool active_render = l->active_render();
458       AttributeStandard uv_std = (active_render) ? ATTR_STD_UV : ATTR_STD_NONE;
459       ustring uv_name = ustring(l->name().c_str());
460       AttributeStandard tangent_std = (active_render) ? ATTR_STD_UV_TANGENT : ATTR_STD_NONE;
461       ustring tangent_name = ustring((string(l->name().c_str()) + ".tangent").c_str());
462
463       /* Denotes whether UV map was requested directly. */
464       const bool need_uv = mesh->need_attribute(scene, uv_name) ||
465                            mesh->need_attribute(scene, uv_std);
466       /* Denotes whether tangent was requested directly. */
467       const bool need_tangent = mesh->need_attribute(scene, tangent_name) ||
468                                 (active_render && mesh->need_attribute(scene, tangent_std));
469
470       Attribute *uv_attr = NULL;
471
472       /* UV map */
473       if (need_uv || need_tangent) {
474         if (active_render)
475           uv_attr = mesh->subd_attributes.add(uv_std, uv_name);
476         else
477           uv_attr = mesh->subd_attributes.add(uv_name, TypeFloat2, ATTR_ELEMENT_CORNER);
478
479         if (subdivide_uvs) {
480           uv_attr->flags |= ATTR_SUBDIVIDED;
481         }
482
483         BL::Mesh::polygons_iterator p;
484         float2 *fdata = uv_attr->data_float2();
485
486         for (b_mesh.polygons.begin(p); p != b_mesh.polygons.end(); ++p) {
487           int n = p->loop_total();
488           for (int j = 0; j < n; j++) {
489             *(fdata++) = get_float2(l->data[p->loop_start() + j].uv());
490           }
491         }
492       }
493
494       /* UV tangent */
495       if (need_tangent) {
496         AttributeStandard sign_std = (active_render) ? ATTR_STD_UV_TANGENT_SIGN : ATTR_STD_NONE;
497         ustring sign_name = ustring((string(l->name().c_str()) + ".tangent_sign").c_str());
498         bool need_sign = (mesh->need_attribute(scene, sign_name) ||
499                           mesh->need_attribute(scene, sign_std));
500         mikk_compute_tangents(b_mesh, l->name().c_str(), mesh, need_sign, active_render);
501       }
502       /* Remove temporarily created UV attribute. */
503       if (!need_uv && uv_attr != NULL) {
504         mesh->subd_attributes.remove(uv_attr);
505       }
506     }
507   }
508   else if (mesh->need_attribute(scene, ATTR_STD_UV_TANGENT)) {
509     bool need_sign = mesh->need_attribute(scene, ATTR_STD_UV_TANGENT_SIGN);
510     mikk_compute_tangents(b_mesh, NULL, mesh, need_sign, true);
511     if (!mesh->need_attribute(scene, ATTR_STD_GENERATED)) {
512       mesh->subd_attributes.remove(ATTR_STD_GENERATED);
513     }
514   }
515 }
516
517 /* Create vertex pointiness attributes. */
518
519 /* Compare vertices by sum of their coordinates. */
520 class VertexAverageComparator {
521  public:
522   VertexAverageComparator(const array<float3> &verts) : verts_(verts)
523   {
524   }
525
526   bool operator()(const int &vert_idx_a, const int &vert_idx_b)
527   {
528     const float3 &vert_a = verts_[vert_idx_a];
529     const float3 &vert_b = verts_[vert_idx_b];
530     if (vert_a == vert_b) {
531       /* Special case for doubles, so we ensure ordering. */
532       return vert_idx_a > vert_idx_b;
533     }
534     const float x1 = vert_a.x + vert_a.y + vert_a.z;
535     const float x2 = vert_b.x + vert_b.y + vert_b.z;
536     return x1 < x2;
537   }
538
539  protected:
540   const array<float3> &verts_;
541 };
542
543 static void attr_create_pointiness(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, bool subdivision)
544 {
545   if (!mesh->need_attribute(scene, ATTR_STD_POINTINESS)) {
546     return;
547   }
548   const int num_verts = b_mesh.vertices.length();
549   if (num_verts == 0) {
550     return;
551   }
552   /* STEP 1: Find out duplicated vertices and point duplicates to a single
553    *         original vertex.
554    */
555   vector<int> sorted_vert_indeices(num_verts);
556   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
557     sorted_vert_indeices[vert_index] = vert_index;
558   }
559   VertexAverageComparator compare(mesh->verts);
560   sort(sorted_vert_indeices.begin(), sorted_vert_indeices.end(), compare);
561   /* This array stores index of the original vertex for the given vertex
562    * index.
563    */
564   vector<int> vert_orig_index(num_verts);
565   for (int sorted_vert_index = 0; sorted_vert_index < num_verts; ++sorted_vert_index) {
566     const int vert_index = sorted_vert_indeices[sorted_vert_index];
567     const float3 &vert_co = mesh->verts[vert_index];
568     bool found = false;
569     for (int other_sorted_vert_index = sorted_vert_index + 1; other_sorted_vert_index < num_verts;
570          ++other_sorted_vert_index) {
571       const int other_vert_index = sorted_vert_indeices[other_sorted_vert_index];
572       const float3 &other_vert_co = mesh->verts[other_vert_index];
573       /* We are too far away now, we wouldn't have duplicate. */
574       if ((other_vert_co.x + other_vert_co.y + other_vert_co.z) -
575               (vert_co.x + vert_co.y + vert_co.z) >
576           3 * FLT_EPSILON) {
577         break;
578       }
579       /* Found duplicate. */
580       if (len_squared(other_vert_co - vert_co) < FLT_EPSILON) {
581         found = true;
582         vert_orig_index[vert_index] = other_vert_index;
583         break;
584       }
585     }
586     if (!found) {
587       vert_orig_index[vert_index] = vert_index;
588     }
589   }
590   /* Make sure we always points to the very first orig vertex. */
591   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
592     int orig_index = vert_orig_index[vert_index];
593     while (orig_index != vert_orig_index[orig_index]) {
594       orig_index = vert_orig_index[orig_index];
595     }
596     vert_orig_index[vert_index] = orig_index;
597   }
598   sorted_vert_indeices.free_memory();
599   /* STEP 2: Calculate vertex normals taking into account their possible
600    *         duplicates which gets "welded" together.
601    */
602   vector<float3> vert_normal(num_verts, make_float3(0.0f, 0.0f, 0.0f));
603   /* First we accumulate all vertex normals in the original index. */
604   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
605     const float3 normal = get_float3(b_mesh.vertices[vert_index].normal());
606     const int orig_index = vert_orig_index[vert_index];
607     vert_normal[orig_index] += normal;
608   }
609   /* Then we normalize the accumulated result and flush it to all duplicates
610    * as well.
611    */
612   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
613     const int orig_index = vert_orig_index[vert_index];
614     vert_normal[vert_index] = normalize(vert_normal[orig_index]);
615   }
616   /* STEP 3: Calculate pointiness using single ring neighborhood. */
617   vector<int> counter(num_verts, 0);
618   vector<float> raw_data(num_verts, 0.0f);
619   vector<float3> edge_accum(num_verts, make_float3(0.0f, 0.0f, 0.0f));
620   BL::Mesh::edges_iterator e;
621   EdgeMap visited_edges;
622   int edge_index = 0;
623   memset(&counter[0], 0, sizeof(int) * counter.size());
624   for (b_mesh.edges.begin(e); e != b_mesh.edges.end(); ++e, ++edge_index) {
625     const int v0 = vert_orig_index[b_mesh.edges[edge_index].vertices()[0]],
626               v1 = vert_orig_index[b_mesh.edges[edge_index].vertices()[1]];
627     if (visited_edges.exists(v0, v1)) {
628       continue;
629     }
630     visited_edges.insert(v0, v1);
631     float3 co0 = get_float3(b_mesh.vertices[v0].co()), co1 = get_float3(b_mesh.vertices[v1].co());
632     float3 edge = normalize(co1 - co0);
633     edge_accum[v0] += edge;
634     edge_accum[v1] += -edge;
635     ++counter[v0];
636     ++counter[v1];
637   }
638   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
639     const int orig_index = vert_orig_index[vert_index];
640     if (orig_index != vert_index) {
641       /* Skip duplicates, they'll be overwritten later on. */
642       continue;
643     }
644     if (counter[vert_index] > 0) {
645       const float3 normal = vert_normal[vert_index];
646       const float angle = safe_acosf(dot(normal, edge_accum[vert_index] / counter[vert_index]));
647       raw_data[vert_index] = angle * M_1_PI_F;
648     }
649     else {
650       raw_data[vert_index] = 0.0f;
651     }
652   }
653   /* STEP 3: Blur vertices to approximate 2 ring neighborhood. */
654   AttributeSet &attributes = (subdivision) ? mesh->subd_attributes : mesh->attributes;
655   Attribute *attr = attributes.add(ATTR_STD_POINTINESS);
656   float *data = attr->data_float();
657   memcpy(data, &raw_data[0], sizeof(float) * raw_data.size());
658   memset(&counter[0], 0, sizeof(int) * counter.size());
659   edge_index = 0;
660   visited_edges.clear();
661   for (b_mesh.edges.begin(e); e != b_mesh.edges.end(); ++e, ++edge_index) {
662     const int v0 = vert_orig_index[b_mesh.edges[edge_index].vertices()[0]],
663               v1 = vert_orig_index[b_mesh.edges[edge_index].vertices()[1]];
664     if (visited_edges.exists(v0, v1)) {
665       continue;
666     }
667     visited_edges.insert(v0, v1);
668     data[v0] += raw_data[v1];
669     data[v1] += raw_data[v0];
670     ++counter[v0];
671     ++counter[v1];
672   }
673   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
674     data[vert_index] /= counter[vert_index] + 1;
675   }
676   /* STEP 4: Copy attribute to the duplicated vertices. */
677   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
678     const int orig_index = vert_orig_index[vert_index];
679     data[vert_index] = data[orig_index];
680   }
681 }
682
683 /* Create Mesh */
684
685 static void create_mesh(Scene *scene,
686                         Mesh *mesh,
687                         BL::Mesh &b_mesh,
688                         const vector<Shader *> &used_shaders,
689                         bool subdivision = false,
690                         bool subdivide_uvs = true)
691 {
692   /* count vertices and faces */
693   int numverts = b_mesh.vertices.length();
694   int numfaces = (!subdivision) ? b_mesh.loop_triangles.length() : b_mesh.polygons.length();
695   int numtris = 0;
696   int numcorners = 0;
697   int numngons = 0;
698   bool use_loop_normals = b_mesh.use_auto_smooth() &&
699                           (mesh->subdivision_type != Mesh::SUBDIVISION_CATMULL_CLARK);
700
701   /* If no faces, create empty mesh. */
702   if (numfaces == 0) {
703     return;
704   }
705
706   if (!subdivision) {
707     numtris = numfaces;
708   }
709   else {
710     BL::Mesh::polygons_iterator p;
711     for (b_mesh.polygons.begin(p); p != b_mesh.polygons.end(); ++p) {
712       numngons += (p->loop_total() == 4) ? 0 : 1;
713       numcorners += p->loop_total();
714     }
715   }
716
717   /* allocate memory */
718   mesh->reserve_mesh(numverts, numtris);
719   mesh->reserve_subd_faces(numfaces, numngons, numcorners);
720
721   /* create vertex coordinates and normals */
722   BL::Mesh::vertices_iterator v;
723   for (b_mesh.vertices.begin(v); v != b_mesh.vertices.end(); ++v)
724     mesh->add_vertex(get_float3(v->co()));
725
726   AttributeSet &attributes = (subdivision) ? mesh->subd_attributes : mesh->attributes;
727   Attribute *attr_N = attributes.add(ATTR_STD_VERTEX_NORMAL);
728   float3 *N = attr_N->data_float3();
729
730   for (b_mesh.vertices.begin(v); v != b_mesh.vertices.end(); ++v, ++N)
731     *N = get_float3(v->normal());
732   N = attr_N->data_float3();
733
734   /* create generated coordinates from undeformed coordinates */
735   const bool need_default_tangent = (subdivision == false) && (b_mesh.uv_layers.length() == 0) &&
736                                     (mesh->need_attribute(scene, ATTR_STD_UV_TANGENT));
737   if (mesh->need_attribute(scene, ATTR_STD_GENERATED) || need_default_tangent) {
738     Attribute *attr = attributes.add(ATTR_STD_GENERATED);
739     attr->flags |= ATTR_SUBDIVIDED;
740
741     float3 loc, size;
742     mesh_texture_space(b_mesh, loc, size);
743
744     float3 *generated = attr->data_float3();
745     size_t i = 0;
746
747     for (b_mesh.vertices.begin(v); v != b_mesh.vertices.end(); ++v) {
748       generated[i++] = get_float3(v->undeformed_co()) * size - loc;
749     }
750   }
751
752   /* create faces */
753   if (!subdivision) {
754     BL::Mesh::loop_triangles_iterator t;
755
756     for (b_mesh.loop_triangles.begin(t); t != b_mesh.loop_triangles.end(); ++t) {
757       BL::MeshPolygon p = b_mesh.polygons[t->polygon_index()];
758       int3 vi = get_int3(t->vertices());
759
760       int shader = clamp(p.material_index(), 0, used_shaders.size() - 1);
761       bool smooth = p.use_smooth() || use_loop_normals;
762
763       if (use_loop_normals) {
764         BL::Array<float, 9> loop_normals = t->split_normals();
765         for (int i = 0; i < 3; i++) {
766           N[vi[i]] = make_float3(
767               loop_normals[i * 3], loop_normals[i * 3 + 1], loop_normals[i * 3 + 2]);
768         }
769       }
770
771       /* Create triangles.
772        *
773        * NOTE: Autosmooth is already taken care about.
774        */
775       mesh->add_triangle(vi[0], vi[1], vi[2], shader, smooth);
776     }
777   }
778   else {
779     BL::Mesh::polygons_iterator p;
780     vector<int> vi;
781
782     for (b_mesh.polygons.begin(p); p != b_mesh.polygons.end(); ++p) {
783       int n = p->loop_total();
784       int shader = clamp(p->material_index(), 0, used_shaders.size() - 1);
785       bool smooth = p->use_smooth() || use_loop_normals;
786
787       vi.resize(n);
788       for (int i = 0; i < n; i++) {
789         /* NOTE: Autosmooth is already taken care about. */
790         vi[i] = b_mesh.loops[p->loop_start() + i].vertex_index();
791       }
792
793       /* create subd faces */
794       mesh->add_subd_face(&vi[0], n, shader, smooth);
795     }
796   }
797
798   /* Create all needed attributes.
799    * The calculate functions will check whether they're needed or not.
800    */
801   attr_create_pointiness(scene, mesh, b_mesh, subdivision);
802   attr_create_vertex_color(scene, mesh, b_mesh, subdivision);
803
804   if (subdivision) {
805     attr_create_subd_uv_map(scene, mesh, b_mesh, subdivide_uvs);
806   }
807   else {
808     attr_create_uv_map(scene, mesh, b_mesh);
809   }
810
811   /* for volume objects, create a matrix to transform from object space to
812    * mesh texture space. this does not work with deformations but that can
813    * probably only be done well with a volume grid mapping of coordinates */
814   if (mesh->need_attribute(scene, ATTR_STD_GENERATED_TRANSFORM)) {
815     Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED_TRANSFORM);
816     Transform *tfm = attr->data_transform();
817
818     float3 loc, size;
819     mesh_texture_space(b_mesh, loc, size);
820
821     *tfm = transform_translate(-loc) * transform_scale(size);
822   }
823 }
824
825 static void create_subd_mesh(Scene *scene,
826                              Mesh *mesh,
827                              BL::Object &b_ob,
828                              BL::Mesh &b_mesh,
829                              const vector<Shader *> &used_shaders,
830                              float dicing_rate,
831                              int max_subdivisions)
832 {
833   BL::SubsurfModifier subsurf_mod(b_ob.modifiers[b_ob.modifiers.length() - 1]);
834   bool subdivide_uvs = subsurf_mod.uv_smooth() != BL::SubsurfModifier::uv_smooth_NONE;
835
836   create_mesh(scene, mesh, b_mesh, used_shaders, true, subdivide_uvs);
837
838   /* export creases */
839   size_t num_creases = 0;
840   BL::Mesh::edges_iterator e;
841
842   for (b_mesh.edges.begin(e); e != b_mesh.edges.end(); ++e) {
843     if (e->crease() != 0.0f) {
844       num_creases++;
845     }
846   }
847
848   mesh->subd_creases.resize(num_creases);
849
850   Mesh::SubdEdgeCrease *crease = mesh->subd_creases.data();
851   for (b_mesh.edges.begin(e); e != b_mesh.edges.end(); ++e) {
852     if (e->crease() != 0.0f) {
853       crease->v[0] = e->vertices()[0];
854       crease->v[1] = e->vertices()[1];
855       crease->crease = e->crease();
856
857       crease++;
858     }
859   }
860
861   /* set subd params */
862   if (!mesh->subd_params) {
863     mesh->subd_params = new SubdParams(mesh);
864   }
865   SubdParams &sdparams = *mesh->subd_params;
866
867   PointerRNA cobj = RNA_pointer_get(&b_ob.ptr, "cycles");
868
869   sdparams.dicing_rate = max(0.1f, RNA_float_get(&cobj, "dicing_rate") * dicing_rate);
870   sdparams.max_level = max_subdivisions;
871
872   sdparams.objecttoworld = get_transform(b_ob.matrix_world());
873 }
874
875 /* Sync */
876
877 static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
878 {
879   if (scene->need_motion() == Scene::MOTION_NONE)
880     return;
881
882   BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
883
884   if (!b_fluid_domain)
885     return;
886
887   /* If the mesh has modifiers following the fluid domain we can't export motion. */
888   if (b_fluid_domain.fluid_mesh_vertices.length() != mesh->verts.size())
889     return;
890
891   /* Find or add attribute */
892   float3 *P = &mesh->verts[0];
893   Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
894
895   if (!attr_mP) {
896     attr_mP = mesh->attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
897   }
898
899   /* Only export previous and next frame, we don't have any in between data. */
900   float motion_times[2] = {-1.0f, 1.0f};
901   for (int step = 0; step < 2; step++) {
902     float relative_time = motion_times[step] * scene->motion_shutter_time() * 0.5f;
903     float3 *mP = attr_mP->data_float3() + step * mesh->verts.size();
904
905     BL::DomainFluidSettings::fluid_mesh_vertices_iterator fvi;
906     int i = 0;
907
908     for (b_fluid_domain.fluid_mesh_vertices.begin(fvi);
909          fvi != b_fluid_domain.fluid_mesh_vertices.end();
910          ++fvi, ++i) {
911       mP[i] = P[i] + get_float3(fvi->velocity()) * relative_time;
912     }
913   }
914 }
915
916 Mesh *BlenderSync::sync_mesh(BL::Depsgraph &b_depsgraph,
917                              BL::Object &b_ob,
918                              BL::Object &b_ob_instance,
919                              bool object_updated,
920                              bool show_self,
921                              bool show_particles)
922 {
923   /* test if we can instance or if the object is modified */
924   BL::ID b_ob_data = b_ob.data();
925   BL::ID key = (BKE_object_is_modified(b_ob)) ? b_ob_instance : b_ob_data;
926   BL::Material material_override = view_layer.material_override;
927
928   /* find shader indices */
929   vector<Shader *> used_shaders;
930
931   BL::Object::material_slots_iterator slot;
932   for (b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot) {
933     if (material_override) {
934       find_shader(material_override, used_shaders, scene->default_surface);
935     }
936     else {
937       BL::ID b_material(slot->material());
938       find_shader(b_material, used_shaders, scene->default_surface);
939     }
940   }
941
942   if (used_shaders.size() == 0) {
943     if (material_override)
944       find_shader(material_override, used_shaders, scene->default_surface);
945     else
946       used_shaders.push_back(scene->default_surface);
947   }
948
949   /* test if we need to sync */
950   int requested_geometry_flags = Mesh::GEOMETRY_NONE;
951   if (view_layer.use_surfaces) {
952     requested_geometry_flags |= Mesh::GEOMETRY_TRIANGLES;
953   }
954   if (view_layer.use_hair) {
955     requested_geometry_flags |= Mesh::GEOMETRY_CURVES;
956   }
957   Mesh *mesh;
958
959   if (!mesh_map.sync(&mesh, key)) {
960     /* if transform was applied to mesh, need full update */
961     if (object_updated && mesh->transform_applied)
962       ;
963     /* test if shaders changed, these can be object level so mesh
964      * does not get tagged for recalc */
965     else if (mesh->used_shaders != used_shaders)
966       ;
967     else if (requested_geometry_flags != mesh->geometry_flags)
968       ;
969     else {
970       /* even if not tagged for recalc, we may need to sync anyway
971        * because the shader needs different mesh attributes */
972       bool attribute_recalc = false;
973
974       foreach (Shader *shader, mesh->used_shaders)
975         if (shader->need_update_mesh)
976           attribute_recalc = true;
977
978       if (!attribute_recalc)
979         return mesh;
980     }
981   }
982
983   /* ensure we only sync instanced meshes once */
984   if (mesh_synced.find(mesh) != mesh_synced.end())
985     return mesh;
986
987   progress.set_sync_status("Synchronizing object", b_ob.name());
988
989   mesh_synced.insert(mesh);
990
991   /* create derived mesh */
992   array<int> oldtriangles;
993   array<Mesh::SubdFace> oldsubd_faces;
994   array<int> oldsubd_face_corners;
995   oldtriangles.steal_data(mesh->triangles);
996   oldsubd_faces.steal_data(mesh->subd_faces);
997   oldsubd_face_corners.steal_data(mesh->subd_face_corners);
998
999   /* compares curve_keys rather than strands in order to handle quick hair
1000    * adjustments in dynamic BVH - other methods could probably do this better*/
1001   array<float3> oldcurve_keys;
1002   array<float> oldcurve_radius;
1003   oldcurve_keys.steal_data(mesh->curve_keys);
1004   oldcurve_radius.steal_data(mesh->curve_radius);
1005
1006   mesh->clear();
1007   mesh->used_shaders = used_shaders;
1008   mesh->name = ustring(b_ob_data.name().c_str());
1009
1010   if (requested_geometry_flags != Mesh::GEOMETRY_NONE) {
1011     /* Adaptive subdivision setup. Not for baking since that requires
1012      * exact mapping to the Blender mesh. */
1013     if (scene->bake_manager->get_baking()) {
1014       mesh->subdivision_type = Mesh::SUBDIVISION_NONE;
1015     }
1016     else {
1017       mesh->subdivision_type = object_subdivision_type(b_ob, preview, experimental);
1018     }
1019
1020     /* For some reason, meshes do not need this... */
1021     bool need_undeformed = mesh->need_attribute(scene, ATTR_STD_GENERATED);
1022
1023     BL::Mesh b_mesh = object_to_mesh(
1024         b_data, b_ob, b_depsgraph, need_undeformed, mesh->subdivision_type);
1025
1026     if (b_mesh) {
1027       /* Sync mesh itself. */
1028       if (view_layer.use_surfaces && show_self) {
1029         if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE)
1030           create_subd_mesh(scene, mesh, b_ob, b_mesh, used_shaders, dicing_rate, max_subdivisions);
1031         else
1032           create_mesh(scene, mesh, b_mesh, used_shaders, false);
1033
1034         create_mesh_volume_attributes(scene, b_ob, mesh, b_scene.frame_current());
1035       }
1036
1037       /* Sync hair curves. */
1038       if (view_layer.use_hair && show_particles &&
1039           mesh->subdivision_type == Mesh::SUBDIVISION_NONE) {
1040         sync_curves(mesh, b_mesh, b_ob, false);
1041       }
1042
1043       free_object_to_mesh(b_data, b_ob, b_mesh);
1044     }
1045   }
1046   mesh->geometry_flags = requested_geometry_flags;
1047
1048   /* fluid motion */
1049   sync_mesh_fluid_motion(b_ob, scene, mesh);
1050
1051   /* tag update */
1052   bool rebuild = (oldtriangles != mesh->triangles) || (oldsubd_faces != mesh->subd_faces) ||
1053                  (oldsubd_face_corners != mesh->subd_face_corners) ||
1054                  (oldcurve_keys != mesh->curve_keys) || (oldcurve_radius != mesh->curve_radius);
1055
1056   mesh->tag_update(scene, rebuild);
1057
1058   return mesh;
1059 }
1060
1061 void BlenderSync::sync_mesh_motion(BL::Depsgraph &b_depsgraph,
1062                                    BL::Object &b_ob,
1063                                    Object *object,
1064                                    float motion_time)
1065 {
1066   /* ensure we only sync instanced meshes once */
1067   Mesh *mesh = object->mesh;
1068
1069   if (mesh_motion_synced.find(mesh) != mesh_motion_synced.end())
1070     return;
1071
1072   mesh_motion_synced.insert(mesh);
1073
1074   /* ensure we only motion sync meshes that also had mesh synced, to avoid
1075    * unnecessary work and to ensure that its attributes were clear */
1076   if (mesh_synced.find(mesh) == mesh_synced.end())
1077     return;
1078
1079   /* Find time matching motion step required by mesh. */
1080   int motion_step = mesh->motion_step(motion_time);
1081   if (motion_step < 0) {
1082     return;
1083   }
1084
1085   /* skip empty meshes */
1086   const size_t numverts = mesh->verts.size();
1087   const size_t numkeys = mesh->curve_keys.size();
1088
1089   if (!numverts && !numkeys)
1090     return;
1091
1092   /* skip objects without deforming modifiers. this is not totally reliable,
1093    * would need a more extensive check to see which objects are animated */
1094   BL::Mesh b_mesh(PointerRNA_NULL);
1095
1096   /* fluid motion is exported immediate with mesh, skip here */
1097   BL::DomainFluidSettings b_fluid_domain = object_fluid_domain_find(b_ob);
1098   if (b_fluid_domain)
1099     return;
1100
1101   if (ccl::BKE_object_is_deform_modified(b_ob, b_scene, preview)) {
1102     /* get derived mesh */
1103     b_mesh = object_to_mesh(b_data, b_ob, b_depsgraph, false, Mesh::SUBDIVISION_NONE);
1104   }
1105
1106   if (!b_mesh) {
1107     /* if we have no motion blur on this frame, but on other frames, copy */
1108     if (numverts) {
1109       /* triangles */
1110       Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
1111
1112       if (attr_mP) {
1113         Attribute *attr_mN = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_NORMAL);
1114         Attribute *attr_N = mesh->attributes.find(ATTR_STD_VERTEX_NORMAL);
1115         float3 *P = &mesh->verts[0];
1116         float3 *N = (attr_N) ? attr_N->data_float3() : NULL;
1117
1118         memcpy(attr_mP->data_float3() + motion_step * numverts, P, sizeof(float3) * numverts);
1119         if (attr_mN)
1120           memcpy(attr_mN->data_float3() + motion_step * numverts, N, sizeof(float3) * numverts);
1121       }
1122     }
1123
1124     if (numkeys) {
1125       /* curves */
1126       Attribute *attr_mP = mesh->curve_attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
1127
1128       if (attr_mP) {
1129         float3 *keys = &mesh->curve_keys[0];
1130         memcpy(attr_mP->data_float3() + motion_step * numkeys, keys, sizeof(float3) * numkeys);
1131       }
1132     }
1133
1134     return;
1135   }
1136
1137   /* TODO(sergey): Perform preliminary check for number of verticies. */
1138   if (numverts) {
1139     /* Find attributes. */
1140     Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
1141     Attribute *attr_mN = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_NORMAL);
1142     Attribute *attr_N = mesh->attributes.find(ATTR_STD_VERTEX_NORMAL);
1143     bool new_attribute = false;
1144     /* Add new attributes if they don't exist already. */
1145     if (!attr_mP) {
1146       attr_mP = mesh->attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
1147       if (attr_N)
1148         attr_mN = mesh->attributes.add(ATTR_STD_MOTION_VERTEX_NORMAL);
1149
1150       new_attribute = true;
1151     }
1152     /* Load vertex data from mesh. */
1153     float3 *mP = attr_mP->data_float3() + motion_step * numverts;
1154     float3 *mN = (attr_mN) ? attr_mN->data_float3() + motion_step * numverts : NULL;
1155     /* NOTE: We don't copy more that existing amount of vertices to prevent
1156      * possible memory corruption.
1157      */
1158     BL::Mesh::vertices_iterator v;
1159     int i = 0;
1160     for (b_mesh.vertices.begin(v); v != b_mesh.vertices.end() && i < numverts; ++v, ++i) {
1161       mP[i] = get_float3(v->co());
1162       if (mN)
1163         mN[i] = get_float3(v->normal());
1164     }
1165     if (new_attribute) {
1166       /* In case of new attribute, we verify if there really was any motion. */
1167       if (b_mesh.vertices.length() != numverts ||
1168           memcmp(mP, &mesh->verts[0], sizeof(float3) * numverts) == 0) {
1169         /* no motion, remove attributes again */
1170         if (b_mesh.vertices.length() != numverts) {
1171           VLOG(1) << "Topology differs, disabling motion blur for object " << b_ob.name();
1172         }
1173         else {
1174           VLOG(1) << "No actual deformation motion for object " << b_ob.name();
1175         }
1176         mesh->attributes.remove(ATTR_STD_MOTION_VERTEX_POSITION);
1177         if (attr_mN)
1178           mesh->attributes.remove(ATTR_STD_MOTION_VERTEX_NORMAL);
1179       }
1180       else if (motion_step > 0) {
1181         VLOG(1) << "Filling deformation motion for object " << b_ob.name();
1182         /* motion, fill up previous steps that we might have skipped because
1183          * they had no motion, but we need them anyway now */
1184         float3 *P = &mesh->verts[0];
1185         float3 *N = (attr_N) ? attr_N->data_float3() : NULL;
1186         for (int step = 0; step < motion_step; step++) {
1187           memcpy(attr_mP->data_float3() + step * numverts, P, sizeof(float3) * numverts);
1188           if (attr_mN)
1189             memcpy(attr_mN->data_float3() + step * numverts, N, sizeof(float3) * numverts);
1190         }
1191       }
1192     }
1193     else {
1194       if (b_mesh.vertices.length() != numverts) {
1195         VLOG(1) << "Topology differs, discarding motion blur for object " << b_ob.name()
1196                 << " at time " << motion_step;
1197         memcpy(mP, &mesh->verts[0], sizeof(float3) * numverts);
1198         if (mN != NULL) {
1199           memcpy(mN, attr_N->data_float3(), sizeof(float3) * numverts);
1200         }
1201       }
1202     }
1203   }
1204
1205   /* hair motion */
1206   if (numkeys)
1207     sync_curves(mesh, b_mesh, b_ob, true, motion_step);
1208
1209   /* free derived mesh */
1210   free_object_to_mesh(b_data, b_ob, b_mesh);
1211 }
1212
1213 CCL_NAMESPACE_END