Blender V5.3
editmesh_tangent.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_math_geom_c.hh"
10#include "BLI_math_vector_c.hh"
11#include "BLI_task.hh"
12
14
15#include "BKE_customdata.hh"
16#include "BKE_editmesh.hh"
18#include "BKE_mesh.hh"
19
20#include "MEM_guardedalloc.h"
21
22/* interface */
23#include "mikktspace.hh"
24
25namespace blender {
26
27/* -------------------------------------------------------------------- */
30
31/* Necessary complexity to handle looptris as quads for correct tangents. */
32#define USE_LOOPTRI_DETECT_QUADS
33
36 {
37#ifdef USE_LOOPTRI_DETECT_QUADS
39#else
40 return uint(numTessFaces);
41#endif
42 }
43
45 {
46#ifdef USE_LOOPTRI_DETECT_QUADS
47 if (face_as_quad_map) {
48 if (looptris[face_as_quad_map[face_num]][0]->f->len == 4) {
49 return 4;
50 }
51 }
52 return 3;
53#else
54 UNUSED_VARS(pContext, face_num);
55 return 3;
56#endif
57 }
58
59 const BMLoop *GetLoop(const uint face_num, uint vert_index)
60 {
61 // BLI_assert(vert_index >= 0 && vert_index < 4);
62 BMLoop *const *ltri;
63 const BMLoop *l;
64
65#ifdef USE_LOOPTRI_DETECT_QUADS
66 if (face_as_quad_map) {
67 ltri = looptris[face_as_quad_map[face_num]].data();
68 if (ltri[0]->f->len == 4) {
69 l = BM_FACE_FIRST_LOOP(ltri[0]->f);
70 while (vert_index--) {
71 l = l->next;
72 }
73 return l;
74 }
75 /* fall through to regular triangle */
76 }
77 else {
78 ltri = looptris[face_num].data();
79 }
80#else
81 ltri = looptris[face_num].data();
82#endif
83 return ltri[vert_index];
84 }
85
86 mikk::float3 GetPosition(const uint face_num, const uint vert_index)
87 {
88 const BMLoop *l = GetLoop(face_num, vert_index);
89 return mikk::float3(l->v->co);
90 }
91
92 mikk::float3 GetTexCoord(const uint face_num, const uint vert_index)
93 {
94 const BMLoop *l = GetLoop(face_num, vert_index);
95 if (has_uv()) {
96 const float *uv = static_cast<const float *> BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
97 return mikk::float3(uv[0], uv[1], 1.0f);
98 }
99 const float *orco_p = orco[BM_elem_index_get(l->v)];
100 float u, v;
101 map_to_sphere(&u, &v, orco_p[0], orco_p[1], orco_p[2]);
102 return mikk::float3(u, v, 1.0f);
103 }
104
105 mikk::float3 GetNormal(const uint face_num, const uint vert_index)
106 {
107 const BMLoop *l = GetLoop(face_num, vert_index);
108 if (!corner_normals.is_empty()) {
110 }
111 if (BM_elem_flag_test(l->f, BM_ELEM_SMOOTH) == 0) { /* flat */
112 if (!face_normals.is_empty()) {
114 }
115 return mikk::float3(l->f->no);
116 }
117 return mikk::float3(l->v->no);
118 }
119
120 void SetTangentSpace(const uint face_num,
121 const uint vert_index,
123 bool orientation)
124 {
125 const BMLoop *l = GetLoop(face_num, vert_index);
126 float *p_res = tangent[BM_elem_index_get(l)];
127 copy_v4_fl4(p_res, T.x, T.y, T.z, orientation ? 1.0f : -1.0f);
128 }
129
130 bool has_uv()
131 {
132 return cd_loop_uv_offset != -1;
133 }
134
138 int cd_loop_uv_offset; /* texture coordinates */
140 float (*tangent)[4]; /* destination */
142
143#ifdef USE_LOOPTRI_DETECT_QUADS
144 /* map from 'fake' face index to looptris,
145 * quads will point to the first looptri of the quad */
148#endif
149};
150
151static void calc_face_as_quad_map(const Span<std::array<BMLoop *, 3>> looptris,
152 BMesh &bm,
153 int &totface,
154 int &num_face_as_quad_map,
155 int *&face_as_quad_map)
156{
157#ifdef USE_LOOPTRI_DETECT_QUADS
158 if (looptris.size() != bm.totface) {
159 /* Over allocate, since we don't know how many ngon or quads we have. */
160
161 /* map fake face index to looptri */
162 face_as_quad_map = MEM_new_array_uninitialized<int>(size_t(totface), __func__);
163 int i, j;
164 for (i = 0, j = 0; j < totface; i++, j++) {
165 face_as_quad_map[i] = j;
166 /* step over all quads */
167 if (looptris[j][0]->f->len == 4) {
168 j++; /* Skips the next looptri. */
169 }
170 }
171 num_face_as_quad_map = i;
172 }
173 else {
174 num_face_as_quad_map = totface;
175 }
176#else
177 num_face_as_quad_map = totface;
178 face_as_quad_map = nullptr;
179#endif
180}
181
183 const Span<std::array<BMLoop *, 3>> looptris,
184 const Span<float3> face_normals,
185 const Span<float3> corner_normals,
186 const Span<StringRef> uv_names)
187{
188 if (looptris.is_empty()) {
189 return {};
190 }
191
192 int totface = looptris.size();
193 int num_face_as_quad_map;
194 int *face_as_quad_map = nullptr;
195 calc_face_as_quad_map(looptris, *bm, totface, num_face_as_quad_map, face_as_quad_map);
196
197 Array<Array<float4>> result(uv_names.size());
198
199 /* needed for indexing loop-tangents */
200 int htype_index = BM_LOOP;
201 if (!face_normals.is_empty()) {
202 /* needed for face normal lookups */
203 htype_index |= BM_FACE;
204 }
205 BM_mesh_elem_index_ensure(bm, htype_index);
206
207 threading::parallel_for(uv_names.index_range(), 1, [&](const IndexRange range) {
208 for (const int n : range) {
209 SGLSLEditMeshToTangent mesh2tangent{};
210 mesh2tangent.numTessFaces = looptris.size();
211 mesh2tangent.face_as_quad_map = face_as_quad_map;
212 mesh2tangent.num_face_as_quad_map = num_face_as_quad_map;
213 mesh2tangent.face_normals = face_normals;
214 /* NOTE: we assume we do have tessellated loop normals at this point
215 * (in case it is object-enabled), have to check this is valid. */
216 mesh2tangent.corner_normals = corner_normals;
217 mesh2tangent.cd_loop_uv_offset = CustomData_get_offset_named(
218 &bm->ldata, CD_PROP_FLOAT2, uv_names[n]);
219 BLI_assert(mesh2tangent.cd_loop_uv_offset != -1);
220
221 mesh2tangent.looptris = looptris;
222 result[n].reinitialize(bm->totloop);
223 mesh2tangent.tangent = reinterpret_cast<float (*)[4]>(result[n].data());
224
225 mikk::Mikktspace<SGLSLEditMeshToTangent> mikk(mesh2tangent);
226 mikk.genTangSpace();
227 }
228 });
229
230 MEM_SAFE_DELETE(face_as_quad_map);
231
232 return result;
233}
234
236 const Span<std::array<BMLoop *, 3>> looptris,
237 const Span<float3> face_normals,
238 const Span<float3> corner_normals,
239 const Span<float3> vert_orco)
240{
241 if (looptris.is_empty()) {
242 return {};
243 }
244
245 int totface = looptris.size();
246 int num_face_as_quad_map;
247 int *face_as_quad_map = nullptr;
248 calc_face_as_quad_map(looptris, *bm, totface, num_face_as_quad_map, face_as_quad_map);
249
251
252 /* needed for indexing loop-tangents */
253 int htype_index = BM_LOOP;
254 /* needed for orco lookups */
255 htype_index |= BM_VERT;
256 if (!face_normals.is_empty()) {
257 /* needed for face normal lookups */
258 htype_index |= BM_FACE;
259 }
260 BM_mesh_elem_index_ensure(bm, htype_index);
261
262 SGLSLEditMeshToTangent mesh2tangent{};
263 mesh2tangent.numTessFaces = looptris.size();
264 mesh2tangent.face_as_quad_map = face_as_quad_map;
265 mesh2tangent.num_face_as_quad_map = num_face_as_quad_map;
266 mesh2tangent.face_normals = face_normals;
267 /* NOTE: we assume we do have tessellated loop normals at this point
268 * (in case it is object-enabled), have to check this is valid. */
269 mesh2tangent.corner_normals = corner_normals;
270 mesh2tangent.cd_loop_uv_offset = -1;
271 mesh2tangent.orco = vert_orco;
272
273 mesh2tangent.looptris = looptris;
274 mesh2tangent.tangent = reinterpret_cast<float (*)[4]>(result.data());
276 mikk.genTangSpace();
277
278 MEM_SAFE_DELETE(face_as_quad_map);
279
280 return result;
281}
282
284
285} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
Read Blender memory allocation and freeing.
#define UNUSED_VARS(...)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_test(ele, hflag)
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
#define T
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BMesh Iterators.
Array< Array< float4 > > BKE_editmesh_uv_tangents_calc(BMesh *bm, Span< std::array< BMLoop *, 3 > > looptris, Span< float3 > face_normals, Span< float3 > corner_normals, Span< StringRef > uv_names)
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
unsigned int uint
Definition BKE_text.h:55
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
ATTR_WARN_UNUSED_RESULT const BMLoop * l
MINLINE void copy_v4_fl4(float v[4], float x, float y, float z, float w)
ATTR_WARN_UNUSED_RESULT const BMVert * v
bool map_to_sphere(float *r_u, float *r_v, float x, float y, float z)
static void calc_face_as_quad_map(const Span< std::array< BMLoop *, 3 > > looptris, BMesh &bm, int &totface, int &num_face_as_quad_map, int *&face_as_quad_map)
Array< float4 > BKE_editmesh_orco_tangents_calc(BMesh *bm, Span< std::array< BMLoop *, 3 > > looptris, Span< float3 > face_normals, Span< float3 > corner_normals, Span< float3 > vert_orco)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMLoop * next
struct BMVert * v
struct BMFace * f
mikk::float3 GetPosition(const uint face_num, const uint vert_index)
uint GetNumVerticesOfFace(const uint face_num)
void SetTangentSpace(const uint face_num, const uint vert_index, mikk::float3 T, bool orientation)
const BMLoop * GetLoop(const uint face_num, uint vert_index)
mikk::float3 GetTexCoord(const uint face_num, const uint vert_index)
mikk::float3 GetNormal(const uint face_num, const uint vert_index)
Span< std::array< BMLoop *, 3 > > looptris