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