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