archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Activity

Cleanup: API for MeshExtractRunTimeData.

Browse Source
This commit is contained in:
Jeroen Bakker
2021-06-01 12:59:15 +02:00
parent 98c6626729
commit f0d93a71df
3 changed files with 161 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

250
source/blender/draw/intern/draw_cache_extract_mesh.cc
View File

@@ -54,63 +54,80 @@ namespace blender::draw {
/** \name Mesh Elements Extract Struct
* \{ */
struct MeshExtractRunData {
struct ExtractorRunData {
/* Extractor where this run data belongs to. */
const MeshExtract *extractor;
void *buffer;
void *user_data;
/* During iteration the VBO/IBO that is being build. */
void *buffer = nullptr;
/* User data during iteration. Created in MeshExtract.init and passed along to other MeshExtract
* functions. */
void *user_data = nullptr;
ExtractorRunData(const MeshExtract *extractor) : extractor(extractor)
{
}
};
using MeshExtractRunDataArray = blender::Vector<MeshExtractRunData>;
static void mesh_extract_run_data_array_add(MeshExtractRunDataArray &array,
const MeshExtract *extractor)
{
MeshExtractRunData run_data;
run_data.extractor = extractor;
run_data.buffer = NULL;
run_data.user_data = NULL;
array.append(run_data);
}
static void mesh_extract_run_data_array_filter_iter_type(const MeshExtractRunDataArray &src,
MeshExtractRunDataArray &dst,
eMRIterType iter_type)
{
for (const MeshExtractRunData &data : src) {
const MeshExtract *extractor = data.extractor;
if ((iter_type & MR_ITER_LOOPTRI) && extractor->iter_looptri_bm) {
BLI_assert(extractor->iter_looptri_mesh);
dst.append(data);
continue;
}
if ((iter_type & MR_ITER_POLY) && extractor->iter_poly_bm) {
BLI_assert(extractor->iter_poly_mesh);
dst.append(data);
continue;
}
if ((iter_type & MR_ITER_LEDGE) && extractor->iter_ledge_bm) {
BLI_assert(extractor->iter_ledge_mesh);
dst.append(data);
continue;
}
if ((iter_type & MR_ITER_LVERT) && extractor->iter_lvert_bm) {
BLI_assert(extractor->iter_lvert_mesh);
dst.append(data);
continue;
class ExtractorRunDatas : public Vector<ExtractorRunData> {
public:
void filter_into(ExtractorRunDatas &result, eMRIterType iter_type) const
{
for (const ExtractorRunData &data : *this) {
const MeshExtract *extractor = data.extractor;
if ((iter_type & MR_ITER_LOOPTRI) && extractor->iter_looptri_bm) {
BLI_assert(extractor->iter_looptri_mesh);
result.append(data);
continue;
}
if ((iter_type & MR_ITER_POLY) && extractor->iter_poly_bm) {
BLI_assert(extractor->iter_poly_mesh);
result.append(data);
continue;
}
if ((iter_type & MR_ITER_LEDGE) && extractor->iter_ledge_bm) {
BLI_assert(extractor->iter_ledge_mesh);
result.append(data);
continue;
}
if ((iter_type & MR_ITER_LVERT) && extractor->iter_lvert_bm) {
BLI_assert(extractor->iter_lvert_mesh);
result.append(data);
continue;
}
}
}
}
static void mesh_extract_run_data_array_filter_threading(
const MeshExtractRunDataArray &src, MeshExtractRunDataArray &dst_multi_threaded)
{
for (const MeshExtractRunData &data : src) {
const MeshExtract *extractor = data.extractor;
if (extractor->use_threading) {
mesh_extract_run_data_array_add(dst_multi_threaded, extractor);
void filter_threaded_extractors_into(ExtractorRunDatas &result)
{
for (const ExtractorRunData &data : *this) {
const MeshExtract *extractor = data.extractor;
if (extractor->use_threading) {
result.append(extractor);
}
}
}
}
eMRIterType iter_types()
{
eMRIterType iter_type = static_cast<eMRIterType>(0);
for (const ExtractorRunData &data : *this) {
const MeshExtract *extractor = data.extractor;
iter_type |= mesh_extract_iter_type(extractor);
}
return iter_type;
}
eMRDataType data_types()
{
eMRDataType data_type = static_cast<eMRDataType>(0);
for (const ExtractorRunData &data : *this) {
const MeshExtract *extractor = data.extractor;
data_type |= extractor->data_type;
}
return data_type;
}
};
/** \} */
@@ -118,34 +135,13 @@ static void mesh_extract_run_data_array_filter_threading(
/** \name Extract
* \{ */
static void extracts_flags_get(const MeshExtractRunDataArray &extractors,
eMRIterType *r_iter_type,
eMRDataType *r_data_flag)
{
eMRIterType iter_type = static_cast<eMRIterType>(0);
eMRDataType data_flag = static_cast<eMRDataType>(0);
for (const MeshExtractRunData &data : extractors) {
const MeshExtract *extractor = data.extractor;
iter_type |= mesh_extract_iter_type(extractor);
data_flag |= extractor->data_flag;
}
if (r_iter_type) {
*r_iter_type = iter_type;
}
if (r_data_flag) {
*r_data_flag = data_flag;
}
}
BLI_INLINE void extract_init(const MeshRenderData *mr,
struct MeshBatchCache *cache,
MeshExtractRunDataArray &extractors,
ExtractorRunDatas &extractors,
MeshBufferCache *mbc)
{
/* Multi thread. */
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
const MeshExtract *extractor = run_data.extractor;
run_data.buffer = mesh_extract_buffer_get(extractor, mbc);
run_data.user_data = extractor->init(mr, cache, run_data.buffer);
@@ -154,14 +150,14 @@ BLI_INLINE void extract_init(const MeshRenderData *mr,
BLI_INLINE void extract_iter_looptri_bm(const MeshRenderData *mr,
const ExtractTriBMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LOOPTRI);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LOOPTRI);
EXTRACT_TRIS_LOOPTRI_FOREACH_BM_BEGIN(elt, elt_index, params)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_looptri_bm(mr, elt, elt_index, run_data.user_data);
}
}
@@ -170,14 +166,14 @@ BLI_INLINE void extract_iter_looptri_bm(const MeshRenderData *mr,
BLI_INLINE void extract_iter_looptri_mesh(const MeshRenderData *mr,
const ExtractTriMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LOOPTRI);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LOOPTRI);
EXTRACT_TRIS_LOOPTRI_FOREACH_MESH_BEGIN(mlt, mlt_index, params)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_looptri_mesh(mr, mlt, mlt_index, run_data.user_data);
}
}
@@ -186,14 +182,14 @@ BLI_INLINE void extract_iter_looptri_mesh(const MeshRenderData *mr,
BLI_INLINE void extract_iter_poly_bm(const MeshRenderData *mr,
const ExtractPolyBMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_POLY);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_POLY);
EXTRACT_POLY_FOREACH_BM_BEGIN(f, f_index, params, mr)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_poly_bm(mr, f, f_index, run_data.user_data);
}
}
@@ -202,14 +198,14 @@ BLI_INLINE void extract_iter_poly_bm(const MeshRenderData *mr,
BLI_INLINE void extract_iter_poly_mesh(const MeshRenderData *mr,
const ExtractPolyMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_POLY);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_POLY);
EXTRACT_POLY_FOREACH_MESH_BEGIN(mp, mp_index, params, mr)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_poly_mesh(mr, mp, mp_index, run_data.user_data);
}
}
@@ -218,14 +214,14 @@ BLI_INLINE void extract_iter_poly_mesh(const MeshRenderData *mr,
BLI_INLINE void extract_iter_ledge_bm(const MeshRenderData *mr,
const ExtractLEdgeBMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LEDGE);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LEDGE);
EXTRACT_LEDGE_FOREACH_BM_BEGIN(eed, ledge_index, params)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_ledge_bm(mr, eed, ledge_index, run_data.user_data);
}
}
@@ -234,14 +230,14 @@ BLI_INLINE void extract_iter_ledge_bm(const MeshRenderData *mr,
BLI_INLINE void extract_iter_ledge_mesh(const MeshRenderData *mr,
const ExtractLEdgeMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LEDGE);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LEDGE);
EXTRACT_LEDGE_FOREACH_MESH_BEGIN(med, ledge_index, params, mr)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_ledge_mesh(mr, med, ledge_index, run_data.user_data);
}
}
@@ -250,14 +246,14 @@ BLI_INLINE void extract_iter_ledge_mesh(const MeshRenderData *mr,
BLI_INLINE void extract_iter_lvert_bm(const MeshRenderData *mr,
const ExtractLVertBMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LVERT);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LVERT);
EXTRACT_LVERT_FOREACH_BM_BEGIN(eve, lvert_index, params)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_lvert_bm(mr, eve, lvert_index, run_data.user_data);
}
}
@@ -266,14 +262,14 @@ BLI_INLINE void extract_iter_lvert_bm(const MeshRenderData *mr,
BLI_INLINE void extract_iter_lvert_mesh(const MeshRenderData *mr,
const ExtractLVertMesh_Params *params,
const MeshExtractRunDataArray &all_extractors)
const ExtractorRunDatas &all_extractors)
{
MeshExtractRunDataArray extractors;
mesh_extract_run_data_array_filter_iter_type(all_extractors, extractors, MR_ITER_LVERT);
ExtractorRunDatas extractors;
all_extractors.filter_into(extractors, MR_ITER_LVERT);
EXTRACT_LVERT_FOREACH_MESH_BEGIN(mv, lvert_index, params, mr)
{
for (MeshExtractRunData &run_data : extractors) {
for (ExtractorRunData &run_data : extractors) {
run_data.extractor->iter_lvert_mesh(mr, mv, lvert_index, run_data.user_data);
}
}
@@ -282,9 +278,9 @@ BLI_INLINE void extract_iter_lvert_mesh(const MeshRenderData *mr,
BLI_INLINE void extract_finish(const MeshRenderData *mr,
struct MeshBatchCache *cache,
const MeshExtractRunDataArray &extractors)
const ExtractorRunDatas &extractors)
{
for (const MeshExtractRunData &run_data : extractors) {
for (const ExtractorRunData &run_data : extractors) {
const MeshExtract *extractor = run_data.extractor;
if (extractor->finish) {
extractor->finish(mr, cache, run_data.buffer, run_data.user_data);
@@ -295,7 +291,7 @@ BLI_INLINE void extract_finish(const MeshRenderData *mr,
/* Single Thread. */
BLI_INLINE void extract_run_and_finish_init(const MeshRenderData *mr,
struct MeshBatchCache *cache,
MeshExtractRunDataArray &extractors,
ExtractorRunDatas &extractors,
eMRIterType iter_type,
MeshBufferCache *mbc)
{
@@ -385,7 +381,7 @@ struct ExtractTaskData {
* This structure makes sure that when extract_init is called, that the user data of all
* iterations are updated. */
MeshExtractRunDataArray *extractors = nullptr;
ExtractorRunDatas *extractors = nullptr;
MeshBufferCache *mbc = nullptr;
int32_t *task_counter = nullptr;
@@ -396,12 +392,12 @@ struct ExtractTaskData {
ExtractTaskData(const MeshRenderData *mr,
struct MeshBatchCache *cache,
MeshExtractRunDataArray *extractors,
ExtractorRunDatas *extractors,
MeshBufferCache *mbc,
int32_t *task_counter)
: mr(mr), cache(cache), extractors(extractors), mbc(mbc), task_counter(task_counter)
{
extracts_flags_get(*extractors, &iter_type, NULL);
iter_type = extractors->iter_types();
};
ExtractTaskData(const ExtractTaskData &src) = default;
@@ -416,12 +412,11 @@ struct ExtractTaskData {
#endif
};
static ExtractTaskData *extract_extract_iter_task_data_create_mesh(
const MeshRenderData *mr,
MeshBatchCache *cache,
MeshExtractRunDataArray *extractors,
MeshBufferCache *mbc,
int32_t *task_counter)
static ExtractTaskData *extract_extract_iter_task_data_create_mesh(const MeshRenderData *mr,
MeshBatchCache *cache,
ExtractorRunDatas *extractors,
MeshBufferCache *mbc,
int32_t *task_counter)
{
ExtractTaskData *taskdata = new ExtractTaskData(mr, cache, extractors, mbc, task_counter);
@@ -445,7 +440,7 @@ BLI_INLINE void mesh_extract_iter(const MeshRenderData *mr,
const eMRIterType iter_type,
int start,
int end,
MeshExtractRunDataArray &extractors)
ExtractorRunDatas &extractors)
{
switch (mr->extract_type) {
case MR_EXTRACT_BMESH:
@@ -791,14 +786,14 @@ static void mesh_buffer_cache_create_requested(struct TaskGraph *task_graph,
GPU_use_hq_normals_workaround();
/* Create an array containing all the extractors that needs to be executed. */
MeshExtractRunDataArray extractors;
ExtractorRunDatas extractors;
#define EXTRACT_ADD_REQUESTED(type, type_lowercase, name) \
do { \
if (DRW_##type_lowercase##_requested(mbc->type_lowercase.name)) { \
const MeshExtract *extractor = mesh_extract_override_get( \
&extract_##name, do_hq_normals, do_lines_loose_subbuffer); \
mesh_extract_run_data_array_add(extractors, extractor); \
extractors.append(extractor); \
} \
} while (0)
@@ -847,9 +842,8 @@ static void mesh_buffer_cache_create_requested(struct TaskGraph *task_graph,
double rdata_start = PIL_check_seconds_timer();
#endif
eMRIterType iter_type;
eMRDataType data_flag;
extracts_flags_get(extractors, &iter_type, &data_flag);
eMRIterType iter_type = extractors.iter_types();
eMRDataType data_flag = extractors.data_types();
MeshRenderData *mr = mesh_render_data_create(me,
extraction_cache,
@@ -880,11 +874,11 @@ static void mesh_buffer_cache_create_requested(struct TaskGraph *task_graph,
uint threads_to_use = 0;
/* First run the requested extractors that do not support asynchronous ranges. */
for (const MeshExtractRunData &run_data : extractors) {
for (const ExtractorRunData &run_data : extractors) {
const MeshExtract *extractor = run_data.extractor;
if (!extractor->use_threading) {
MeshExtractRunDataArray *single_threaded_extractors = new MeshExtractRunDataArray();
mesh_extract_run_data_array_add(*single_threaded_extractors, extractor);
ExtractorRunDatas *single_threaded_extractors = new ExtractorRunDatas();
single_threaded_extractors->append(extractor);
ExtractTaskData *taskdata = extract_extract_iter_task_data_create_mesh(
mr, cache, single_threaded_extractors, mbc, NULL);
struct TaskNode *task_node = extract_single_threaded_task_node_create(task_graph,
@@ -895,8 +889,8 @@ static void mesh_buffer_cache_create_requested(struct TaskGraph *task_graph,
}
/* Distribute the remaining extractors into ranges per core. */
MeshExtractRunDataArray *multi_threaded_extractors = new MeshExtractRunDataArray();
mesh_extract_run_data_array_filter_threading(extractors, *multi_threaded_extractors);
ExtractorRunDatas *multi_threaded_extractors = new ExtractorRunDatas();
extractors.filter_threaded_extractors_into(*multi_threaded_extractors);
if (!multi_threaded_extractors->is_empty()) {
/*
* Determine the number of thread to use for multithreading.
@@ -927,7 +921,7 @@ static void mesh_buffer_cache_create_requested(struct TaskGraph *task_graph,
}
else {
/* Run all requests on the same thread. */
MeshExtractRunDataArray *extractors_copy = new MeshExtractRunDataArray(extractors);
ExtractorRunDatas *extractors_copy = new ExtractorRunDatas(extractors);
ExtractTaskData *taskdata = extract_extract_iter_task_data_create_mesh(
mr, cache, extractors_copy, mbc, NULL);

76
source/blender/draw/intern/draw_cache_extract_mesh_extractors.c
View File

@@ -246,7 +246,7 @@ const MeshExtract extract_tris = {.init = extract_tris_init,
.iter_looptri_bm = extract_tris_iter_looptri_bm,
.iter_looptri_mesh = extract_tris_iter_looptri_mesh,
.finish = extract_tris_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.tris)};
@@ -375,7 +375,7 @@ const MeshExtract extract_lines = {.init = extract_lines_init,
.iter_ledge_bm = extract_lines_iter_ledge_bm,
.iter_ledge_mesh = extract_lines_iter_ledge_mesh,
.finish = extract_lines_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines)};
@@ -414,7 +414,7 @@ const MeshExtract extract_lines_with_lines_loose = {
.iter_ledge_bm = extract_lines_iter_ledge_bm,
.iter_ledge_mesh = extract_lines_iter_ledge_mesh,
.finish = extract_lines_with_lines_loose_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines)};
@@ -542,7 +542,7 @@ const MeshExtract extract_points = {.init = extract_points_init,
.iter_lvert_bm = extract_points_iter_lvert_bm,
.iter_lvert_mesh = extract_points_iter_lvert_mesh,
.finish = extract_points_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.points)};
@@ -617,7 +617,7 @@ const MeshExtract extract_fdots = {.init = extract_fdots_init,
.iter_poly_bm = extract_fdots_iter_poly_bm,
.iter_poly_mesh = extract_fdots_iter_poly_mesh,
.finish = extract_fdots_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.fdots)};
@@ -700,7 +700,7 @@ const MeshExtract extract_lines_paint_mask = {
.init = extract_lines_paint_mask_init,
.iter_poly_mesh = extract_lines_paint_mask_iter_poly_mesh,
.finish = extract_lines_paint_mask_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines_paint_mask)};
@@ -852,7 +852,7 @@ const MeshExtract extract_lines_adjacency = {
.iter_looptri_bm = extract_lines_adjacency_iter_looptri_bm,
.iter_looptri_mesh = extract_lines_adjacency_iter_looptri_mesh,
.finish = extract_lines_adjacency_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines_adjacency)};
@@ -928,7 +928,7 @@ const MeshExtract extract_edituv_tris = {
.iter_looptri_bm = extract_edituv_tris_iter_looptri_bm,
.iter_looptri_mesh = extract_edituv_tris_iter_looptri_mesh,
.finish = extract_edituv_tris_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.edituv_tris)};
@@ -1012,7 +1012,7 @@ const MeshExtract extract_edituv_lines = {
.iter_poly_bm = extract_edituv_lines_iter_poly_bm,
.iter_poly_mesh = extract_edituv_lines_iter_poly_mesh,
.finish = extract_edituv_lines_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.edituv_lines)};
@@ -1091,7 +1091,7 @@ const MeshExtract extract_edituv_points = {
.iter_poly_bm = extract_edituv_points_iter_poly_bm,
.iter_poly_mesh = extract_edituv_points_iter_poly_mesh,
.finish = extract_edituv_points_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.edituv_points)};
@@ -1182,7 +1182,7 @@ const MeshExtract extract_edituv_fdots = {
.iter_poly_bm = extract_edituv_fdots_iter_poly_bm,
.iter_poly_mesh = extract_edituv_fdots_iter_poly_mesh,
.finish = extract_edituv_fdots_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.edituv_fdots)};
@@ -1362,7 +1362,7 @@ const MeshExtract extract_pos_nor = {.init = extract_pos_nor_init,
.iter_lvert_bm = extract_pos_nor_iter_lvert_bm,
.iter_lvert_mesh = extract_pos_nor_iter_lvert_mesh,
.finish = extract_pos_nor_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.pos_nor)};
@@ -1550,7 +1550,7 @@ const MeshExtract extract_pos_nor_hq = {
.iter_lvert_bm = extract_pos_nor_hq_iter_lvert_bm,
.iter_lvert_mesh = extract_pos_nor_hq_iter_lvert_mesh,
.finish = extract_pos_nor_hq_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.pos_nor)};
@@ -1641,7 +1641,7 @@ static void extract_lnor_hq_iter_poly_mesh(const MeshRenderData *mr,
const MeshExtract extract_lnor_hq = {.init = extract_lnor_hq_init,
.iter_poly_bm = extract_lnor_hq_iter_poly_bm,
.iter_poly_mesh = extract_lnor_hq_iter_poly_mesh,
.data_flag = MR_DATA_LOOP_NOR,
.data_type = MR_DATA_LOOP_NOR,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.lnor)};
@@ -1730,7 +1730,7 @@ static void extract_lnor_iter_poly_mesh(const MeshRenderData *mr,
const MeshExtract extract_lnor = {.init = extract_lnor_init,
.iter_poly_bm = extract_lnor_iter_poly_bm,
.iter_poly_mesh = extract_lnor_iter_poly_mesh,
.data_flag = MR_DATA_LOOP_NOR,
.data_type = MR_DATA_LOOP_NOR,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.lnor)};
@@ -1825,7 +1825,7 @@ static void *extract_uv_init(const MeshRenderData *mr, struct MeshBatchCache *ca
}
const MeshExtract extract_uv = {.init = extract_uv_init,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.uv)};
@@ -2014,7 +2014,7 @@ static void *extract_tan_init(const MeshRenderData *mr, struct MeshBatchCache *c
}
const MeshExtract extract_tan = {.init = extract_tan_init,
.data_flag = MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR |
.data_type = MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR |
MR_DATA_LOOPTRI,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.tan)};
@@ -2033,7 +2033,7 @@ static void *extract_tan_hq_init(const MeshRenderData *mr, struct MeshBatchCache
const MeshExtract extract_tan_hq = {
.init = extract_tan_hq_init,
.data_flag = MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR | MR_DATA_LOOPTRI,
.data_type = MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR | MR_DATA_LOOPTRI,
.use_threading = false,
};
@@ -2132,7 +2132,7 @@ static void *extract_sculpt_data_init(const MeshRenderData *mr,
const MeshExtract extract_sculpt_data = {
.init = extract_sculpt_data_init,
.data_flag = 0,
.data_type = 0,
/* TODO: enable threading. */
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.sculpt_data)};
@@ -2280,7 +2280,7 @@ static void *extract_vcol_init(const MeshRenderData *mr, struct MeshBatchCache *
}
const MeshExtract extract_vcol = {.init = extract_vcol_init,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.vcol)};
@@ -2366,7 +2366,7 @@ const MeshExtract extract_orco = {.init = extract_orco_init,
.iter_poly_bm = extract_orco_iter_poly_bm,
.iter_poly_mesh = extract_orco_iter_poly_mesh,
.finish = extract_orco_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.orco)};
@@ -2567,7 +2567,7 @@ const MeshExtract extract_edge_fac = {
.iter_ledge_bm = extract_edge_fac_iter_ledge_bm,
.iter_ledge_mesh = extract_edge_fac_iter_ledge_mesh,
.finish = extract_edge_fac_finish,
.data_flag = MR_DATA_POLY_NOR,
.data_type = MR_DATA_POLY_NOR,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edge_fac)};
@@ -2721,7 +2721,7 @@ const MeshExtract extract_weights = {.init = extract_weights_init,
.iter_poly_bm = extract_weights_iter_poly_bm,
.iter_poly_mesh = extract_weights_iter_poly_mesh,
.finish = extract_weights_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.weights)};
@@ -3000,7 +3000,7 @@ const MeshExtract extract_edit_data = {
.iter_ledge_mesh = extract_edit_data_iter_ledge_mesh,
.iter_lvert_bm = extract_edit_data_iter_lvert_bm,
.iter_lvert_mesh = extract_edit_data_iter_lvert_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edit_data)};
@@ -3111,7 +3111,7 @@ const MeshExtract extract_edituv_data = {
.iter_poly_bm = extract_edituv_data_iter_poly_bm,
.iter_poly_mesh = extract_edituv_data_iter_poly_mesh,
.finish = extract_edituv_data_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edituv_data)};
@@ -3227,7 +3227,7 @@ static void extract_edituv_stretch_area_finish(const MeshRenderData *mr,
const MeshExtract extract_edituv_stretch_area = {
.init = extract_edituv_stretch_area_init,
.finish = extract_edituv_stretch_area_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edituv_stretch_area)};
@@ -3430,7 +3430,7 @@ const MeshExtract extract_edituv_stretch_angle = {
.iter_poly_bm = extract_edituv_stretch_angle_iter_poly_bm,
.iter_poly_mesh = extract_edituv_stretch_angle_iter_poly_mesh,
.finish = extract_edituv_stretch_angle_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edituv_stretch_angle)};
@@ -4037,7 +4037,7 @@ const MeshExtract extract_mesh_analysis = {
.finish = extract_analysis_iter_finish_mesh,
/* This is not needed for all visualization types.
* * Maybe split into different extract. */
.data_flag = MR_DATA_POLY_NOR | MR_DATA_LOOPTRI,
.data_type = MR_DATA_POLY_NOR | MR_DATA_LOOPTRI,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.mesh_analysis)};
@@ -4117,7 +4117,7 @@ const MeshExtract extract_fdots_pos = {
.init = extract_fdots_pos_init,
.iter_poly_bm = extract_fdots_pos_iter_poly_bm,
.iter_poly_mesh = extract_fdots_pos_iter_poly_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdots_pos)};
@@ -4199,7 +4199,7 @@ static void extract_fdots_nor_finish(const MeshRenderData *mr,
const MeshExtract extract_fdots_nor = {
.init = extract_fdots_nor_init,
.finish = extract_fdots_nor_finish,
.data_flag = MR_DATA_POLY_NOR,
.data_type = MR_DATA_POLY_NOR,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdots_nor)};
@@ -4276,7 +4276,7 @@ static void extract_fdots_nor_hq_finish(const MeshRenderData *mr,
const MeshExtract extract_fdots_nor_hq = {
.init = extract_fdots_nor_hq_init,
.finish = extract_fdots_nor_hq_finish,
.data_flag = MR_DATA_POLY_NOR,
.data_type = MR_DATA_POLY_NOR,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdots_nor)};
@@ -4375,7 +4375,7 @@ const MeshExtract extract_fdots_uv = {
.iter_poly_bm = extract_fdots_uv_iter_poly_bm,
.iter_poly_mesh = extract_fdots_uv_iter_poly_mesh,
.finish = extract_fdots_uv_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdots_uv)};
@@ -4447,7 +4447,7 @@ const MeshExtract extract_fdots_edituv_data = {
.iter_poly_bm = extract_fdots_edituv_data_iter_poly_bm,
.iter_poly_mesh = extract_fdots_edituv_data_iter_poly_mesh,
.finish = extract_fdots_edituv_data_finish,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdots_edituv_data)};
@@ -4504,7 +4504,7 @@ static void *extract_skin_roots_init(const MeshRenderData *mr,
const MeshExtract extract_skin_roots = {
.init = extract_skin_roots_init,
.data_flag = 0,
.data_type = 0,
.use_threading = false,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.skin_roots)};
@@ -4676,7 +4676,7 @@ const MeshExtract extract_poly_idx = {
.init = extract_select_idx_init,
.iter_poly_bm = extract_poly_idx_iter_poly_bm,
.iter_poly_mesh = extract_poly_idx_iter_poly_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.poly_idx)};
@@ -4686,7 +4686,7 @@ const MeshExtract extract_edge_idx = {
.iter_poly_mesh = extract_edge_idx_iter_poly_mesh,
.iter_ledge_bm = extract_edge_idx_iter_ledge_bm,
.iter_ledge_mesh = extract_edge_idx_iter_ledge_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.edge_idx)};
@@ -4698,7 +4698,7 @@ const MeshExtract extract_vert_idx = {
.iter_ledge_mesh = extract_vert_idx_iter_ledge_mesh,
.iter_lvert_bm = extract_vert_idx_iter_lvert_bm,
.iter_lvert_mesh = extract_vert_idx_iter_lvert_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.vert_idx)};
@@ -4743,6 +4743,6 @@ const MeshExtract extract_fdot_idx = {
.init = extract_fdot_idx_init,
.iter_poly_bm = extract_fdot_idx_iter_poly_bm,
.iter_poly_mesh = extract_fdot_idx_iter_poly_mesh,
.data_flag = 0,
.data_type = 0,
.use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, vbo.fdot_idx)};

2
source/blender/draw/intern/draw_cache_extract_mesh_private.h
View File

@@ -430,7 +430,7 @@ typedef struct MeshExtract {
/** Executed on one worker thread after all elements iterations. */
ExtractFinishFn *finish;
/** Used to request common data. */
const eMRDataType data_flag;
const eMRDataType data_type;
/** Used to know if the element callbacks are thread-safe and can be parallelized. */
const bool use_threading;
/**