Merge branch 'master' into blende2.8
[blender.git] / source / blender / blenkernel / intern / mesh_tangent.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/mesh_tangent.c
27  *  \ingroup bke
28  *
29  * Functions to evaluate mesh tangents.
30  */
31
32 #include <limits.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38
39 #include "BLI_utildefines.h"
40 #include "BLI_math.h"
41 #include "BLI_stack.h"
42 #include "BLI_task.h"
43
44 #include "BKE_customdata.h"
45 #include "BKE_global.h"
46 #include "BKE_mesh.h"
47 #include "BKE_mesh_tangent.h"
48 #include "BKE_mesh_runtime.h"
49 #include "BKE_report.h"
50
51 #include "BLI_strict_flags.h"
52
53 #include "atomic_ops.h"
54 #include "mikktspace.h"
55
56
57 /* -------------------------------------------------------------------- */
58
59 /** \name Mesh Tangent Calculations (Single Layer)
60  * \{ */
61
62 /* Tangent space utils. */
63
64 /* User data. */
65 typedef struct {
66         const MPoly *mpolys;   /* faces */
67         const MLoop *mloops;   /* faces's vertices */
68         const MVert *mverts;   /* vertices */
69         const MLoopUV *luvs;   /* texture coordinates */
70         float (*lnors)[3];     /* loops' normals */
71         float (*tangents)[4];  /* output tangents */
72         int num_polys;         /* number of polygons */
73 } BKEMeshToTangent;
74
75 /* Mikktspace's API */
76 static int get_num_faces(const SMikkTSpaceContext *pContext)
77 {
78         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
79         return p_mesh->num_polys;
80 }
81
82 static int get_num_verts_of_face(const SMikkTSpaceContext *pContext, const int face_idx)
83 {
84         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
85         return p_mesh->mpolys[face_idx].totloop;
86 }
87
88 static void get_position(const SMikkTSpaceContext *pContext, float r_co[3], const int face_idx, const int vert_idx)
89 {
90         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
91         const int loop_idx = p_mesh->mpolys[face_idx].loopstart + vert_idx;
92         copy_v3_v3(r_co, p_mesh->mverts[p_mesh->mloops[loop_idx].v].co);
93 }
94
95 static void get_texture_coordinate(
96         const SMikkTSpaceContext *pContext, float r_uv[2], const int face_idx,
97         const int vert_idx)
98 {
99         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
100         copy_v2_v2(r_uv, p_mesh->luvs[p_mesh->mpolys[face_idx].loopstart + vert_idx].uv);
101 }
102
103 static void get_normal(const SMikkTSpaceContext *pContext, float r_no[3], const int face_idx, const int vert_idx)
104 {
105         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
106         copy_v3_v3(r_no, p_mesh->lnors[p_mesh->mpolys[face_idx].loopstart + vert_idx]);
107 }
108
109 static void set_tspace(
110         const SMikkTSpaceContext *pContext, const float fv_tangent[3], const float face_sign,
111         const int face_idx, const int vert_idx)
112 {
113         BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
114         float *p_res = p_mesh->tangents[p_mesh->mpolys[face_idx].loopstart + vert_idx];
115         copy_v3_v3(p_res, fv_tangent);
116         p_res[3] = face_sign;
117 }
118
119 /**
120  * Compute simplified tangent space normals, i.e. tangent vector + sign of bi-tangent one, which combined with
121  * split normals can be used to recreate the full tangent space.
122  * Note: * The mesh should be made of only tris and quads!
123  */
124 void BKE_mesh_calc_loop_tangent_single_ex(
125         const MVert *mverts, const int UNUSED(numVerts), const MLoop *mloops,
126         float (*r_looptangent)[4], float (*loopnors)[3], const MLoopUV *loopuvs,
127         const int UNUSED(numLoops), const MPoly *mpolys, const int numPolys,
128         ReportList *reports)
129 {
130         BKEMeshToTangent mesh_to_tangent = {NULL};
131         SMikkTSpaceContext s_context = {NULL};
132         SMikkTSpaceInterface s_interface = {NULL};
133
134         const MPoly *mp;
135         int mp_index;
136
137         /* First check we do have a tris/quads only mesh. */
138         for (mp = mpolys, mp_index = 0; mp_index < numPolys; mp++, mp_index++) {
139                 if (mp->totloop > 4) {
140                         BKE_report(reports, RPT_ERROR, "Tangent space can only be computed for tris/quads, aborting");
141                         return;
142                 }
143         }
144
145         /* Compute Mikktspace's tangent normals. */
146         mesh_to_tangent.mpolys = mpolys;
147         mesh_to_tangent.mloops = mloops;
148         mesh_to_tangent.mverts = mverts;
149         mesh_to_tangent.luvs = loopuvs;
150         mesh_to_tangent.lnors = loopnors;
151         mesh_to_tangent.tangents = r_looptangent;
152         mesh_to_tangent.num_polys = numPolys;
153
154         s_context.m_pUserData = &mesh_to_tangent;
155         s_context.m_pInterface = &s_interface;
156         s_interface.m_getNumFaces = get_num_faces;
157         s_interface.m_getNumVerticesOfFace = get_num_verts_of_face;
158         s_interface.m_getPosition = get_position;
159         s_interface.m_getTexCoord = get_texture_coordinate;
160         s_interface.m_getNormal = get_normal;
161         s_interface.m_setTSpaceBasic = set_tspace;
162
163         /* 0 if failed */
164         if (genTangSpaceDefault(&s_context) == false) {
165                 BKE_report(reports, RPT_ERROR, "Mikktspace failed to generate tangents for this mesh!");
166         }
167 }
168
169 /**
170  * Wrapper around BKE_mesh_calc_loop_tangent_single_ex, which takes care of most boiling code.
171  * \note
172  * - There must be a valid loop's CD_NORMALS available.
173  * - The mesh should be made of only tris and quads!
174  */
175 void BKE_mesh_calc_loop_tangent_single(Mesh *mesh, const char *uvmap, float (*r_looptangents)[4], ReportList *reports)
176 {
177         MLoopUV *loopuvs;
178         float (*loopnors)[3];
179
180         /* Check we have valid texture coordinates first! */
181         if (uvmap) {
182                 loopuvs = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvmap);
183         }
184         else {
185                 loopuvs = CustomData_get_layer(&mesh->ldata, CD_MLOOPUV);
186         }
187         if (!loopuvs) {
188                 BKE_reportf(reports, RPT_ERROR, "Tangent space computation needs an UVMap, \"%s\" not found, aborting", uvmap);
189                 return;
190         }
191
192         loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
193         if (!loopnors) {
194                 BKE_report(reports, RPT_ERROR, "Tangent space computation needs loop normals, none found, aborting");
195                 return;
196         }
197
198         BKE_mesh_calc_loop_tangent_single_ex(
199                 mesh->mvert, mesh->totvert, mesh->mloop, r_looptangents,
200                 loopnors, loopuvs, mesh->totloop, mesh->mpoly, mesh->totpoly, reports);
201 }
202
203 /** \} */
204
205
206 /* -------------------------------------------------------------------- */
207
208 /** \name Mesh Tangent Calculations (All Layers)
209  * \{ */
210
211
212 /* Necessary complexity to handle looptri's as quads for correct tangents */
213 #define USE_LOOPTRI_DETECT_QUADS
214
215 typedef struct {
216         const float (*precomputedFaceNormals)[3];
217         const float (*precomputedLoopNormals)[3];
218         const MLoopTri *looptri;
219         MLoopUV *mloopuv;   /* texture coordinates */
220         const MPoly *mpoly;       /* indices */
221         const MLoop *mloop;       /* indices */
222         const MVert *mvert;       /* vertices & normals */
223         const float (*orco)[3];
224         float (*tangent)[4];    /* destination */
225         int numTessFaces;
226
227 #ifdef USE_LOOPTRI_DETECT_QUADS
228         /* map from 'fake' face index to looptri,
229          * quads will point to the first looptri of the quad */
230         const int    *face_as_quad_map;
231         int       num_face_as_quad_map;
232 #endif
233
234 } SGLSLMeshToTangent;
235
236 /* interface */
237 static int dm_ts_GetNumFaces(const SMikkTSpaceContext *pContext)
238 {
239         SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
240
241 #ifdef USE_LOOPTRI_DETECT_QUADS
242         return pMesh->num_face_as_quad_map;
243 #else
244         return pMesh->numTessFaces;
245 #endif
246 }
247
248 static int dm_ts_GetNumVertsOfFace(const SMikkTSpaceContext *pContext, const int face_num)
249 {
250 #ifdef USE_LOOPTRI_DETECT_QUADS
251         SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
252         if (pMesh->face_as_quad_map) {
253                 const MLoopTri *lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
254                 const MPoly *mp = &pMesh->mpoly[lt->poly];
255                 if (mp->totloop == 4) {
256                         return 4;
257                 }
258         }
259         return 3;
260 #else
261         UNUSED_VARS(pContext, face_num);
262         return 3;
263 #endif
264 }
265
266 static void dm_ts_GetPosition(
267         const SMikkTSpaceContext *pContext, float r_co[3],
268         const int face_num, const int vert_index)
269 {
270         //assert(vert_index >= 0 && vert_index < 4);
271         SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
272         const MLoopTri *lt;
273         uint loop_index;
274         const float *co;
275
276 #ifdef USE_LOOPTRI_DETECT_QUADS
277         if (pMesh->face_as_quad_map) {
278                 lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
279                 const MPoly *mp = &pMesh->mpoly[lt->poly];
280                 if (mp->totloop == 4) {
281                         loop_index = (uint)(mp->loopstart + vert_index);
282                         goto finally;
283                 }
284                 /* fall through to regular triangle */
285         }
286         else {
287                 lt = &pMesh->looptri[face_num];
288         }
289 #else
290         lt = &pMesh->looptri[face_num];
291 #endif
292         loop_index = lt->tri[vert_index];
293
294 finally:
295         co = pMesh->mvert[pMesh->mloop[loop_index].v].co;
296         copy_v3_v3(r_co, co);
297 }
298
299 static void dm_ts_GetTextureCoordinate(
300         const SMikkTSpaceContext *pContext, float r_uv[2],
301         const int face_num, const int vert_index)
302 {
303         //assert(vert_index >= 0 && vert_index < 4);
304         SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
305         const MLoopTri *lt;
306         uint loop_index;
307
308 #ifdef USE_LOOPTRI_DETECT_QUADS
309         if (pMesh->face_as_quad_map) {
310                 lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
311                 const MPoly *mp = &pMesh->mpoly[lt->poly];
312                 if (mp->totloop == 4) {
313                         loop_index = (uint)(mp->loopstart + vert_index);
314                         goto finally;
315                 }
316                 /* fall through to regular triangle */
317         }
318         else {
319                 lt = &pMesh->looptri[face_num];
320         }
321 #else
322         lt = &pMesh->looptri[face_num];
323 #endif
324         loop_index = lt->tri[vert_index];
325
326 finally:
327         if (pMesh->mloopuv != NULL) {
328                 const float *uv = pMesh->mloopuv[loop_index].uv;
329                 copy_v2_v2(r_uv, uv);
330         }
331         else {
332                 const float *orco = pMesh->orco[pMesh->mloop[loop_index].v];
333                 map_to_sphere(&r_uv[0], &r_uv[1], orco[0], orco[1], orco[2]);
334         }
335 }
336
337 static void dm_ts_GetNormal(
338         const SMikkTSpaceContext *pContext, float r_no[3],
339         const int face_num, const int vert_index)
340 {
341         //assert(vert_index >= 0 && vert_index < 4);
342         SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
343         const MLoopTri *lt;
344         uint loop_index;
345
346 #ifdef USE_LOOPTRI_DETECT_QUADS
347         if (pMesh->face_as_quad_map) {
348                 lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
349                 const MPoly *mp = &pMesh->mpoly[lt->poly];
350                 if (mp->totloop == 4) {
351                         loop_index = (uint)(mp->loopstart + vert_index);
352                         goto finally;
353                 }
354                 /* fall through to regular triangle */
355         }
356         else {
357                 lt = &pMesh->looptri[face_num];
358         }
359 #else
360         lt = &pMesh->looptri[face_num];
361 #endif
362         loop_index = lt->tri[vert_index];
363
364 finally:
365         if (pMesh->precomputedLoopNormals) {
366                 copy_v3_v3(r_no, pMesh->precomputedLoopNormals[loop_index]);
367         }
368         else if ((pMesh->mpoly[lt->poly].flag & ME_SMOOTH) == 0) {  /* flat */
369                 if (pMesh->precomputedFaceNormals) {
370                         copy_v3_v3(r_no, pMesh->precomputedFaceNormals[lt->poly]);
371                 }
372                 else {
373 #ifdef USE_LOOPTRI_DETECT_QUADS
374                         const MPoly *mp = &pMesh->mpoly[lt->poly];
375                         if (mp->totloop == 4) {
376                                 normal_quad_v3(
377                                         r_no,
378                                         pMesh->mvert[pMesh->mloop[mp->loopstart + 0].v].co,
379                                         pMesh->mvert[pMesh->mloop[mp->loopstart + 1].v].co,
380                                         pMesh->mvert[pMesh->mloop[mp->loopstart + 2].v].co,
381                                         pMesh->mvert[pMesh->mloop[mp->loopstart + 3].v].co);
382                         }
383                         else
384 #endif
385                         {
386                                 normal_tri_v3(
387                                         r_no,
388                                         pMesh->mvert[pMesh->mloop[lt->tri[0]].v].co,
389                                         pMesh->mvert[pMesh->mloop[lt->tri[1]].v].co,
390                                         pMesh->mvert[pMesh->mloop[lt->tri[2]].v].co);
391                         }
392                 }
393         }
394         else {
395                 const short *no = pMesh->mvert[pMesh->mloop[loop_index].v].no;
396                 normal_short_to_float_v3(r_no, no);
397         }
398 }
399
400 static void dm_ts_SetTSpace(
401         const SMikkTSpaceContext *pContext, const float fvTangent[3], const float fSign,
402         const int face_num, const int vert_index)
403 {
404         //assert(vert_index >= 0 && vert_index < 4);
405         SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
406         const MLoopTri *lt;
407         uint loop_index;
408
409 #ifdef USE_LOOPTRI_DETECT_QUADS
410         if (pMesh->face_as_quad_map) {
411                 lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
412                 const MPoly *mp = &pMesh->mpoly[lt->poly];
413                 if (mp->totloop == 4) {
414                         loop_index = (uint)(mp->loopstart + vert_index);
415                         goto finally;
416                 }
417                 /* fall through to regular triangle */
418         }
419         else {
420                 lt = &pMesh->looptri[face_num];
421         }
422 #else
423         lt = &pMesh->looptri[face_num];
424 #endif
425         loop_index = lt->tri[vert_index];
426
427         float *pRes;
428
429 finally:
430         pRes = pMesh->tangent[loop_index];
431         copy_v3_v3(pRes, fvTangent);
432         pRes[3] = fSign;
433 }
434
435 static void DM_calc_loop_tangents_thread(TaskPool * __restrict UNUSED(pool), void *taskdata, int UNUSED(threadid))
436 {
437         struct SGLSLMeshToTangent *mesh2tangent = taskdata;
438         /* new computation method */
439         {
440                 SMikkTSpaceContext sContext = {NULL};
441                 SMikkTSpaceInterface sInterface = {NULL};
442
443                 sContext.m_pUserData = mesh2tangent;
444                 sContext.m_pInterface = &sInterface;
445                 sInterface.m_getNumFaces = dm_ts_GetNumFaces;
446                 sInterface.m_getNumVerticesOfFace = dm_ts_GetNumVertsOfFace;
447                 sInterface.m_getPosition = dm_ts_GetPosition;
448                 sInterface.m_getTexCoord = dm_ts_GetTextureCoordinate;
449                 sInterface.m_getNormal = dm_ts_GetNormal;
450                 sInterface.m_setTSpaceBasic = dm_ts_SetTSpace;
451
452                 /* 0 if failed */
453                 genTangSpaceDefault(&sContext);
454         }
455 }
456
457 void BKE_mesh_add_loop_tangent_named_layer_for_uv(
458         CustomData *uv_data, CustomData *tan_data, int numLoopData,
459         const char *layer_name)
460 {
461         if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
462             CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
463         {
464                 CustomData_add_layer_named(
465                         tan_data, CD_TANGENT, CD_CALLOC, NULL,
466                         numLoopData, layer_name);
467         }
468 }
469
470 /**
471  * Here we get some useful information such as active uv layer name and search if it is already in tangent_names.
472  * Also, we calculate tangent_mask that works as a descriptor of tangents state.
473  * If tangent_mask has changed, then recalculate tangents.
474  */
475 void BKE_mesh_calc_loop_tangent_step_0(
476         const CustomData *loopData, bool calc_active_tangent,
477         const char (*tangent_names)[MAX_NAME], int tangent_names_count,
478         bool *rcalc_act, bool *rcalc_ren, int *ract_uv_n, int *rren_uv_n,
479         char *ract_uv_name, char *rren_uv_name, short *rtangent_mask)
480 {
481         /* Active uv in viewport */
482         int layer_index = CustomData_get_layer_index(loopData, CD_MLOOPUV);
483         *ract_uv_n = CustomData_get_active_layer(loopData, CD_MLOOPUV);
484         ract_uv_name[0] = 0;
485         if (*ract_uv_n != -1) {
486                 strcpy(ract_uv_name, loopData->layers[*ract_uv_n + layer_index].name);
487         }
488
489         /* Active tangent in render */
490         *rren_uv_n = CustomData_get_render_layer(loopData, CD_MLOOPUV);
491         rren_uv_name[0] = 0;
492         if (*rren_uv_n != -1) {
493                 strcpy(rren_uv_name, loopData->layers[*rren_uv_n + layer_index].name);
494         }
495
496         /* If active tangent not in tangent_names we take it into account */
497         *rcalc_act = false;
498         *rcalc_ren = false;
499         for (int i = 0; i < tangent_names_count; i++) {
500                 if (tangent_names[i][0] == 0) {
501                         calc_active_tangent = true;
502                 }
503         }
504         if (calc_active_tangent) {
505                 *rcalc_act = true;
506                 *rcalc_ren = true;
507                 for (int i = 0; i < tangent_names_count; i++) {
508                         if (STREQ(ract_uv_name, tangent_names[i]))
509                                 *rcalc_act = false;
510                         if (STREQ(rren_uv_name, tangent_names[i]))
511                                 *rcalc_ren = false;
512                 }
513         }
514         *rtangent_mask = 0;
515
516         const int uv_layer_num = CustomData_number_of_layers(loopData, CD_MLOOPUV);
517         for (int n = 0; n < uv_layer_num; n++) {
518                 const char *name = CustomData_get_layer_name(loopData, CD_MLOOPUV, n);
519                 bool add = false;
520                 for (int i = 0; i < tangent_names_count; i++) {
521                         if (tangent_names[i][0] && STREQ(tangent_names[i], name)) {
522                                 add = true;
523                                 break;
524                         }
525                 }
526                 if (!add && ((*rcalc_act && ract_uv_name[0] && STREQ(ract_uv_name, name)) ||
527                              (*rcalc_ren && rren_uv_name[0] && STREQ(rren_uv_name, name))))
528                 {
529                         add = true;
530                 }
531                 if (add)
532                         *rtangent_mask |= (short)(1 << n);
533         }
534
535         if (uv_layer_num == 0)
536                 *rtangent_mask |= DM_TANGENT_MASK_ORCO;
537 }
538
539 /**
540  * See: #BKE_editmesh_loop_tangent_calc (matching logic).
541  */
542 void BKE_mesh_calc_loop_tangent_ex(
543         const MVert *mvert,
544         const MPoly *mpoly, const uint mpoly_len,
545         const MLoop *mloop,
546         const MLoopTri *looptri,
547         const uint looptri_len,
548
549         CustomData *loopdata,
550         bool calc_active_tangent,
551         const char (*tangent_names)[MAX_NAME], int tangent_names_len,
552         const float (*poly_normals)[3],
553         const float (*loop_normals)[3],
554         const float (*vert_orco)[3],
555         /* result */
556         CustomData *loopdata_out,
557         const uint  loopdata_out_len,
558         short *tangent_mask_curr_p)
559 {
560         int act_uv_n = -1;
561         int ren_uv_n = -1;
562         bool calc_act = false;
563         bool calc_ren = false;
564         char act_uv_name[MAX_NAME];
565         char ren_uv_name[MAX_NAME];
566         short tangent_mask = 0;
567         short tangent_mask_curr = *tangent_mask_curr_p;
568
569         BKE_mesh_calc_loop_tangent_step_0(
570                 loopdata, calc_active_tangent, tangent_names, tangent_names_len,
571                 &calc_act, &calc_ren, &act_uv_n, &ren_uv_n, act_uv_name, ren_uv_name, &tangent_mask);
572         if ((tangent_mask_curr | tangent_mask) != tangent_mask_curr) {
573                 /* Check we have all the needed layers */
574                 /* Allocate needed tangent layers */
575                 for (int i = 0; i < tangent_names_len; i++)
576                         if (tangent_names[i][0])
577                                 BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, tangent_names[i]);
578                 if ((tangent_mask & DM_TANGENT_MASK_ORCO) && CustomData_get_named_layer_index(loopdata, CD_TANGENT, "") == -1)
579                             CustomData_add_layer_named(loopdata_out, CD_TANGENT, CD_CALLOC, NULL, (int)loopdata_out_len, "");
580                 if (calc_act && act_uv_name[0])
581                         BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, act_uv_name);
582                 if (calc_ren && ren_uv_name[0])
583                         BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, ren_uv_name);
584
585 #ifdef USE_LOOPTRI_DETECT_QUADS
586                 int num_face_as_quad_map;
587                 int *face_as_quad_map = NULL;
588
589                 /* map faces to quads */
590                 if (looptri_len != mpoly_len) {
591                         /* over alloc, since we dont know how many ngon or quads we have */
592
593                         /* map fake face index to looptri */
594                         face_as_quad_map = MEM_mallocN(sizeof(int) * looptri_len, __func__);
595                         int k, j;
596                         for (k = 0, j = 0; j < (int)looptri_len; k++, j++) {
597                                 face_as_quad_map[k] = j;
598                                 /* step over all quads */
599                                 if (mpoly[looptri[j].poly].totloop == 4) {
600                                         j++;  /* skips the nest looptri */
601                                 }
602                         }
603                         num_face_as_quad_map = k;
604                 }
605                 else {
606                         num_face_as_quad_map = (int)looptri_len;
607                 }
608 #endif
609
610                 /* Calculation */
611                 if (looptri_len != 0) {
612                         TaskScheduler *scheduler = BLI_task_scheduler_get();
613                         TaskPool *task_pool;
614                         task_pool = BLI_task_pool_create(scheduler, NULL);
615
616                         tangent_mask_curr = 0;
617                         /* Calculate tangent layers */
618                         SGLSLMeshToTangent data_array[MAX_MTFACE];
619                         const int tangent_layer_num = CustomData_number_of_layers(loopdata_out, CD_TANGENT);
620                         for (int n = 0; n < tangent_layer_num; n++) {
621                                 int index = CustomData_get_layer_index_n(loopdata_out, CD_TANGENT, n);
622                                 BLI_assert(n < MAX_MTFACE);
623                                 SGLSLMeshToTangent *mesh2tangent = &data_array[n];
624                                 mesh2tangent->numTessFaces = (int)looptri_len;
625 #ifdef USE_LOOPTRI_DETECT_QUADS
626                                 mesh2tangent->face_as_quad_map = face_as_quad_map;
627                                 mesh2tangent->num_face_as_quad_map = num_face_as_quad_map;
628 #endif
629                                 mesh2tangent->mvert = mvert;
630                                 mesh2tangent->mpoly = mpoly;
631                                 mesh2tangent->mloop = mloop;
632                                 mesh2tangent->looptri = looptri;
633                                 /* Note, we assume we do have tessellated loop normals at this point (in case it is object-enabled),
634                                  * have to check this is valid...
635                                  */
636                                 mesh2tangent->precomputedLoopNormals = loop_normals;
637                                 mesh2tangent->precomputedFaceNormals = poly_normals;
638
639                                 mesh2tangent->orco = NULL;
640                                 mesh2tangent->mloopuv = CustomData_get_layer_named(loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
641
642                                 /* Fill the resulting tangent_mask */
643                                 if (!mesh2tangent->mloopuv) {
644                                     mesh2tangent->orco = vert_orco;
645                                     if (!mesh2tangent->orco)
646                                             continue;
647
648                                     tangent_mask_curr |= DM_TANGENT_MASK_ORCO;
649                                 }
650                                 else {
651                                     int uv_ind = CustomData_get_named_layer_index(loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
652                                     int uv_start = CustomData_get_layer_index(loopdata, CD_MLOOPUV);
653                                     BLI_assert(uv_ind != -1 && uv_start != -1);
654                                     BLI_assert(uv_ind - uv_start < MAX_MTFACE);
655                                     tangent_mask_curr |= (short)(1 << (uv_ind - uv_start));
656                                 }
657
658                                 mesh2tangent->tangent = loopdata_out->layers[index].data;
659                                 BLI_task_pool_push(task_pool, DM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
660                         }
661
662                         BLI_assert(tangent_mask_curr == tangent_mask);
663                         BLI_task_pool_work_and_wait(task_pool);
664                         BLI_task_pool_free(task_pool);
665                 }
666                 else {
667                         tangent_mask_curr = tangent_mask;
668                 }
669 #ifdef USE_LOOPTRI_DETECT_QUADS
670                 if (face_as_quad_map) {
671                         MEM_freeN(face_as_quad_map);
672                 }
673 #undef USE_LOOPTRI_DETECT_QUADS
674
675 #endif
676
677                 *tangent_mask_curr_p = tangent_mask_curr;
678
679                 /* Update active layer index */
680                 int act_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, act_uv_n);
681                 if (act_uv_index != -1) {
682                     int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[act_uv_index].name);
683                     CustomData_set_layer_active_index(loopdata, CD_TANGENT, tan_index);
684                 }/* else tangent has been built from orco */
685
686                 /* Update render layer index */
687                 int ren_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, ren_uv_n);
688                 if (ren_uv_index != -1) {
689                     int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[ren_uv_index].name);
690                     CustomData_set_layer_render_index(loopdata, CD_TANGENT, tan_index);
691                 }/* else tangent has been built from orco */
692         }
693 }
694
695 void BKE_mesh_calc_loop_tangents(
696         Mesh *me_eval, bool calc_active_tangent,
697         const char (*tangent_names)[MAX_NAME], int tangent_names_len)
698 {
699         BKE_mesh_runtime_looptri_ensure(me_eval);
700
701         /* TODO(campbell): store in Mesh.runtime to avoid recalculation. */
702         short tangent_mask = 0;
703         BKE_mesh_calc_loop_tangent_ex(
704                 me_eval->mvert,
705                 me_eval->mpoly, (uint)me_eval->totpoly,
706                 me_eval->mloop,
707                 me_eval->runtime.looptris.array, (uint)me_eval->runtime.looptris.len,
708                 &me_eval->ldata,
709                 calc_active_tangent,
710                 tangent_names, tangent_names_len,
711                 CustomData_get_layer(&me_eval->pdata, CD_NORMAL),
712                 CustomData_get_layer(&me_eval->ldata, CD_NORMAL),
713                 CustomData_get_layer(&me_eval->vdata, CD_ORCO),  /* may be NULL */
714                 /* result */
715                 &me_eval->ldata, (uint)me_eval->totloop,
716                 &tangent_mask);
717 }
718
719 /** \} */