Page MenuHome
Differential D11509 Diff 37898 source/blender/draw/intern/draw_cache_extract_mesh_extractors.c

Changeset View

Standalone View

View Options

source/blender/draw/intern/draw_cache_extract_mesh_extractors.c

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/** \name Extract Edges Indices /** \name Extract Edges Indices
* \{ */ * \{ */
static void *extract_lines_init(const MeshRenderData *mr, static void *extract_lines_init(const MeshRenderData *mr,
struct MeshBatchCache *UNUSED(cache), struct MeshBatchCache *UNUSED(cache),
void *UNUSED(buf)) void *UNUSED(buf))
{ {
GPUIndexBufBuilder *elb = MEM_mallocN(sizeof(*elb), __func__); GPUIndexBufBuilderAsync *elb_async = MEM_mallocN(sizeof(*elb_async), __func__);
/* Put loose edges at the end. */ /* Put loose edges at the end. */
GPU_indexbuf_init( GPU_indexbuf_async_init(elb_async,
elb, GPU_PRIM_LINES, mr->edge_len + mr->edge_loose_len, mr->loop_len + mr->loop_loose_len); GPU_PRIM_LINES,
return elb; mr->edge_len + mr->edge_loose_len,
mr->loop_len + mr->loop_loose_len);
return elb_async;
} }
static void extract_lines_iter_poly_bm(const MeshRenderData *UNUSED(mr), static void extract_lines_iter_poly_bm(const MeshRenderData *UNUSED(mr),
BMFace *f, BMFace *f,
const int UNUSED(f_index), const int UNUSED(f_index),
void *elb) void *elb_async)
{ {
BMLoop *l_iter, *l_first; BMLoop *l_iter, *l_first;
/* Use #BMLoop.prev to match mesh order (to avoid minor differences in data extraction). */ /* Use #BMLoop.prev to match mesh order (to avoid minor differences in data extraction). */
l_iter = l_first = BM_FACE_FIRST_LOOP(f)->prev; l_iter = l_first = BM_FACE_FIRST_LOOP(f)->prev;
do { do {
if (!BM_elem_flag_test(l_iter->e, BM_ELEM_HIDDEN)) { if (!BM_elem_flag_test(l_iter->e, BM_ELEM_HIDDEN)) {
GPU_indexbuf_set_line_verts(elb, GPU_indexbuf_async_set_line_verts(elb_async,
BM_elem_index_get(l_iter->e), BM_elem_index_get(l_iter->e),
BM_elem_index_get(l_iter), BM_elem_index_get(l_iter),
BM_elem_index_get(l_iter->next)); BM_elem_index_get(l_iter->next));
} }
else { else {
GPU_indexbuf_set_line_restart(elb, BM_elem_index_get(l_iter->e)); GPU_indexbuf_async_set_line_restart(elb_async, BM_elem_index_get(l_iter->e));
} }
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);
} }
static void extract_lines_iter_poly_mesh(const MeshRenderData *mr, static void extract_lines_iter_poly_mesh(const MeshRenderData *mr,
const MPoly *mp, const MPoly *mp,
const int UNUSED(mp_index), const int UNUSED(mp_index),
void *elb) void *elb_async)
{ {
/* Using poly & loop iterator would complicate accessing the adjacent loop. */ /* Using poly & loop iterator would complicate accessing the adjacent loop. */
const MLoop *mloop = mr->mloop; const MLoop *mloop = mr->mloop;
const MEdge *medge = mr->medge; const MEdge *medge = mr->medge;
if (mr->use_hide || (mr->extract_type == MR_EXTRACT_MAPPED) || (mr->e_origindex != NULL)) { if (mr->use_hide || (mr->extract_type == MR_EXTRACT_MAPPED) || (mr->e_origindex != NULL)) {
const int ml_index_last = mp->loopstart + (mp->totloop - 1); const int ml_index_last = mp->loopstart + (mp->totloop - 1);
int ml_index = ml_index_last, ml_index_next = mp->loopstart; int ml_index = ml_index_last, ml_index_next = mp->loopstart;
do { do {
const MLoop *ml = &mloop[ml_index]; const MLoop *ml = &mloop[ml_index];
const MEdge *med = &medge[ml->e]; const MEdge *med = &medge[ml->e];
if (!((mr->use_hide && (med->flag & ME_HIDE)) || if (!((mr->use_hide && (med->flag & ME_HIDE)) ||
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) && ((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) &&
(mr->e_origindex[ml->e] == ORIGINDEX_NONE)))) { (mr->e_origindex[ml->e] == ORIGINDEX_NONE)))) {
GPU_indexbuf_set_line_verts(elb, ml->e, ml_index, ml_index_next); GPU_indexbuf_async_set_line_verts(elb_async, ml->e, ml_index, ml_index_next);
} }
else { else {
GPU_indexbuf_set_line_restart(elb, ml->e); GPU_indexbuf_async_set_line_restart(elb_async, ml->e);
} }
} while ((ml_index = ml_index_next++) != ml_index_last); } while ((ml_index = ml_index_next++) != ml_index_last);
} }
else { else {
const int ml_index_last = mp->loopstart + (mp->totloop - 1); const int ml_index_last = mp->loopstart + (mp->totloop - 1);
int ml_index = ml_index_last, ml_index_next = mp->loopstart; int ml_index = ml_index_last, ml_index_next = mp->loopstart;
do { do {
const MLoop *ml = &mloop[ml_index]; const MLoop *ml = &mloop[ml_index];
GPU_indexbuf_set_line_verts(elb, ml->e, ml_index, ml_index_next); GPU_indexbuf_async_set_line_verts(elb_async, ml->e, ml_index, ml_index_next);
} while ((ml_index = ml_index_next++) != ml_index_last); } while ((ml_index = ml_index_next++) != ml_index_last);
} }
} }
static void extract_lines_iter_ledge_bm(const MeshRenderData *mr, static void extract_lines_iter_ledge_bm(const MeshRenderData *mr,
BMEdge *eed, BMEdge *eed,
const int ledge_index, const int ledge_index,
void *elb) void *elb_async)
{ {
const int l_index_offset = mr->edge_len + ledge_index; const int l_index_offset = mr->edge_len + ledge_index;
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
const int l_index = mr->loop_len + ledge_index * 2; const int l_index = mr->loop_len + ledge_index * 2;
GPU_indexbuf_set_line_verts(elb, l_index_offset, l_index, l_index + 1); GPU_indexbuf_async_set_line_verts(elb_async, l_index_offset, l_index, l_index + 1);
} }
else { else {
GPU_indexbuf_set_line_restart(elb, l_index_offset); GPU_indexbuf_async_set_line_restart(elb_async, l_index_offset);
} }
/* Don't render the edge twice. */ /* Don't render the edge twice. */
GPU_indexbuf_set_line_restart(elb, BM_elem_index_get(eed)); GPU_indexbuf_async_set_line_restart(elb_async, BM_elem_index_get(eed));
} }
static void extract_lines_iter_ledge_mesh(const MeshRenderData *mr, static void extract_lines_iter_ledge_mesh(const MeshRenderData *mr,
const MEdge *med, const MEdge *med,
const uint ledge_index, const uint ledge_index,
void *elb) void *elb_async)
{ {
const int l_index_offset = mr->edge_len + ledge_index; const int l_index_offset = mr->edge_len + ledge_index;
const int e_index = mr->ledges[ledge_index]; const int e_index = mr->ledges[ledge_index];
if (!((mr->use_hide && (med->flag & ME_HIDE)) || if (!((mr->use_hide && (med->flag & ME_HIDE)) ||
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) && ((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) &&
(mr->e_origindex[e_index] == ORIGINDEX_NONE)))) { (mr->e_origindex[e_index] == ORIGINDEX_NONE)))) {
const int l_index = mr->loop_len + ledge_index * 2; const int l_index = mr->loop_len + ledge_index * 2;
GPU_indexbuf_set_line_verts(elb, l_index_offset, l_index, l_index + 1); GPU_indexbuf_async_set_line_verts(elb_async, l_index_offset, l_index, l_index + 1);
} }
else { else {
GPU_indexbuf_set_line_restart(elb, l_index_offset); GPU_indexbuf_async_set_line_restart(elb_async, l_index_offset);
} }
/* Don't render the edge twice. */ /* Don't render the edge twice. */
GPU_indexbuf_set_line_restart(elb, e_index); GPU_indexbuf_async_set_line_restart(elb_async, e_index);
} }
static void extract_lines_finish(const MeshRenderData *UNUSED(mr), static void extract_lines_finish(const MeshRenderData *UNUSED(mr),
struct MeshBatchCache *UNUSED(cache), struct MeshBatchCache *UNUSED(cache),
void *buf, void *buf,
void *elb) void *elb_async)
{ {
GPUIndexBuf *ibo = buf; GPUIndexBuf *ibo = buf;
GPU_indexbuf_build_in_place(elb, ibo); GPU_indexbuf_async_build_in_place(elb_async, ibo);
MEM_freeN(elb); MEM_freeN(elb_async);
} }
const MeshExtract extract_lines = { const MeshExtract extract_lines = {
.init = extract_lines_init, .init = extract_lines_init,
.iter_poly_bm = extract_lines_iter_poly_bm, .iter_poly_bm = extract_lines_iter_poly_bm,
.iter_poly_mesh = extract_lines_iter_poly_mesh, .iter_poly_mesh = extract_lines_iter_poly_mesh,
.iter_ledge_bm = extract_lines_iter_ledge_bm, .iter_ledge_bm = extract_lines_iter_ledge_bm,
.iter_ledge_mesh = extract_lines_iter_ledge_mesh, .iter_ledge_mesh = extract_lines_iter_ledge_mesh,
.finish = extract_lines_finish, .finish = extract_lines_finish,
.data_type = 0, .data_type = 0,
.use_threading = false, .use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines), .mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines),
}; };
/** \} */ /** \} */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/** \name Extract Loose Edges Sub Buffer /** \name Extract Loose Edges Sub Buffer
* \{ */ * \{ */
static void extract_lines_loose_subbuffer(const MeshRenderData *mr, struct MeshBatchCache *cache) static void extract_lines_loose_subbuffer(const MeshRenderData *mr, struct MeshBatchCache *cache)
{ {
BLI_assert(cache->final.ibo.lines); BLI_assert(cache->final.ibo.lines);
/* Multiply by 2 because these are edges indices. */ /* Multiply by 2 because these are edges indices. */
const int start = mr->edge_len * 2; const int start = mr->edge_len * 2;
const int len = mr->edge_loose_len * 2; const int len = mr->edge_loose_len * 2;
GPU_indexbuf_create_subrange_in_place( GPU_indexbuf_create_subrange_in_place(
cache->final.ibo.lines_loose, cache->final.ibo.lines, start, len); cache->final.ibo.lines_loose, cache->final.ibo.lines, start, len);
cache->no_loose_wire = (len == 0); cache->no_loose_wire = (len == 0);
} }
static void extract_lines_with_lines_loose_finish(const MeshRenderData *mr, static void extract_lines_with_lines_loose_finish(const MeshRenderData *mr,
struct MeshBatchCache *cache, struct MeshBatchCache *cache,
void *buf, void *buf,
void *elb) void *elb_async)
{ {
GPUIndexBuf *ibo = buf; GPUIndexBuf *ibo = buf;
GPU_indexbuf_build_in_place(elb, ibo); GPU_indexbuf_async_build_in_place(elb_async, ibo);
extract_lines_loose_subbuffer(mr, cache); extract_lines_loose_subbuffer(mr, cache);
MEM_freeN(elb); MEM_freeN(elb_async);
} }
const MeshExtract extract_lines_with_lines_loose = { const MeshExtract extract_lines_with_lines_loose = {
.init = extract_lines_init, .init = extract_lines_init,
.iter_poly_bm = extract_lines_iter_poly_bm, .iter_poly_bm = extract_lines_iter_poly_bm,
.iter_poly_mesh = extract_lines_iter_poly_mesh, .iter_poly_mesh = extract_lines_iter_poly_mesh,
.iter_ledge_bm = extract_lines_iter_ledge_bm, .iter_ledge_bm = extract_lines_iter_ledge_bm,
.iter_ledge_mesh = extract_lines_iter_ledge_mesh, .iter_ledge_mesh = extract_lines_iter_ledge_mesh,
.finish = extract_lines_with_lines_loose_finish, .finish = extract_lines_with_lines_loose_finish,
.data_type = 0, .data_type = 0,
.use_threading = false, .use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines)}; .mesh_buffer_offset = offsetof(MeshBufferCache, ibo.lines)};
/** \} */ /** \} */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/** \name Extract Point Indices /** \name Extract Point Indices
* \{ */ * \{ */
static void *extract_points_init(const MeshRenderData *mr, static void *extract_points_init(const MeshRenderData *mr,
struct MeshBatchCache *UNUSED(cache), struct MeshBatchCache *UNUSED(cache),
void *UNUSED(buf)) void *UNUSED(buf))
{ {
GPUIndexBufBuilder *elb = MEM_mallocN(sizeof(*elb), __func__); GPUIndexBufBuilderAsync *elb_async = MEM_mallocN(sizeof(*elb_async), __func__);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr->vert_len, mr->loop_len + mr->loop_loose_len); GPU_indexbuf_async_init(
return elb; elb_async, GPU_PRIM_POINTS, mr->vert_len, mr->loop_len + mr->loop_loose_len);
return elb_async;
} }
BLI_INLINE void vert_set_bm(GPUIndexBufBuilder *elb, BMVert *eve, int l_index) BLI_INLINE void vert_set_bm(GPUIndexBufBuilderAsync *elb_async, BMVert *eve, int l_index)
{ {
const int v_index = BM_elem_index_get(eve); const int v_index = BM_elem_index_get(eve);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
GPU_indexbuf_set_point_vert(elb, v_index, l_index); GPU_indexbuf_async_set_point_vert(elb_async, v_index, l_index);
} }
else { else {
GPU_indexbuf_set_point_restart(elb, v_index); GPU_indexbuf_async_set_point_restart(elb_async, v_index);
} }
} }
BLI_INLINE void vert_set_mesh(GPUIndexBufBuilder *elb, BLI_INLINE void vert_set_mesh(GPUIndexBufBuilderAsync *elb_async,
const MeshRenderData *mr, const MeshRenderData *mr,
const int v_index, const int v_index,
const int l_index) const int l_index)
{ {
const MVert *mv = &mr->mvert[v_index]; const MVert *mv = &mr->mvert[v_index];
if (!((mr->use_hide && (mv->flag & ME_HIDE)) || if (!((mr->use_hide && (mv->flag & ME_HIDE)) ||
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->v_origindex) && ((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->v_origindex) &&
(mr->v_origindex[v_index] == ORIGINDEX_NONE)))) { (mr->v_origindex[v_index] == ORIGINDEX_NONE)))) {
GPU_indexbuf_set_point_vert(elb, v_index, l_index); GPU_indexbuf_async_set_point_vert(elb_async, v_index, l_index);
} }
else { else {
GPU_indexbuf_set_point_restart(elb, v_index); GPU_indexbuf_async_set_point_restart(elb_async, v_index);
} }
} }
static void extract_points_iter_poly_bm(const MeshRenderData *UNUSED(mr), static void extract_points_iter_poly_bm(const MeshRenderData *UNUSED(mr),
BMFace *f, BMFace *f,
const int UNUSED(f_index), const int UNUSED(f_index),
void *elb) void *elb_async)
{ {
BMLoop *l_iter, *l_first; BMLoop *l_iter, *l_first;
l_iter = l_first = BM_FACE_FIRST_LOOP(f); l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do { do {
const int l_index = BM_elem_index_get(l_iter); const int l_index = BM_elem_index_get(l_iter);
vert_set_bm(elb, l_iter->v, l_index); vert_set_bm(elb_async, l_iter->v, l_index);
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);
} }
static void extract_points_iter_poly_mesh(const MeshRenderData *mr, static void extract_points_iter_poly_mesh(const MeshRenderData *mr,
const MPoly *mp, const MPoly *mp,
const int UNUSED(mp_index), const int UNUSED(mp_index),
void *elb) void *elb_async)
{ {
const MLoop *mloop = mr->mloop; const MLoop *mloop = mr->mloop;
const int ml_index_end = mp->loopstart + mp->totloop; const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) { for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const MLoop *ml = &mloop[ml_index]; const MLoop *ml = &mloop[ml_index];
vert_set_mesh(elb, mr, ml->v, ml_index); vert_set_mesh(elb_async, mr, ml->v, ml_index);
} }
} }
static void extract_points_iter_ledge_bm(const MeshRenderData *mr, static void extract_points_iter_ledge_bm(const MeshRenderData *mr,
BMEdge *eed, BMEdge *eed,
const int ledge_index, const int ledge_index,
void *elb) void *elb_async)
{ {
vert_set_bm(elb, eed->v1, mr->loop_len + (ledge_index * 2)); vert_set_bm(elb_async, eed->v1, mr->loop_len + (ledge_index * 2));
vert_set_bm(elb, eed->v2, mr->loop_len + (ledge_index * 2) + 1); vert_set_bm(elb_async, eed->v2, mr->loop_len + (ledge_index * 2) + 1);
} }
static void extract_points_iter_ledge_mesh(const MeshRenderData *mr, static void extract_points_iter_ledge_mesh(const MeshRenderData *mr,
const MEdge *med, const MEdge *med,
const uint ledge_index, const uint ledge_index,
void *elb) void *elb_async)
{ {
vert_set_mesh(elb, mr, med->v1, mr->loop_len + (ledge_index * 2)); vert_set_mesh(elb_async, mr, med->v1, mr->loop_len + (ledge_index * 2));
vert_set_mesh(elb, mr, med->v2, mr->loop_len + (ledge_index * 2) + 1); vert_set_mesh(elb_async, mr, med->v2, mr->loop_len + (ledge_index * 2) + 1);
} }
static void extract_points_iter_lvert_bm(const MeshRenderData *mr, static void extract_points_iter_lvert_bm(const MeshRenderData *mr,
BMVert *eve, BMVert *eve,
const int lvert_index, const int lvert_index,
void *elb) void *elb_async)
{ {
const int offset = mr->loop_len + (mr->edge_loose_len * 2); const int offset = mr->loop_len + (mr->edge_loose_len * 2);
vert_set_bm(elb, eve, offset + lvert_index); vert_set_bm(elb_async, eve, offset + lvert_index);
} }
static void extract_points_iter_lvert_mesh(const MeshRenderData *mr, static void extract_points_iter_lvert_mesh(const MeshRenderData *mr,
const MVert *UNUSED(mv), const MVert *UNUSED(mv),
const int lvert_index, const int lvert_index,
void *elb) void *elb_async)
{ {
const int offset = mr->loop_len + (mr->edge_loose_len * 2); const int offset = mr->loop_len + (mr->edge_loose_len * 2);
vert_set_mesh(elb, mr, mr->lverts[lvert_index], offset + lvert_index); vert_set_mesh(elb_async, mr, mr->lverts[lvert_index], offset + lvert_index);
} }
static void extract_points_finish(const MeshRenderData *UNUSED(mr), static void extract_points_finish(const MeshRenderData *UNUSED(mr),
struct MeshBatchCache *UNUSED(cache), struct MeshBatchCache *UNUSED(cache),
void *buf, void *buf,
void *elb) void *elb_async)
{ {
GPUIndexBuf *ibo = buf; GPUIndexBuf *ibo = buf;
GPU_indexbuf_build_in_place(elb, ibo); GPU_indexbuf_async_build_in_place(elb_async, ibo);
MEM_freeN(elb); MEM_freeN(elb_async);
} }
const MeshExtract extract_points = { const MeshExtract extract_points = {
.init = extract_points_init, .init = extract_points_init,
.iter_poly_bm = extract_points_iter_poly_bm, .iter_poly_bm = extract_points_iter_poly_bm,
.iter_poly_mesh = extract_points_iter_poly_mesh, .iter_poly_mesh = extract_points_iter_poly_mesh,
.iter_ledge_bm = extract_points_iter_ledge_bm, .iter_ledge_bm = extract_points_iter_ledge_bm,
.iter_ledge_mesh = extract_points_iter_ledge_mesh, .iter_ledge_mesh = extract_points_iter_ledge_mesh,
.iter_lvert_bm = extract_points_iter_lvert_bm, .iter_lvert_bm = extract_points_iter_lvert_bm,
.iter_lvert_mesh = extract_points_iter_lvert_mesh, .iter_lvert_mesh = extract_points_iter_lvert_mesh,
.finish = extract_points_finish, .finish = extract_points_finish,
.data_type = 0, .data_type = 0,
.use_threading = false, .use_threading = true,
.mesh_buffer_offset = offsetof(MeshBufferCache, ibo.points), .mesh_buffer_offset = offsetof(MeshBufferCache, ibo.points),
}; };
/** \} */ /** \} */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/** \name Extract Face-dots Indices /** \name Extract Face-dots Indices
* \{ */ * \{ */
▲ Show 20 Lines • Show All 4,212 Lines • Show Last 20 Lines