1 files changed, 18 insertions, 456 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 150a919bf6b..a6b9a048763 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -60,6 +60,7 @@
 #include "BKE_modifier.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_mapping.h"
+#include "BKE_mesh_tangent.h"
 #include "BKE_object.h"
 #include "BKE_object_deform.h"
 #include "BKE_paint.h"
@@ -3038,234 +3039,6 @@ void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int
 
 /* ******************* GLSL ******************** */
 
-/** \name Tangent Space Calculation
- * \{ */
-
-/* Necessary complexity to handle looptri's as quads for correct tangents */
-#define USE_LOOPTRI_DETECT_QUADS
-
-typedef struct {
-	float (*precomputedFaceNormals)[3];
-	float (*precomputedLoopNormals)[3];
-	const MLoopTri *looptri;
-	MLoopUV *mloopuv;   /* texture coordinates */
-	MPoly *mpoly;       /* indices */
-	MLoop *mloop;       /* indices */
-	MVert *mvert;       /* vertices & normals */
-	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;
-#endif
-
-} SGLSLMeshToTangent;
-
-/* interface */
-#include "mikktspace.h"
-
-static int dm_ts_GetNumFaces(const SMikkTSpaceContext *pContext)
-{
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-
-#ifdef USE_LOOPTRI_DETECT_QUADS
-	return pMesh->num_face_as_quad_map;
-#else
-	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;
-#else
-	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)
-{
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-	const MLoopTri *lt;
-	int 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 = mp->loopstart + vert_index;
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
-#else
-	lt = &pMesh->looptri[face_num];
-#endif
-	loop_index = lt->tri[vert_index];
-
-finally:
-	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)
-{
-	//assert(vert_index >= 0 && vert_index < 4);
-	SGLSLMeshToTangent *pMesh = pContext->m_pUserData;
-	const MLoopTri *lt;
-	int 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 = mp->loopstart + vert_index;
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
-#else
-	lt = &pMesh->looptri[face_num];
-#endif
-	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]);
-	}
-}
-
-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;
-	int 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 = mp->loopstart + vert_index;
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
-#else
-	lt = &pMesh->looptri[face_num];
-#endif
-	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 {
-#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
-#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);
-	}
-}
-
-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;
-	int 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 = mp->loopstart + vert_index;
-			goto finally;
-		}
-		/* fall through to regular triangle */
-	}
-	else {
-		lt = &pMesh->looptri[face_num];
-	}
-#else
-	lt = &pMesh->looptri[face_num];
-#endif
-	loop_index = lt->tri[vert_index];
-
-	float *pRes;
-
-finally:
-	pRes = pMesh->tangent[loop_index];
-	copy_v3_v3(pRes, fvTangent);
-	pRes[3] = fSign;
-}
-
 void DM_calc_tangents_names_from_gpu(
         const GPUVertexAttribs *gattribs,
         char (*tangent_names)[MAX_NAME], int *r_tangent_names_count)
@@ -3279,240 +3052,29 @@ void DM_calc_tangents_names_from_gpu(
 	*r_tangent_names_count = count;
 }
 
-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);
-	}
-}
-
-void DM_add_named_tangent_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);
-	}
-}
-
-/**
- * Here we get some useful information such as active uv layer name and search if it is already in tangent_names.
- * Also, we calculate tangent_mask that works as a descriptor of tangents state.
- * If tangent_mask has changed, then recalculate tangents.
- */
-void DM_calc_loop_tangents_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, char *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 ((*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 |= 1 << n;
-	}
-}
-
 void DM_calc_loop_tangents(
         DerivedMesh *dm, bool calc_active_tangent,
-        const char (*tangent_names)[MAX_NAME], int tangent_names_count)
+        const char (*tangent_names)[MAX_NAME], int tangent_names_len)
 {
-	if (CustomData_number_of_layers(&dm->loopData, CD_MLOOPUV) == 0)
+	if (CustomData_number_of_layers(&dm->loopData, CD_MLOOPUV) == 0) {
 		return;
-	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];
-	char tangent_mask = 0;
-	DM_calc_loop_tangents_step_0(
-	        &dm->loopData, calc_active_tangent, tangent_names, tangent_names_count,
-	        &calc_act, &calc_ren, &act_uv_n, &ren_uv_n, act_uv_name, ren_uv_name, &tangent_mask);
-	if ((dm->tangent_mask | tangent_mask) != dm->tangent_mask) {
-		/* Check we have all the needed layers */
-		MPoly *mpoly = dm->getPolyArray(dm);
-		const MLoopTri *looptri = dm->getLoopTriArray(dm);
-		int totface = dm->getNumLoopTri(dm);
-		/* Allocate needed tangent layers */
-		for (int i = 0; i < tangent_names_count; i++)
-			if (tangent_names[i][0])
-				DM_add_named_tangent_layer_for_uv(&dm->loopData, &dm->loopData, dm->numLoopData, tangent_names[i]);
-		if (calc_act && act_uv_name[0])
-			DM_add_named_tangent_layer_for_uv(&dm->loopData, &dm->loopData, dm->numLoopData, act_uv_name);
-		if (calc_ren && ren_uv_name[0])
-			DM_add_named_tangent_layer_for_uv(&dm->loopData, &dm->loopData, dm->numLoopData, 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 (totface != dm->getNumPolys(dm)) {
-			/* 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) * totface, __func__);
-			int k, j;
-			for (k = 0, j = 0; j < totface; 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 = totface;
-		}
-#endif
-
-		/* Calculation */
-		{
-			TaskScheduler *scheduler = BLI_task_scheduler_get();
-			TaskPool *task_pool;
-			task_pool = BLI_task_pool_create(scheduler, NULL);
-
-			dm->tangent_mask = 0;
-			/* Calculate tangent layers */
-			SGLSLMeshToTangent data_array[MAX_MTFACE];
-			const int tangent_layer_num = CustomData_number_of_layers(&dm->loopData, CD_TANGENT);
-			for (int n = 0; n < tangent_layer_num; n++) {
-				int index = CustomData_get_layer_index_n(&dm->loopData, CD_TANGENT, n);
-				BLI_assert(n < MAX_MTFACE);
-				SGLSLMeshToTangent *mesh2tangent = &data_array[n];
-				mesh2tangent->numTessFaces = totface;
-#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;
-#endif
-				mesh2tangent->mvert = dm->getVertArray(dm);
-				mesh2tangent->mpoly = dm->getPolyArray(dm);
-				mesh2tangent->mloop = dm->getLoopArray(dm);
-				mesh2tangent->looptri = dm->getLoopTriArray(dm);
-				/* 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 = dm->getLoopDataArray(dm, CD_NORMAL);
-				mesh2tangent->precomputedFaceNormals = CustomData_get_layer(&dm->polyData, CD_NORMAL);
-
-				mesh2tangent->orco = NULL;
-				mesh2tangent->mloopuv = CustomData_get_layer_named(&dm->loopData, CD_MLOOPUV, dm->loopData.layers[index].name);
-				if (!mesh2tangent->mloopuv) {
-					mesh2tangent->orco = dm->getVertDataArray(dm, CD_ORCO);
-					if (!mesh2tangent->orco)
-						continue;
-				}
-				mesh2tangent->tangent = dm->loopData.layers[index].data;
-
-				/* Fill the resulting tangent_mask */
-				int uv_ind = CustomData_get_named_layer_index(&dm->loopData, CD_MLOOPUV, dm->loopData.layers[index].name);
-				int uv_start = CustomData_get_layer_index(&dm->loopData, CD_MLOOPUV);
-				BLI_assert(uv_ind != -1 && uv_start != -1);
-				BLI_assert(uv_ind - uv_start < MAX_MTFACE);
-				dm->tangent_mask |= 1 << (uv_ind - uv_start);
-				BLI_task_pool_push(task_pool, DM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
-			}
-
-			BLI_assert(dm->tangent_mask == tangent_mask);
-			BLI_task_pool_work_and_wait(task_pool);
-			BLI_task_pool_free(task_pool);
-		}
-#ifdef USE_LOOPTRI_DETECT_QUADS
-		if (face_as_quad_map) {
-			MEM_freeN(face_as_quad_map);
-		}
-#undef USE_LOOPTRI_DETECT_QUADS
-
-#endif
-
-		int uv_index, tan_index;
-
-		/* Update active layer index */
-		uv_index = CustomData_get_layer_index_n(&dm->loopData, CD_MLOOPUV, act_uv_n);
-		if (uv_index != -1) {
-			tan_index = CustomData_get_named_layer_index(&dm->loopData, CD_TANGENT, dm->loopData.layers[uv_index].name);
-			CustomData_set_layer_active_index(&dm->loopData, CD_TANGENT, tan_index);
-		}
-
-		/* Update render layer index */
-		uv_index = CustomData_get_layer_index_n(&dm->loopData, CD_MLOOPUV, ren_uv_n);
-		if (uv_index != -1) {
-			tan_index = CustomData_get_named_layer_index(&dm->loopData, CD_TANGENT, dm->loopData.layers[uv_index].name);
-			CustomData_set_layer_render_index(&dm->loopData, CD_TANGENT, tan_index);
-		}
 	}
-}
-
-/** \} */
 
+	BKE_mesh_calc_loop_tangent_ex(
+	        dm->getVertArray(dm),
+	        dm->getPolyArray(dm), dm->getNumPolys(dm),
+	        dm->getLoopArray(dm),
+	        dm->getLoopTriArray(dm), dm->getNumLoopTri(dm),
+	        &dm->loopData,
+	        calc_active_tangent,
+	        tangent_names, tangent_names_len,
+	        CustomData_get_layer(&dm->polyData, CD_NORMAL),
+	        dm->getLoopDataArray(dm, CD_NORMAL),
+	        dm->getVertDataArray(dm, CD_ORCO),  /* may be NULL */
+	        /* result */
+	        &dm->loopData, dm->getNumLoops(dm),
+	        &dm->tangent_mask);
+}
 
 void DM_calc_auto_bump_scale(DerivedMesh *dm)
 {