ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 566 insertions, 509 deletions

diff --git a/source/blender/blenkernel/intern/mesh_tangent.c b/source/blender/blenkernel/intern/mesh_tangent.c
index 0bb399630b8..e6c4e9ff4be 100644
--- a/source/blender/blenkernel/intern/mesh_tangent.c
+++ b/source/blender/blenkernel/intern/mesh_tangent.c
@@ -45,7 +45,6 @@
 #include "atomic_ops.h"
 #include "mikktspace.h"
 
-
 /* -------------------------------------------------------------------- */
 /** \name Mesh Tangent Calculations (Single Layer)
  * \{ */
@@ -54,57 +53,66 @@
 
 /* User data. */
 typedef struct {
-	const MPoly *mpolys;   /* faces */
-	const MLoop *mloops;   /* faces's vertices */
-	const MVert *mverts;   /* vertices */
-	const MLoopUV *luvs;   /* texture coordinates */
-	float (*lnors)[3];     /* loops' normals */
-	float (*tangents)[4];  /* output tangents */
-	int num_polys;         /* number of polygons */
+  const MPoly *mpolys;  /* faces */
+  const MLoop *mloops;  /* faces's vertices */
+  const MVert *mverts;  /* vertices */
+  const MLoopUV *luvs;  /* texture coordinates */
+  float (*lnors)[3];    /* loops' normals */
+  float (*tangents)[4]; /* output tangents */
+  int num_polys;        /* number of polygons */
 } BKEMeshToTangent;
 
 /* Mikktspace's API */
 static int get_num_faces(const SMikkTSpaceContext *pContext)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	return p_mesh->num_polys;
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  return p_mesh->num_polys;
 }
 
 static int get_num_verts_of_face(const SMikkTSpaceContext *pContext, const int face_idx)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	return p_mesh->mpolys[face_idx].totloop;
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  return p_mesh->mpolys[face_idx].totloop;
 }
 
-static void get_position(const SMikkTSpaceContext *pContext, float r_co[3], const int face_idx, const int vert_idx)
+static void get_position(const SMikkTSpaceContext *pContext,
+                         float r_co[3],
+                         const int face_idx,
+                         const int vert_idx)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	const int loop_idx = p_mesh->mpolys[face_idx].loopstart + vert_idx;
-	copy_v3_v3(r_co, p_mesh->mverts[p_mesh->mloops[loop_idx].v].co);
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  const int loop_idx = p_mesh->mpolys[face_idx].loopstart + vert_idx;
+  copy_v3_v3(r_co, p_mesh->mverts[p_mesh->mloops[loop_idx].v].co);
 }
 
-static void get_texture_coordinate(
-        const SMikkTSpaceContext *pContext, float r_uv[2], const int face_idx,
-        const int vert_idx)
+static void get_texture_coordinate(const SMikkTSpaceContext *pContext,
+                                   float r_uv[2],
+                                   const int face_idx,
+                                   const int vert_idx)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	copy_v2_v2(r_uv, p_mesh->luvs[p_mesh->mpolys[face_idx].loopstart + vert_idx].uv);
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  copy_v2_v2(r_uv, p_mesh->luvs[p_mesh->mpolys[face_idx].loopstart + vert_idx].uv);
 }
 
-static void get_normal(const SMikkTSpaceContext *pContext, float r_no[3], const int face_idx, const int vert_idx)
+static void get_normal(const SMikkTSpaceContext *pContext,
+                       float r_no[3],
+                       const int face_idx,
+                       const int vert_idx)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	copy_v3_v3(r_no, p_mesh->lnors[p_mesh->mpolys[face_idx].loopstart + vert_idx]);
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  copy_v3_v3(r_no, p_mesh->lnors[p_mesh->mpolys[face_idx].loopstart + vert_idx]);
 }
 
-static void set_tspace(
-        const SMikkTSpaceContext *pContext, const float fv_tangent[3], const float face_sign,
-        const int face_idx, const int vert_idx)
+static void set_tspace(const SMikkTSpaceContext *pContext,
+                       const float fv_tangent[3],
+                       const float face_sign,
+                       const int face_idx,
+                       const int vert_idx)
 {
-	BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
-	float *p_res = p_mesh->tangents[p_mesh->mpolys[face_idx].loopstart + vert_idx];
-	copy_v3_v3(p_res, fv_tangent);
-	p_res[3] = face_sign;
+  BKEMeshToTangent *p_mesh = (BKEMeshToTangent *)pContext->m_pUserData;
+  float *p_res = p_mesh->tangents[p_mesh->mpolys[face_idx].loopstart + vert_idx];
+  copy_v3_v3(p_res, fv_tangent);
+  p_res[3] = face_sign;
 }
 
 /**
@@ -112,49 +120,55 @@ static void set_tspace(
  * split normals can be used to recreate the full tangent space.
  * Note: * The mesh should be made of only tris and quads!
  */
-void BKE_mesh_calc_loop_tangent_single_ex(
-        const MVert *mverts, const int UNUSED(numVerts), const MLoop *mloops,
-        float (*r_looptangent)[4], float (*loopnors)[3], const MLoopUV *loopuvs,
-        const int UNUSED(numLoops), const MPoly *mpolys, const int numPolys,
-        ReportList *reports)
+void BKE_mesh_calc_loop_tangent_single_ex(const MVert *mverts,
+                                          const int UNUSED(numVerts),
+                                          const MLoop *mloops,
+                                          float (*r_looptangent)[4],
+                                          float (*loopnors)[3],
+                                          const MLoopUV *loopuvs,
+                                          const int UNUSED(numLoops),
+                                          const MPoly *mpolys,
+                                          const int numPolys,
+                                          ReportList *reports)
 {
-	BKEMeshToTangent mesh_to_tangent = {NULL};
-	SMikkTSpaceContext s_context = {NULL};
-	SMikkTSpaceInterface s_interface = {NULL};
-
-	const MPoly *mp;
-	int mp_index;
-
-	/* First check we do have a tris/quads only mesh. */
-	for (mp = mpolys, mp_index = 0; mp_index < numPolys; mp++, mp_index++) {
-		if (mp->totloop > 4) {
-			BKE_report(reports, RPT_ERROR, "Tangent space can only be computed for tris/quads, aborting");
-			return;
-		}
-	}
-
-	/* Compute Mikktspace's tangent normals. */
-	mesh_to_tangent.mpolys = mpolys;
-	mesh_to_tangent.mloops = mloops;
-	mesh_to_tangent.mverts = mverts;
-	mesh_to_tangent.luvs = loopuvs;
-	mesh_to_tangent.lnors = loopnors;
-	mesh_to_tangent.tangents = r_looptangent;
-	mesh_to_tangent.num_polys = numPolys;
-
-	s_context.m_pUserData = &mesh_to_tangent;
-	s_context.m_pInterface = &s_interface;
-	s_interface.m_getNumFaces = get_num_faces;
-	s_interface.m_getNumVerticesOfFace = get_num_verts_of_face;
-	s_interface.m_getPosition = get_position;
-	s_interface.m_getTexCoord = get_texture_coordinate;
-	s_interface.m_getNormal = get_normal;
-	s_interface.m_setTSpaceBasic = set_tspace;
-
-	/* 0 if failed */
-	if (genTangSpaceDefault(&s_context) == false) {
-		BKE_report(reports, RPT_ERROR, "Mikktspace failed to generate tangents for this mesh!");
-	}
+  BKEMeshToTangent mesh_to_tangent = {NULL};
+  SMikkTSpaceContext s_context = {NULL};
+  SMikkTSpaceInterface s_interface = {NULL};
+
+  const MPoly *mp;
+  int mp_index;
+
+  /* First check we do have a tris/quads only mesh. */
+  for (mp = mpolys, mp_index = 0; mp_index < numPolys; mp++, mp_index++) {
+    if (mp->totloop > 4) {
+      BKE_report(
+          reports, RPT_ERROR, "Tangent space can only be computed for tris/quads, aborting");
+      return;
+    }
+  }
+
+  /* Compute Mikktspace's tangent normals. */
+  mesh_to_tangent.mpolys = mpolys;
+  mesh_to_tangent.mloops = mloops;
+  mesh_to_tangent.mverts = mverts;
+  mesh_to_tangent.luvs = loopuvs;
+  mesh_to_tangent.lnors = loopnors;
+  mesh_to_tangent.tangents = r_looptangent;
+  mesh_to_tangent.num_polys = numPolys;
+
+  s_context.m_pUserData = &mesh_to_tangent;
+  s_context.m_pInterface = &s_interface;
+  s_interface.m_getNumFaces = get_num_faces;
+  s_interface.m_getNumVerticesOfFace = get_num_verts_of_face;
+  s_interface.m_getPosition = get_position;
+  s_interface.m_getTexCoord = get_texture_coordinate;
+  s_interface.m_getNormal = get_normal;
+  s_interface.m_setTSpaceBasic = set_tspace;
+
+  /* 0 if failed */
+  if (genTangSpaceDefault(&s_context) == false) {
+    BKE_report(reports, RPT_ERROR, "Mikktspace failed to generate tangents for this mesh!");
+  }
 }
 
 /**
@@ -163,62 +177,74 @@ void BKE_mesh_calc_loop_tangent_single_ex(
  * - There must be a valid loop's CD_NORMALS available.
  * - The mesh should be made of only tris and quads!
  */
-void BKE_mesh_calc_loop_tangent_single(Mesh *mesh, const char *uvmap, float (*r_looptangents)[4], ReportList *reports)
+void BKE_mesh_calc_loop_tangent_single(Mesh *mesh,
+                                       const char *uvmap,
+                                       float (*r_looptangents)[4],
+                                       ReportList *reports)
 {
-	MLoopUV *loopuvs;
-	float (*loopnors)[3];
-
-	/* Check we have valid texture coordinates first! */
-	if (uvmap) {
-		loopuvs = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvmap);
-	}
-	else {
-		loopuvs = CustomData_get_layer(&mesh->ldata, CD_MLOOPUV);
-	}
-	if (!loopuvs) {
-		BKE_reportf(reports, RPT_ERROR, "Tangent space computation needs an UVMap, \"%s\" not found, aborting", uvmap);
-		return;
-	}
-
-	loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
-	if (!loopnors) {
-		BKE_report(reports, RPT_ERROR, "Tangent space computation needs loop normals, none found, aborting");
-		return;
-	}
-
-	BKE_mesh_calc_loop_tangent_single_ex(
-	        mesh->mvert, mesh->totvert, mesh->mloop, r_looptangents,
-	        loopnors, loopuvs, mesh->totloop, mesh->mpoly, mesh->totpoly, reports);
+  MLoopUV *loopuvs;
+  float(*loopnors)[3];
+
+  /* Check we have valid texture coordinates first! */
+  if (uvmap) {
+    loopuvs = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvmap);
+  }
+  else {
+    loopuvs = CustomData_get_layer(&mesh->ldata, CD_MLOOPUV);
+  }
+  if (!loopuvs) {
+    BKE_reportf(reports,
+                RPT_ERROR,
+                "Tangent space computation needs an UVMap, \"%s\" not found, aborting",
+                uvmap);
+    return;
+  }
+
+  loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
+  if (!loopnors) {
+    BKE_report(
+        reports, RPT_ERROR, "Tangent space computation needs loop normals, none found, aborting");
+    return;
+  }
+
+  BKE_mesh_calc_loop_tangent_single_ex(mesh->mvert,
+                                       mesh->totvert,
+                                       mesh->mloop,
+                                       r_looptangents,
+                                       loopnors,
+                                       loopuvs,
+                                       mesh->totloop,
+                                       mesh->mpoly,
+                                       mesh->totpoly,
+                                       reports);
 }
 
 /** \} */
 
-
 /* -------------------------------------------------------------------- */
 /** \name Mesh Tangent Calculations (All Layers)
  * \{ */
 
-
 /* Necessary complexity to handle looptri's as quads for correct tangents */
 #define USE_LOOPTRI_DETECT_QUADS
 
 typedef struct {
-	const float (*precomputedFaceNormals)[3];
-	const float (*precomputedLoopNormals)[3];
-	const MLoopTri *looptri;
-	MLoopUV *mloopuv;   /* texture coordinates */
-	const MPoly *mpoly;       /* indices */
-	const MLoop *mloop;       /* indices */
-	const MVert *mvert;       /* vertices & normals */
-	const float (*orco)[3];
-	float (*tangent)[4];    /* destination */
-	int numTessFaces;
+  const float (*precomputedFaceNormals)[3];
+  const float (*precomputedLoopNormals)[3];
+  const MLoopTri *looptri;
+  MLoopUV *mloopuv;   /* texture coordinates */
+  const MPoly *mpoly; /* indices */
+  const MLoop *mloop; /* indices */
+  const MVert *mvert; /* vertices & normals */
+  const float (*orco)[3];
+  float (*tangent)[4]; /* destination */
+  int numTessFaces;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	/* map from 'fake' face index to looptri,
-	 * quads will point to the first looptri of the quad */
-	const int    *face_as_quad_map;
-	int       num_face_as_quad_map;
+  /* map from 'fake' face index to looptri,
+   * quads will point to the first looptri of the quad */
+  const int *face_as_quad_map;
+  int num_face_as_quad_map;
 #endif
 
 } SGLSLMeshToTangent;
@@ -226,235 +252,238 @@ typedef struct {
 /* interface */
 static int dm_ts_GetNumFaces(const SMikkTSpaceContext *pContext)
 {
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
+  SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	return pMesh->num_face_as_quad_map;
+  return pMesh->num_face_as_quad_map;
 #else
-	return pMesh->numTessFaces;
+  return pMesh->numTessFaces;
 #endif
 }
 
 static int dm_ts_GetNumVertsOfFace(const SMikkTSpaceContext *pContext, const int face_num)
 {
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-	if (pMesh->face_as_quad_map) {
-		const MLoopTri *lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
-		const MPoly *mp = &pMesh->mpoly[lt->poly];
-		if (mp->totloop == 4) {
-			return 4;
-		}
-	}
-	return 3;
+  SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
+  if (pMesh->face_as_quad_map) {
+    const MLoopTri *lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
+    const MPoly *mp = &pMesh->mpoly[lt->poly];
+    if (mp->totloop == 4) {
+      return 4;
+    }
+  }
+  return 3;
 #else
-	UNUSED_VARS(pContext, face_num);
-	return 3;
+  UNUSED_VARS(pContext, face_num);
+  return 3;
 #endif
 }
 
-static void dm_ts_GetPosition(
-        const SMikkTSpaceContext *pContext, float r_co[3],
-        const int face_num, const int vert_index)
+static void dm_ts_GetPosition(const SMikkTSpaceContext *pContext,
+                              float r_co[3],
+                              const int face_num,
+                              const int vert_index)
 {
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-	const MLoopTri *lt;
-	uint loop_index;
-	const float *co;
+  //assert(vert_index >= 0 && vert_index < 4);
+  SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
+  const MLoopTri *lt;
+  uint loop_index;
+  const float *co;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	if (pMesh->face_as_quad_map) {
-		lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
-		const MPoly *mp = &pMesh->mpoly[lt->poly];
-		if (mp->totloop == 4) {
-			loop_index = (uint)(mp->loopstart + vert_index);
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
+  if (pMesh->face_as_quad_map) {
+    lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
+    const MPoly *mp = &pMesh->mpoly[lt->poly];
+    if (mp->totloop == 4) {
+      loop_index = (uint)(mp->loopstart + vert_index);
+      goto finally;
+    }
+    /* fall through to regular triangle */
+  }
+  else {
+    lt = &pMesh->looptri[face_num];
+  }
 #else
-	lt = &pMesh->looptri[face_num];
+  lt = &pMesh->looptri[face_num];
 #endif
-	loop_index = lt->tri[vert_index];
+  loop_index = lt->tri[vert_index];
 
 finally:
-	co = pMesh->mvert[pMesh->mloop[loop_index].v].co;
-	copy_v3_v3(r_co, co);
+  co = pMesh->mvert[pMesh->mloop[loop_index].v].co;
+  copy_v3_v3(r_co, co);
 }
 
-static void dm_ts_GetTextureCoordinate(
-        const SMikkTSpaceContext *pContext, float r_uv[2],
-        const int face_num, const int vert_index)
+static void dm_ts_GetTextureCoordinate(const SMikkTSpaceContext *pContext,
+                                       float r_uv[2],
+                                       const int face_num,
+                                       const int vert_index)
 {
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-	const MLoopTri *lt;
-	uint loop_index;
+  //assert(vert_index >= 0 && vert_index < 4);
+  SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
+  const MLoopTri *lt;
+  uint loop_index;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	if (pMesh->face_as_quad_map) {
-		lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
-		const MPoly *mp = &pMesh->mpoly[lt->poly];
-		if (mp->totloop == 4) {
-			loop_index = (uint)(mp->loopstart + vert_index);
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
+  if (pMesh->face_as_quad_map) {
+    lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
+    const MPoly *mp = &pMesh->mpoly[lt->poly];
+    if (mp->totloop == 4) {
+      loop_index = (uint)(mp->loopstart + vert_index);
+      goto finally;
+    }
+    /* fall through to regular triangle */
+  }
+  else {
+    lt = &pMesh->looptri[face_num];
+  }
 #else
-	lt = &pMesh->looptri[face_num];
+  lt = &pMesh->looptri[face_num];
 #endif
-	loop_index = lt->tri[vert_index];
+  loop_index = lt->tri[vert_index];
 
 finally:
-	if (pMesh->mloopuv != NULL) {
-		const float *uv = pMesh->mloopuv[loop_index].uv;
-		copy_v2_v2(r_uv, uv);
-	}
-	else {
-		const float *orco = pMesh->orco[pMesh->mloop[loop_index].v];
-		map_to_sphere(&r_uv[0], &r_uv[1], orco[0], orco[1], orco[2]);
-	}
+  if (pMesh->mloopuv != NULL) {
+    const float *uv = pMesh->mloopuv[loop_index].uv;
+    copy_v2_v2(r_uv, uv);
+  }
+  else {
+    const float *orco = pMesh->orco[pMesh->mloop[loop_index].v];
+    map_to_sphere(&r_uv[0], &r_uv[1], orco[0], orco[1], orco[2]);
+  }
 }
 
-static void dm_ts_GetNormal(
-        const SMikkTSpaceContext *pContext, float r_no[3],
-        const int face_num, const int vert_index)
+static void dm_ts_GetNormal(const SMikkTSpaceContext *pContext,
+                            float r_no[3],
+                            const int face_num,
+                            const int vert_index)
 {
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
-	const MLoopTri *lt;
-	uint loop_index;
+  //assert(vert_index >= 0 && vert_index < 4);
+  SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *)pContext->m_pUserData;
+  const MLoopTri *lt;
+  uint loop_index;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	if (pMesh->face_as_quad_map) {
-		lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
-		const MPoly *mp = &pMesh->mpoly[lt->poly];
-		if (mp->totloop == 4) {
-			loop_index = (uint)(mp->loopstart + vert_index);
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
+  if (pMesh->face_as_quad_map) {
+    lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
+    const MPoly *mp = &pMesh->mpoly[lt->poly];
+    if (mp->totloop == 4) {
+      loop_index = (uint)(mp->loopstart + vert_index);
+      goto finally;
+    }
+    /* fall through to regular triangle */
+  }
+  else {
+    lt = &pMesh->looptri[face_num];
+  }
 #else
-	lt = &pMesh->looptri[face_num];
+  lt = &pMesh->looptri[face_num];
 #endif
-	loop_index = lt->tri[vert_index];
+  loop_index = lt->tri[vert_index];
 
 finally:
-	if (pMesh->precomputedLoopNormals) {
-		copy_v3_v3(r_no, pMesh->precomputedLoopNormals[loop_index]);
-	}
-	else if ((pMesh->mpoly[lt->poly].flag & ME_SMOOTH) == 0) {  /* flat */
-		if (pMesh->precomputedFaceNormals) {
-			copy_v3_v3(r_no, pMesh->precomputedFaceNormals[lt->poly]);
-		}
-		else {
+  if (pMesh->precomputedLoopNormals) {
+    copy_v3_v3(r_no, pMesh->precomputedLoopNormals[loop_index]);
+  }
+  else if ((pMesh->mpoly[lt->poly].flag & ME_SMOOTH) == 0) { /* flat */
+    if (pMesh->precomputedFaceNormals) {
+      copy_v3_v3(r_no, pMesh->precomputedFaceNormals[lt->poly]);
+    }
+    else {
 #ifdef USE_LOOPTRI_DETECT_QUADS
-			const MPoly *mp = &pMesh->mpoly[lt->poly];
-			if (mp->totloop == 4) {
-				normal_quad_v3(
-				        r_no,
-				        pMesh->mvert[pMesh->mloop[mp->loopstart + 0].v].co,
-				        pMesh->mvert[pMesh->mloop[mp->loopstart + 1].v].co,
-				        pMesh->mvert[pMesh->mloop[mp->loopstart + 2].v].co,
-				        pMesh->mvert[pMesh->mloop[mp->loopstart + 3].v].co);
-			}
-			else
+      const MPoly *mp = &pMesh->mpoly[lt->poly];
+      if (mp->totloop == 4) {
+        normal_quad_v3(r_no,
+                       pMesh->mvert[pMesh->mloop[mp->loopstart + 0].v].co,
+                       pMesh->mvert[pMesh->mloop[mp->loopstart + 1].v].co,
+                       pMesh->mvert[pMesh->mloop[mp->loopstart + 2].v].co,
+                       pMesh->mvert[pMesh->mloop[mp->loopstart + 3].v].co);
+      }
+      else
 #endif
-			{
-				normal_tri_v3(
-				        r_no,
-				        pMesh->mvert[pMesh->mloop[lt->tri[0]].v].co,
-				        pMesh->mvert[pMesh->mloop[lt->tri[1]].v].co,
-				        pMesh->mvert[pMesh->mloop[lt->tri[2]].v].co);
-			}
-		}
-	}
-	else {
-		const short *no = pMesh->mvert[pMesh->mloop[loop_index].v].no;
-		normal_short_to_float_v3(r_no, no);
-	}
+      {
+        normal_tri_v3(r_no,
+                      pMesh->mvert[pMesh->mloop[lt->tri[0]].v].co,
+                      pMesh->mvert[pMesh->mloop[lt->tri[1]].v].co,
+                      pMesh->mvert[pMesh->mloop[lt->tri[2]].v].co);
+      }
+    }
+  }
+  else {
+    const short *no = pMesh->mvert[pMesh->mloop[loop_index].v].no;
+    normal_short_to_float_v3(r_no, no);
+  }
 }
 
-static void dm_ts_SetTSpace(
-        const SMikkTSpaceContext *pContext, const float fvTangent[3], const float fSign,
-        const int face_num, const int vert_index)
+static void dm_ts_SetTSpace(const SMikkTSpaceContext *pContext,
+                            const float fvTangent[3],
+                            const float fSign,
+                            const int face_num,
+                            const int vert_index)
 {
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
-	const MLoopTri *lt;
-	uint loop_index;
+  //assert(vert_index >= 0 && vert_index < 4);
+  SGLSLMeshToTangent *pMesh = (SGLSLMeshToTangent *)pContext->m_pUserData;
+  const MLoopTri *lt;
+  uint loop_index;
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-	if (pMesh->face_as_quad_map) {
-		lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
-		const MPoly *mp = &pMesh->mpoly[lt->poly];
-		if (mp->totloop == 4) {
-			loop_index = (uint)(mp->loopstart + vert_index);
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
+  if (pMesh->face_as_quad_map) {
+    lt = &pMesh->looptri[pMesh->face_as_quad_map[face_num]];
+    const MPoly *mp = &pMesh->mpoly[lt->poly];
+    if (mp->totloop == 4) {
+      loop_index = (uint)(mp->loopstart + vert_index);
+      goto finally;
+    }
+    /* fall through to regular triangle */
+  }
+  else {
+    lt = &pMesh->looptri[face_num];
+  }
 #else
-	lt = &pMesh->looptri[face_num];
+  lt = &pMesh->looptri[face_num];
 #endif
-	loop_index = lt->tri[vert_index];
+  loop_index = lt->tri[vert_index];
 
-	float *pRes;
+  float *pRes;
 
 finally:
-	pRes = pMesh->tangent[loop_index];
-	copy_v3_v3(pRes, fvTangent);
-	pRes[3] = fSign;
+  pRes = pMesh->tangent[loop_index];
+  copy_v3_v3(pRes, fvTangent);
+  pRes[3] = fSign;
 }
 
-static void DM_calc_loop_tangents_thread(TaskPool * __restrict UNUSED(pool), void *taskdata, int UNUSED(threadid))
+static void DM_calc_loop_tangents_thread(TaskPool *__restrict UNUSED(pool),
+                                         void *taskdata,
+                                         int UNUSED(threadid))
 {
-	struct SGLSLMeshToTangent *mesh2tangent = taskdata;
-	/* new computation method */
-	{
-		SMikkTSpaceContext sContext = {NULL};
-		SMikkTSpaceInterface sInterface = {NULL};
-
-		sContext.m_pUserData = mesh2tangent;
-		sContext.m_pInterface = &sInterface;
-		sInterface.m_getNumFaces = dm_ts_GetNumFaces;
-		sInterface.m_getNumVerticesOfFace = dm_ts_GetNumVertsOfFace;
-		sInterface.m_getPosition = dm_ts_GetPosition;
-		sInterface.m_getTexCoord = dm_ts_GetTextureCoordinate;
-		sInterface.m_getNormal = dm_ts_GetNormal;
-		sInterface.m_setTSpaceBasic = dm_ts_SetTSpace;
-
-		/* 0 if failed */
-		genTangSpaceDefault(&sContext);
-	}
+  struct SGLSLMeshToTangent *mesh2tangent = taskdata;
+  /* new computation method */
+  {
+    SMikkTSpaceContext sContext = {NULL};
+    SMikkTSpaceInterface sInterface = {NULL};
+
+    sContext.m_pUserData = mesh2tangent;
+    sContext.m_pInterface = &sInterface;
+    sInterface.m_getNumFaces = dm_ts_GetNumFaces;
+    sInterface.m_getNumVerticesOfFace = dm_ts_GetNumVertsOfFace;
+    sInterface.m_getPosition = dm_ts_GetPosition;
+    sInterface.m_getTexCoord = dm_ts_GetTextureCoordinate;
+    sInterface.m_getNormal = dm_ts_GetNormal;
+    sInterface.m_setTSpaceBasic = dm_ts_SetTSpace;
+
+    /* 0 if failed */
+    genTangSpaceDefault(&sContext);
+  }
 }
 
-void BKE_mesh_add_loop_tangent_named_layer_for_uv(
-        CustomData *uv_data, CustomData *tan_data, int numLoopData,
-        const char *layer_name)
+void BKE_mesh_add_loop_tangent_named_layer_for_uv(CustomData *uv_data,
+                                                  CustomData *tan_data,
+                                                  int numLoopData,
+                                                  const char *layer_name)
 {
-	if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
-	    CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
-	{
-		CustomData_add_layer_named(
-		        tan_data, CD_TANGENT, CD_CALLOC, NULL,
-		        numLoopData, layer_name);
-	}
+  if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
+      CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1) {
+    CustomData_add_layer_named(tan_data, CD_TANGENT, CD_CALLOC, NULL, numLoopData, layer_name);
+  }
 }
 
 /**
@@ -462,248 +491,276 @@ void BKE_mesh_add_loop_tangent_named_layer_for_uv(
  * Also, we calculate tangent_mask that works as a descriptor of tangents state.
  * If tangent_mask has changed, then recalculate tangents.
  */
-void BKE_mesh_calc_loop_tangent_step_0(
-        const CustomData *loopData, bool calc_active_tangent,
-        const char (*tangent_names)[MAX_NAME], int tangent_names_count,
-        bool *rcalc_act, bool *rcalc_ren, int *ract_uv_n, int *rren_uv_n,
-        char *ract_uv_name, char *rren_uv_name, short *rtangent_mask)
+void BKE_mesh_calc_loop_tangent_step_0(const CustomData *loopData,
+                                       bool calc_active_tangent,
+                                       const char (*tangent_names)[MAX_NAME],
+                                       int tangent_names_count,
+                                       bool *rcalc_act,
+                                       bool *rcalc_ren,
+                                       int *ract_uv_n,
+                                       int *rren_uv_n,
+                                       char *ract_uv_name,
+                                       char *rren_uv_name,
+                                       short *rtangent_mask)
 {
-	/* Active uv in viewport */
-	int layer_index = CustomData_get_layer_index(loopData, CD_MLOOPUV);
-	*ract_uv_n = CustomData_get_active_layer(loopData, CD_MLOOPUV);
-	ract_uv_name[0] = 0;
-	if (*ract_uv_n != -1) {
-		strcpy(ract_uv_name, loopData->layers[*ract_uv_n + layer_index].name);
-	}
-
-	/* Active tangent in render */
-	*rren_uv_n = CustomData_get_render_layer(loopData, CD_MLOOPUV);
-	rren_uv_name[0] = 0;
-	if (*rren_uv_n != -1) {
-		strcpy(rren_uv_name, loopData->layers[*rren_uv_n + layer_index].name);
-	}
-
-	/* If active tangent not in tangent_names we take it into account */
-	*rcalc_act = false;
-	*rcalc_ren = false;
-	for (int i = 0; i < tangent_names_count; i++) {
-		if (tangent_names[i][0] == 0) {
-			calc_active_tangent = true;
-		}
-	}
-	if (calc_active_tangent) {
-		*rcalc_act = true;
-		*rcalc_ren = true;
-		for (int i = 0; i < tangent_names_count; i++) {
-			if (STREQ(ract_uv_name, tangent_names[i]))
-				*rcalc_act = false;
-			if (STREQ(rren_uv_name, tangent_names[i]))
-				*rcalc_ren = false;
-		}
-	}
-	*rtangent_mask = 0;
-
-	const int uv_layer_num = CustomData_number_of_layers(loopData, CD_MLOOPUV);
-	for (int n = 0; n < uv_layer_num; n++) {
-		const char *name = CustomData_get_layer_name(loopData, CD_MLOOPUV, n);
-		bool add = false;
-		for (int i = 0; i < tangent_names_count; i++) {
-			if (tangent_names[i][0] && STREQ(tangent_names[i], name)) {
-				add = true;
-				break;
-			}
-		}
-		if (!add && ((*rcalc_act && ract_uv_name[0] && STREQ(ract_uv_name, name)) ||
-		             (*rcalc_ren && rren_uv_name[0] && STREQ(rren_uv_name, name))))
-		{
-			add = true;
-		}
-		if (add)
-			*rtangent_mask |= (short)(1 << n);
-	}
-
-	if (uv_layer_num == 0)
-		*rtangent_mask |= DM_TANGENT_MASK_ORCO;
+  /* Active uv in viewport */
+  int layer_index = CustomData_get_layer_index(loopData, CD_MLOOPUV);
+  *ract_uv_n = CustomData_get_active_layer(loopData, CD_MLOOPUV);
+  ract_uv_name[0] = 0;
+  if (*ract_uv_n != -1) {
+    strcpy(ract_uv_name, loopData->layers[*ract_uv_n + layer_index].name);
+  }
+
+  /* Active tangent in render */
+  *rren_uv_n = CustomData_get_render_layer(loopData, CD_MLOOPUV);
+  rren_uv_name[0] = 0;
+  if (*rren_uv_n != -1) {
+    strcpy(rren_uv_name, loopData->layers[*rren_uv_n + layer_index].name);
+  }
+
+  /* If active tangent not in tangent_names we take it into account */
+  *rcalc_act = false;
+  *rcalc_ren = false;
+  for (int i = 0; i < tangent_names_count; i++) {
+    if (tangent_names[i][0] == 0) {
+      calc_active_tangent = true;
+    }
+  }
+  if (calc_active_tangent) {
+    *rcalc_act = true;
+    *rcalc_ren = true;
+    for (int i = 0; i < tangent_names_count; i++) {
+      if (STREQ(ract_uv_name, tangent_names[i]))
+        *rcalc_act = false;
+      if (STREQ(rren_uv_name, tangent_names[i]))
+        *rcalc_ren = false;
+    }
+  }
+  *rtangent_mask = 0;
+
+  const int uv_layer_num = CustomData_number_of_layers(loopData, CD_MLOOPUV);
+  for (int n = 0; n < uv_layer_num; n++) {
+    const char *name = CustomData_get_layer_name(loopData, CD_MLOOPUV, n);
+    bool add = false;
+    for (int i = 0; i < tangent_names_count; i++) {
+      if (tangent_names[i][0] && STREQ(tangent_names[i], name)) {
+        add = true;
+        break;
+      }
+    }
+    if (!add && ((*rcalc_act && ract_uv_name[0] && STREQ(ract_uv_name, name)) ||
+                 (*rcalc_ren && rren_uv_name[0] && STREQ(rren_uv_name, name)))) {
+      add = true;
+    }
+    if (add)
+      *rtangent_mask |= (short)(1 << n);
+  }
+
+  if (uv_layer_num == 0)
+    *rtangent_mask |= DM_TANGENT_MASK_ORCO;
 }
 
 /**
  * See: #BKE_editmesh_loop_tangent_calc (matching logic).
  */
-void BKE_mesh_calc_loop_tangent_ex(
-        const MVert *mvert,
-        const MPoly *mpoly, const uint mpoly_len,
-        const MLoop *mloop,
-        const MLoopTri *looptri,
-        const uint looptri_len,
-
-        CustomData *loopdata,
-        bool calc_active_tangent,
-        const char (*tangent_names)[MAX_NAME], int tangent_names_len,
-        const float (*poly_normals)[3],
-        const float (*loop_normals)[3],
-        const float (*vert_orco)[3],
-        /* result */
-        CustomData *loopdata_out,
-        const uint  loopdata_out_len,
-        short *tangent_mask_curr_p)
+void BKE_mesh_calc_loop_tangent_ex(const MVert *mvert,
+                                   const MPoly *mpoly,
+                                   const uint mpoly_len,
+                                   const MLoop *mloop,
+                                   const MLoopTri *looptri,
+                                   const uint looptri_len,
+
+                                   CustomData *loopdata,
+                                   bool calc_active_tangent,
+                                   const char (*tangent_names)[MAX_NAME],
+                                   int tangent_names_len,
+                                   const float (*poly_normals)[3],
+                                   const float (*loop_normals)[3],
+                                   const float (*vert_orco)[3],
+                                   /* result */
+                                   CustomData *loopdata_out,
+                                   const uint loopdata_out_len,
+                                   short *tangent_mask_curr_p)
 {
-	int act_uv_n = -1;
-	int ren_uv_n = -1;
-	bool calc_act = false;
-	bool calc_ren = false;
-	char act_uv_name[MAX_NAME];
-	char ren_uv_name[MAX_NAME];
-	short tangent_mask = 0;
-	short tangent_mask_curr = *tangent_mask_curr_p;
-
-	BKE_mesh_calc_loop_tangent_step_0(
-	        loopdata, calc_active_tangent, tangent_names, tangent_names_len,
-	        &calc_act, &calc_ren, &act_uv_n, &ren_uv_n, act_uv_name, ren_uv_name, &tangent_mask);
-	if ((tangent_mask_curr | tangent_mask) != tangent_mask_curr) {
-		/* Check we have all the needed layers */
-		/* Allocate needed tangent layers */
-		for (int i = 0; i < tangent_names_len; i++)
-			if (tangent_names[i][0])
-				BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, tangent_names[i]);
-		if ((tangent_mask & DM_TANGENT_MASK_ORCO) && CustomData_get_named_layer_index(loopdata, CD_TANGENT, "") == -1)
-			    CustomData_add_layer_named(loopdata_out, CD_TANGENT, CD_CALLOC, NULL, (int)loopdata_out_len, "");
-		if (calc_act && act_uv_name[0])
-			BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, act_uv_name);
-		if (calc_ren && ren_uv_name[0])
-			BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, ren_uv_name);
+  int act_uv_n = -1;
+  int ren_uv_n = -1;
+  bool calc_act = false;
+  bool calc_ren = false;
+  char act_uv_name[MAX_NAME];
+  char ren_uv_name[MAX_NAME];
+  short tangent_mask = 0;
+  short tangent_mask_curr = *tangent_mask_curr_p;
+
+  BKE_mesh_calc_loop_tangent_step_0(loopdata,
+                                    calc_active_tangent,
+                                    tangent_names,
+                                    tangent_names_len,
+                                    &calc_act,
+                                    &calc_ren,
+                                    &act_uv_n,
+                                    &ren_uv_n,
+                                    act_uv_name,
+                                    ren_uv_name,
+                                    &tangent_mask);
+  if ((tangent_mask_curr | tangent_mask) != tangent_mask_curr) {
+    /* Check we have all the needed layers */
+    /* Allocate needed tangent layers */
+    for (int i = 0; i < tangent_names_len; i++)
+      if (tangent_names[i][0])
+        BKE_mesh_add_loop_tangent_named_layer_for_uv(
+            loopdata, loopdata_out, (int)loopdata_out_len, tangent_names[i]);
+    if ((tangent_mask & DM_TANGENT_MASK_ORCO) &&
+        CustomData_get_named_layer_index(loopdata, CD_TANGENT, "") == -1)
+      CustomData_add_layer_named(
+          loopdata_out, CD_TANGENT, CD_CALLOC, NULL, (int)loopdata_out_len, "");
+    if (calc_act && act_uv_name[0])
+      BKE_mesh_add_loop_tangent_named_layer_for_uv(
+          loopdata, loopdata_out, (int)loopdata_out_len, act_uv_name);
+    if (calc_ren && ren_uv_name[0])
+      BKE_mesh_add_loop_tangent_named_layer_for_uv(
+          loopdata, loopdata_out, (int)loopdata_out_len, ren_uv_name);
 
 #ifdef USE_LOOPTRI_DETECT_QUADS
-		int num_face_as_quad_map;
-		int *face_as_quad_map = NULL;
-
-		/* map faces to quads */
-		if (looptri_len != mpoly_len) {
-			/* over alloc, since we dont know how many ngon or quads we have */
-
-			/* map fake face index to looptri */
-			face_as_quad_map = MEM_mallocN(sizeof(int) * looptri_len, __func__);
-			int k, j;
-			for (k = 0, j = 0; j < (int)looptri_len; k++, j++) {
-				face_as_quad_map[k] = j;
-				/* step over all quads */
-				if (mpoly[looptri[j].poly].totloop == 4) {
-					j++;  /* skips the nest looptri */
-				}
-			}
-			num_face_as_quad_map = k;
-		}
-		else {
-			num_face_as_quad_map = (int)looptri_len;
-		}
+    int num_face_as_quad_map;
+    int *face_as_quad_map = NULL;
+
+    /* map faces to quads */
+    if (looptri_len != mpoly_len) {
+      /* over alloc, since we dont know how many ngon or quads we have */
+
+      /* map fake face index to looptri */
+      face_as_quad_map = MEM_mallocN(sizeof(int) * looptri_len, __func__);
+      int k, j;
+      for (k = 0, j = 0; j < (int)looptri_len; k++, j++) {
+        face_as_quad_map[k] = j;
+        /* step over all quads */
+        if (mpoly[looptri[j].poly].totloop == 4) {
+          j++; /* skips the nest looptri */
+        }
+      }
+      num_face_as_quad_map = k;
+    }
+    else {
+      num_face_as_quad_map = (int)looptri_len;
+    }
 #endif
 
-		/* Calculation */
-		if (looptri_len != 0) {
-			TaskScheduler *scheduler = BLI_task_scheduler_get();
-			TaskPool *task_pool;
-			task_pool = BLI_task_pool_create(scheduler, NULL);
-
-			tangent_mask_curr = 0;
-			/* Calculate tangent layers */
-			SGLSLMeshToTangent data_array[MAX_MTFACE];
-			const int tangent_layer_num = CustomData_number_of_layers(loopdata_out, CD_TANGENT);
-			for (int n = 0; n < tangent_layer_num; n++) {
-				int index = CustomData_get_layer_index_n(loopdata_out, CD_TANGENT, n);
-				BLI_assert(n < MAX_MTFACE);
-				SGLSLMeshToTangent *mesh2tangent = &data_array[n];
-				mesh2tangent->numTessFaces = (int)looptri_len;
+    /* Calculation */
+    if (looptri_len != 0) {
+      TaskScheduler *scheduler = BLI_task_scheduler_get();
+      TaskPool *task_pool;
+      task_pool = BLI_task_pool_create(scheduler, NULL);
+
+      tangent_mask_curr = 0;
+      /* Calculate tangent layers */
+      SGLSLMeshToTangent data_array[MAX_MTFACE];
+      const int tangent_layer_num = CustomData_number_of_layers(loopdata_out, CD_TANGENT);
+      for (int n = 0; n < tangent_layer_num; n++) {
+        int index = CustomData_get_layer_index_n(loopdata_out, CD_TANGENT, n);
+        BLI_assert(n < MAX_MTFACE);
+        SGLSLMeshToTangent *mesh2tangent = &data_array[n];
+        mesh2tangent->numTessFaces = (int)looptri_len;
 #ifdef USE_LOOPTRI_DETECT_QUADS
-				mesh2tangent->face_as_quad_map = face_as_quad_map;
-				mesh2tangent->num_face_as_quad_map = num_face_as_quad_map;
+        mesh2tangent->face_as_quad_map = face_as_quad_map;
+        mesh2tangent->num_face_as_quad_map = num_face_as_quad_map;
 #endif
-				mesh2tangent->mvert = mvert;
-				mesh2tangent->mpoly = mpoly;
-				mesh2tangent->mloop = mloop;
-				mesh2tangent->looptri = looptri;
-				/* Note, we assume we do have tessellated loop normals at this point (in case it is object-enabled),
-				 * have to check this is valid...
-				 */
-				mesh2tangent->precomputedLoopNormals = loop_normals;
-				mesh2tangent->precomputedFaceNormals = poly_normals;
-
-				mesh2tangent->orco = NULL;
-				mesh2tangent->mloopuv = CustomData_get_layer_named(loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
-
-				/* Fill the resulting tangent_mask */
-				if (!mesh2tangent->mloopuv) {
-				    mesh2tangent->orco = vert_orco;
-				    if (!mesh2tangent->orco)
-					    continue;
-
-				    tangent_mask_curr |= DM_TANGENT_MASK_ORCO;
-				}
-				else {
-				    int uv_ind = CustomData_get_named_layer_index(loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
-				    int uv_start = CustomData_get_layer_index(loopdata, CD_MLOOPUV);
-				    BLI_assert(uv_ind != -1 && uv_start != -1);
-				    BLI_assert(uv_ind - uv_start < MAX_MTFACE);
-				    tangent_mask_curr |= (short)(1 << (uv_ind - uv_start));
-				}
-
-				mesh2tangent->tangent = loopdata_out->layers[index].data;
-				BLI_task_pool_push(task_pool, DM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
-			}
-
-			BLI_assert(tangent_mask_curr == tangent_mask);
-			BLI_task_pool_work_and_wait(task_pool);
-			BLI_task_pool_free(task_pool);
-		}
-		else {
-			tangent_mask_curr = tangent_mask;
-		}
+        mesh2tangent->mvert = mvert;
+        mesh2tangent->mpoly = mpoly;
+        mesh2tangent->mloop = mloop;
+        mesh2tangent->looptri = looptri;
+        /* Note, we assume we do have tessellated loop normals at this point (in case it is object-enabled),
+         * have to check this is valid...
+         */
+        mesh2tangent->precomputedLoopNormals = loop_normals;
+        mesh2tangent->precomputedFaceNormals = poly_normals;
+
+        mesh2tangent->orco = NULL;
+        mesh2tangent->mloopuv = CustomData_get_layer_named(
+            loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
+
+        /* Fill the resulting tangent_mask */
+        if (!mesh2tangent->mloopuv) {
+          mesh2tangent->orco = vert_orco;
+          if (!mesh2tangent->orco)
+            continue;
+
+          tangent_mask_curr |= DM_TANGENT_MASK_ORCO;
+        }
+        else {
+          int uv_ind = CustomData_get_named_layer_index(
+              loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
+          int uv_start = CustomData_get_layer_index(loopdata, CD_MLOOPUV);
+          BLI_assert(uv_ind != -1 && uv_start != -1);
+          BLI_assert(uv_ind - uv_start < MAX_MTFACE);
+          tangent_mask_curr |= (short)(1 << (uv_ind - uv_start));
+        }
+
+        mesh2tangent->tangent = loopdata_out->layers[index].data;
+        BLI_task_pool_push(
+            task_pool, DM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
+      }
+
+      BLI_assert(tangent_mask_curr == tangent_mask);
+      BLI_task_pool_work_and_wait(task_pool);
+      BLI_task_pool_free(task_pool);
+    }
+    else {
+      tangent_mask_curr = tangent_mask;
+    }
 #ifdef USE_LOOPTRI_DETECT_QUADS
-		if (face_as_quad_map) {
-			MEM_freeN(face_as_quad_map);
-		}
-#undef USE_LOOPTRI_DETECT_QUADS
+    if (face_as_quad_map) {
+      MEM_freeN(face_as_quad_map);
+    }
+#  undef USE_LOOPTRI_DETECT_QUADS
 
 #endif
 
-		*tangent_mask_curr_p = tangent_mask_curr;
-
-		/* Update active layer index */
-		int act_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, act_uv_n);
-		if (act_uv_index != -1) {
-		    int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[act_uv_index].name);
-		    CustomData_set_layer_active_index(loopdata, CD_TANGENT, tan_index);
-		}/* else tangent has been built from orco */
-
-		/* Update render layer index */
-		int ren_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, ren_uv_n);
-		if (ren_uv_index != -1) {
-		    int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[ren_uv_index].name);
-		    CustomData_set_layer_render_index(loopdata, CD_TANGENT, tan_index);
-		}/* else tangent has been built from orco */
-	}
+    *tangent_mask_curr_p = tangent_mask_curr;
+
+    /* Update active layer index */
+    int act_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, act_uv_n);
+    if (act_uv_index != -1) {
+      int tan_index = CustomData_get_named_layer_index(
+          loopdata, CD_TANGENT, loopdata->layers[act_uv_index].name);
+      CustomData_set_layer_active_index(loopdata, CD_TANGENT, tan_index);
+    } /* else tangent has been built from orco */
+
+    /* Update render layer index */
+    int ren_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, ren_uv_n);
+    if (ren_uv_index != -1) {
+      int tan_index = CustomData_get_named_layer_index(
+          loopdata, CD_TANGENT, loopdata->layers[ren_uv_index].name);
+      CustomData_set_layer_render_index(loopdata, CD_TANGENT, tan_index);
+    } /* else tangent has been built from orco */
+  }
 }
 
-void BKE_mesh_calc_loop_tangents(
-        Mesh *me_eval, bool calc_active_tangent,
-        const char (*tangent_names)[MAX_NAME], int tangent_names_len)
+void BKE_mesh_calc_loop_tangents(Mesh *me_eval,
+                                 bool calc_active_tangent,
+                                 const char (*tangent_names)[MAX_NAME],
+                                 int tangent_names_len)
 {
-	BKE_mesh_runtime_looptri_ensure(me_eval);
-
-	/* TODO(campbell): store in Mesh.runtime to avoid recalculation. */
-	short tangent_mask = 0;
-	BKE_mesh_calc_loop_tangent_ex(
-	        me_eval->mvert,
-	        me_eval->mpoly, (uint)me_eval->totpoly,
-	        me_eval->mloop,
-	        me_eval->runtime.looptris.array, (uint)me_eval->runtime.looptris.len,
-	        &me_eval->ldata,
-	        calc_active_tangent,
-	        tangent_names, tangent_names_len,
-	        CustomData_get_layer(&me_eval->pdata, CD_NORMAL),
-	        CustomData_get_layer(&me_eval->ldata, CD_NORMAL),
-	        CustomData_get_layer(&me_eval->vdata, CD_ORCO),  /* may be NULL */
-	        /* result */
-	        &me_eval->ldata, (uint)me_eval->totloop,
-	        &tangent_mask);
+  BKE_mesh_runtime_looptri_ensure(me_eval);
+
+  /* TODO(campbell): store in Mesh.runtime to avoid recalculation. */
+  short tangent_mask = 0;
+  BKE_mesh_calc_loop_tangent_ex(me_eval->mvert,
+                                me_eval->mpoly,
+                                (uint)me_eval->totpoly,
+                                me_eval->mloop,
+                                me_eval->runtime.looptris.array,
+                                (uint)me_eval->runtime.looptris.len,
+                                &me_eval->ldata,
+                                calc_active_tangent,
+                                tangent_names,
+                                tangent_names_len,
+                                CustomData_get_layer(&me_eval->pdata, CD_NORMAL),
+                                CustomData_get_layer(&me_eval->ldata, CD_NORMAL),
+                                CustomData_get_layer(&me_eval->vdata, CD_ORCO), /* may be NULL */
+                                /* result */
+                                &me_eval->ldata,
+                                (uint)me_eval->totloop,
+                                &tangent_mask);
 }
 
 /** \} */