Blender V5.3
extract_mesh_ibo_points.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "GPU_index_buffer.hh"
10
11#include "draw_subdivision.hh"
12#include "extract_mesh.hh"
13
14#include "BLI_array_utils.hh"
15#include "BLI_timeit.hh"
16
17namespace blender::draw {
18
20 const IndexMask &mask,
21 IndexMaskMemory &memory)
22{
23 IndexMask visible = mask;
24 if (!mr.hide_vert.is_empty()) {
25 visible = IndexMask::from_bools_inverse(visible, mr.hide_vert, memory);
26 }
27 if (mr.orig_index_vert != nullptr) {
28 const int *orig_index = mr.orig_index_vert;
29 static_assert(ORIGINDEX_NONE == -1);
30 visible = array_utils::indices_non_negative(visible, Span(orig_index, mr.verts_num), memory);
31 }
32 return visible;
33}
34
40template<typename Fn>
41static void process_ibo_verts_mesh(const MeshRenderData &mr, const Fn &process_vert_fn)
42{
43 const Span<int> corner_verts = mr.corner_verts;
44 threading::parallel_for(corner_verts.index_range(), 2048, [&](const IndexRange range) {
45 for (const int corner : range) {
46 process_vert_fn(corner, corner_verts[corner]);
47 }
48 });
49
50 const int loose_edges_start = mr.corners_num;
51 const Span<int2> edges = mr.edges;
52 mr.loose_edges.foreach_index_optimized<int>(
53 [&](const int i, const int pos) {
54 const int2 edge = edges[i];
55 process_vert_fn(loose_edges_start + pos * 2 + 0, edge[0]);
56 process_vert_fn(loose_edges_start + pos * 2 + 1, edge[1]);
57 },
59
60 const int loose_verts_start = mr.corners_num + mr.loose_edges.size() * 2;
61 mr.loose_verts.foreach_index_optimized<int>(
62 [&](const int i, const int pos) { process_vert_fn(loose_verts_start + pos, i); },
64}
65
67{
68 IndexMaskMemory memory;
69 const IndexMask visible_verts = calc_vert_visibility_mesh(mr, IndexMask(mr.verts_num), memory);
70
71 const int max_index = mr.corners_num + mr.loose_edges.size() * 2 + mr.loose_verts.size();
72 GPUIndexBufBuilder builder;
73 GPU_indexbuf_init(&builder, GPU_PRIM_POINTS, visible_verts.size(), max_index);
75
77 if (visible_verts.size() == mr.verts_num) {
78 Array<bool> used(mr.verts_num, false);
79 process_ibo_verts_mesh(mr, [&](const int ibo_index, const int vert) {
80 if (!used[vert]) {
81 used[vert] = true;
82 data[vert] = ibo_index;
83 }
84 });
85 }
86 else {
87 /* Compress the vertex indices into the smaller range of visible vertices in the IBO. */
88 Array<int> map(mr.verts_num, -1);
89 index_mask::build_reverse_map(visible_verts, map.as_mutable_span());
90 process_ibo_verts_mesh(mr, [&](const int ibo_index, const int vert) {
91 const int index = map[vert];
92 if (index != -1) {
93 map[vert] = -1;
94 data[index] = ibo_index;
95 }
96 });
97 }
98 });
99
100 return gpu::IndexBufPtr(GPU_indexbuf_build_ex(&builder, 0, max_index, false));
101}
102
103template<typename Fn>
104static void process_ibo_verts_bm(const MeshRenderData &mr, const Fn &process_vert_fn)
105{
106 BMesh &bm = *mr.bm;
107
108 threading::parallel_for(IndexRange(mr.verts_num), 4096, [&](const IndexRange range) {
109 for (const int i : range) {
110 BMVert &vert = *BM_vert_at_index(&bm, i);
111 if (const BMLoop *loop = BM_vert_find_first_loop(&vert)) {
112 process_vert_fn(BM_elem_index_get(loop), i);
113 }
114 }
115 });
116
117 const int loose_edges_start = mr.corners_num;
118 mr.loose_edges.foreach_index(
119 [&](const int i, const int pos) {
120 const BMEdge &edge = *BM_edge_at_index(&bm, i);
121 process_vert_fn(loose_edges_start + pos * 2 + 0, BM_elem_index_get(edge.v1));
122 process_vert_fn(loose_edges_start + pos * 2 + 1, BM_elem_index_get(edge.v2));
123 },
124 exec_mode::grain_size(4096));
125
126 const int loose_verts_start = mr.corners_num + mr.loose_edges.size() * 2;
127 mr.loose_verts.foreach_index_optimized<int>(
128 [&](const int i, const int pos) { process_vert_fn(loose_verts_start + pos, i); },
129 exec_mode::grain_size(4096));
130}
131
133{
134 BMesh &bm = *mr.bm;
135
136 IndexMaskMemory memory;
137 const IndexMask visible_verts = IndexMask::from_predicate(
138 IndexRange(bm.totvert), memory, [&](const int i) {
139 return !BM_elem_flag_test_bool(BM_vert_at_index(&const_cast<BMesh &>(bm), i),
140 BM_ELEM_HIDDEN);
141 });
142
143 const int max_index = mr.corners_num + mr.loose_edges.size() * 2 + mr.loose_verts.size();
144 GPUIndexBufBuilder builder;
145 GPU_indexbuf_init(&builder, GPU_PRIM_POINTS, visible_verts.size(), max_index);
147
148 if (mr.loose_verts.is_empty() && mr.loose_edges.is_empty()) {
149 /* Make use of BMesh's vertex to loop topology knowledge to iterate over verts instead of
150 * iterating over faces and defining points implicitly as done in the #Mesh extraction. */
151 visible_verts.foreach_index(
152 [&](const int i, const int pos) {
153 BMVert &vert = *BM_vert_at_index(&bm, i);
155 },
157 }
158 else if (visible_verts.size() == bm.totvert) {
159 Array<bool> used(mr.verts_num, false);
160 process_ibo_verts_bm(mr, [&](const int ibo_index, const int vert) {
161 if (!used[vert]) {
162 used[vert] = true;
163 data[vert] = ibo_index;
164 }
165 });
166 }
167 else {
168 /* Compress the vertex indices into the smaller range of visible vertices in the IBO. */
169 Array<int> map(mr.verts_num, -1);
171 process_ibo_verts_bm(mr, [&](const int ibo_index, const int vert) {
172 const int index = map[vert];
173 if (index != -1) {
174 map[vert] = -1;
175 data[index] = ibo_index;
176 }
177 });
178 }
179
180 return gpu::IndexBufPtr(GPU_indexbuf_build_ex(&builder, 0, max_index, false));
181}
182
184{
186 return extract_points_mesh(mr);
187 }
188 return extract_points_bm(mr);
189}
190
192 const IndexMask &mask,
193 const Span<int> map,
194 IndexMaskMemory &memory)
195{
196 IndexMask visible = mask;
197 if (!mr.hide_vert.is_empty()) {
198 const Span<bool> hide_vert = mr.hide_vert;
200 visible, memory, [&](const int i) { return !hide_vert[map[i]]; });
201 }
202 if (mr.orig_index_vert != nullptr) {
203 const int *orig_index = mr.orig_index_vert;
205 visible, memory, [&](const int i) { return orig_index[map[i]] != ORIGINDEX_NONE; });
206 }
207 return visible;
208}
209
211 const DRWSubdivCache &subdiv_cache)
212{
213 const Span<int2> coarse_edges = mr.edges;
214 const int verts_per_edge = subdiv_verts_per_coarse_edge(subdiv_cache);
215 const int loose_edge_verts_num = verts_per_edge * mr.loose_edges.size();
216
217 const Span<bool> hide_vert = mr.hide_vert;
218 const Span<int> corner_orig_verts = subdiv_cache.verts_orig_index->data<int>();
219
220 IndexMaskMemory memory;
221 IndexMask visible_corners = IndexMask::from_predicate(
222 corner_orig_verts.index_range(), memory, [&](const int i) {
223 return corner_orig_verts[i] != -1;
224 });
225 visible_corners = calc_vert_visibility_mapped_mesh(
226 mr, visible_corners, corner_orig_verts, memory);
227
228 Array<int, 64> loose_verts(mr.loose_verts.size());
229 mr.loose_verts.to_indices(loose_verts.as_mutable_span());
230 const IndexMask visible_loose = calc_vert_visibility_mapped_mesh(
231 mr, IndexMask(loose_verts.size()), loose_verts, memory);
232
233 const int max_index = subdiv_cache.num_subdiv_loops + loose_edge_verts_num + loose_verts.size();
234 GPUIndexBufBuilder builder;
235 GPU_indexbuf_init(&builder,
237 visible_corners.size() + mr.loose_edges.size() * 2 + visible_loose.size(),
238 max_index);
240
241 visible_corners.to_indices<int32_t>(data.take_front(visible_corners.size()).cast<int32_t>());
242
243 const auto show_vert = [&](const int vert) {
244 if (!hide_vert.is_empty() && hide_vert[vert]) {
245 return false;
246 }
247 if (mr.orig_index_vert && mr.orig_index_vert[vert] == ORIGINDEX_NONE) {
248 return false;
249 }
250 return true;
251 };
252
253 MutableSpan loose_edge_data = data.slice(visible_corners.size(), mr.loose_edges.size() * 2);
254 const int loose_geom_start = subdiv_cache.num_subdiv_loops;
255 mr.loose_edges.foreach_index([&](const int i, const int pos) {
256 const int2 edge = coarse_edges[i];
257 const IndexRange edge_range(loose_geom_start + pos * verts_per_edge, verts_per_edge);
258 loose_edge_data[pos * 2 + 0] = show_vert(edge[0]) ? edge_range.first() : gpu::RESTART_INDEX;
259 loose_edge_data[pos * 2 + 1] = show_vert(edge[1]) ? edge_range.last() : gpu::RESTART_INDEX;
260 });
261
262 MutableSpan loose_vert_data = data.take_back(visible_loose.size()).cast<int32_t>();
263 const int loose_verts_start = loose_geom_start + loose_edge_verts_num;
264 visible_loose.shift(loose_verts_start, memory).to_indices<int32_t>(loose_vert_data);
265
266 return gpu::IndexBufPtr(GPU_indexbuf_build_ex(&builder, 0, max_index, true));
267}
268
270 const DRWSubdivCache &subdiv_cache)
271{
272 const Span<int2> coarse_edges = mr.edges;
273 const IndexMask &loose_verts = mr.loose_verts;
274 const IndexMask &loose_edges = mr.loose_edges;
275 const int verts_per_edge = subdiv_verts_per_coarse_edge(subdiv_cache);
276 const int loose_edge_verts_num = verts_per_edge * loose_edges.size();
277
278 const Span<int> corner_orig_verts = subdiv_cache.verts_orig_index->data<int>();
279
280 const auto show_vert_bm = [&](const int vert_index) {
281 const BMVert *vert = mr.orig_index_vert ? bm_original_vert_get(mr, vert_index) :
282 BM_vert_at_index(mr.bm, vert_index);
284 };
285
286 IndexMaskMemory memory;
287 const IndexMask visible_corners = IndexMask::from_predicate(
288 corner_orig_verts.index_range(), memory, [&](const int i) {
289 return corner_orig_verts[i] != -1 && show_vert_bm(corner_orig_verts[i]);
290 });
291
292 const IndexMask visible_loose = IndexMask::from_predicate(
293 loose_verts.index_range(), memory, [&](const int vert) { return show_vert_bm(vert); });
294
295 const int max_index = subdiv_cache.num_subdiv_loops + loose_edge_verts_num + loose_verts.size();
296 GPUIndexBufBuilder builder;
297 GPU_indexbuf_init(&builder,
299 visible_corners.size() + loose_edges.size() * 2 + visible_loose.size(),
300 max_index);
302
303 visible_corners.to_indices<int32_t>(data.take_front(visible_corners.size()).cast<int32_t>());
304
305 MutableSpan loose_edge_data = data.slice(visible_corners.size(), loose_edges.size() * 2);
306 const int loose_geom_start = subdiv_cache.num_subdiv_loops;
307 for (const int i : loose_edges.index_range()) {
308 const int2 edge = coarse_edges[loose_edges[i]];
309 const IndexRange edge_range(loose_geom_start + i * verts_per_edge, verts_per_edge);
310 loose_edge_data[i * 2 + 0] = show_vert_bm(edge[0]) ? edge_range.first() : gpu::RESTART_INDEX;
311 loose_edge_data[i * 2 + 1] = show_vert_bm(edge[1]) ? edge_range.last() : gpu::RESTART_INDEX;
312 }
313
314 MutableSpan loose_vert_data = data.take_back(visible_loose.size()).cast<int32_t>();
315 const int loose_verts_start = loose_geom_start + loose_edge_verts_num;
316 visible_loose.shift(loose_verts_start, memory).to_indices<int32_t>(loose_vert_data);
317
318 return gpu::IndexBufPtr(GPU_indexbuf_build_ex(&builder, 0, max_index, true));
319}
320
322 const DRWSubdivCache &subdiv_cache)
323{
325 return extract_points_subdiv_mesh(mr, subdiv_cache);
326 }
327 return extract_points_subdiv_bm(mr, subdiv_cache);
328}
329
330} // namespace blender::draw
#define ORIGINDEX_NONE
#define BM_elem_index_get(ele)
#define BM_elem_flag_test_bool(ele, hflag)
int64_t size() const
Definition BLI_array.hh:267
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_bools_inverse(Span< bool > bools, LinearAllocator<> &memory)
constexpr int64_t first() const
constexpr int64_t last(const int64_t n=0) const
constexpr Span()=default
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
constexpr bool is_empty() const
MutableSpan< T > data()
IndexMask shift(const int64_t offset, LinearAllocator<> &memory) const
void to_indices(MutableSpan< T > r_indices) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
Extraction of Mesh data into VBO to feed to GPU.
IndexMask indices_non_negative(const IndexMask &universe, Span< int > values, LinearAllocator<> &memory)
BLI_INLINE BMVert * bm_original_vert_get(const MeshRenderData &mr, int idx)
static IndexMask calc_vert_visibility_mapped_mesh(const MeshRenderData &mr, const IndexMask &mask, const Span< int > map, IndexMaskMemory &memory)
int subdiv_verts_per_coarse_edge(const DRWSubdivCache &cache)
gpu::IndexBufPtr extract_points_subdiv(const MeshRenderData &mr, const DRWSubdivCache &subdiv_cache)
static void process_ibo_verts_mesh(const MeshRenderData &mr, const Fn &process_vert_fn)
static gpu::IndexBufPtr extract_points_subdiv_bm(const MeshRenderData &mr, const DRWSubdivCache &subdiv_cache)
static gpu::IndexBufPtr extract_points_bm(const MeshRenderData &mr)
static gpu::IndexBufPtr extract_points_mesh(const MeshRenderData &mr)
static void process_ibo_verts_bm(const MeshRenderData &mr, const Fn &process_vert_fn)
static IndexMask calc_vert_visibility_mesh(const MeshRenderData &mr, const IndexMask &mask, IndexMaskMemory &memory)
static gpu::IndexBufPtr extract_points_subdiv_mesh(const MeshRenderData &mr, const DRWSubdivCache &subdiv_cache)
gpu::IndexBufPtr extract_points(const MeshRenderData &mr)
constexpr ParallelGrainSize grain_size(int grain_size)
std::unique_ptr< IndexBuf, IndexBufDeleter > IndexBufPtr
constexpr uint32_t RESTART_INDEX
void build_reverse_map(const IndexMask &mask, MutableSpan< T > r_map)
Definition index_mask.cc:36
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
void memory_bandwidth_bound_task(const int64_t approximate_bytes_touched, const Function &function)
Definition BLI_task.hh:251
void GPU_indexbuf_init(GPUIndexBufBuilder *, GPUPrimType, uint prim_len, uint vertex_len)
BLI_INLINE BMEdge * BM_edge_at_index(BMesh *bm, const int index)
VecBase< int32_t, 2 > int2
BMesh const char void * data
BMLoop * BM_vert_find_first_loop(BMVert *v)
MutableSpan< uint32_t > GPU_indexbuf_get_data(GPUIndexBufBuilder *)
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
gpu::IndexBuf * GPU_indexbuf_build_ex(GPUIndexBufBuilder *builder, uint index_min, uint index_max, bool uses_restart_indices)
signed int int32_t
Definition BKE_text.h:78