griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Rename MeshRenderData variables

Browse Source 
Use more standard _num suffix and standard mesh variable names.
This commit is contained in:
Hans Goudey
2024-03-19 15:00:52 -04:00
parent 82f434f444
commit 9fe2e34833
31 changed files with 174 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/draw/intern/draw_cache_extract.hh
View File

@@ -222,7 +222,7 @@ struct SortedFaceData {
/** The number of visible triangles assigned to each material. */
Array<int> mat_tri_len;
/* The total number of visible triangles (a sum of the values in #mat_tri_len). */
int visible_tri_len;
int visible_tris_num;
};
/**

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

@@ -400,24 +400,24 @@ BLI_INLINE void extract_task_range_run_iter(const MeshRenderData &mr,
case MR_ITER_CORNER_TRI:
range_data.elems = is_mesh ? mr.corner_tris.data() : (void *)mr.edit_bmesh->looptris;
func = is_mesh ? extract_range_iter_corner_tri_mesh : extract_range_iter_looptri_bm;
stop = mr.tri_len;
stop = mr.corner_tris_num;
break;
case MR_ITER_POLY:
range_data.elems = is_mesh ? mr.faces.data().data() : (void *)mr.bm->ftable;
func = is_mesh ? extract_range_iter_face_mesh : extract_range_iter_face_bm;
stop = mr.face_len;
stop = mr.faces_num;
break;
case MR_ITER_LOOSE_EDGE:
range_data.loose_elems = mr.loose_edges.data();
range_data.elems = is_mesh ? mr.edges.data() : (void *)mr.bm->etable;
func = is_mesh ? extract_range_iter_loose_edge_mesh : extract_range_iter_loose_edge_bm;
stop = mr.edge_loose_len;
stop = mr.loose_edges_num;
break;
case MR_ITER_LOOSE_VERT:
range_data.loose_elems = mr.loose_verts.data();
range_data.elems = is_mesh ? mr.vert_positions.data() : (void *)mr.bm->vtable;
func = is_mesh ? extract_range_iter_loose_vert_mesh : extract_range_iter_loose_vert_bm;
stop = mr.vert_loose_len;
stop = mr.loose_verts_num;
break;
default:
BLI_assert(false);
@@ -721,7 +721,7 @@ void mesh_buffer_cache_create_requested(TaskGraph *task_graph,
task_graph, *mr, mbc, iter_type, data_flag);
/* Simple heuristic. */
const bool use_thread = (mr->loop_len + mr->loop_loose_len) > MIN_RANGE_LEN;
const bool use_thread = (mr->corners_num + mr->loose_indices_num) > MIN_RANGE_LEN;
if (use_thread) {
/* First run the requested extractors that do not support asynchronous ranges. */

60
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@@ -82,14 +82,14 @@ static void mesh_render_data_loose_verts_bm(const MeshRenderData &mr,
BMIter iter;
BMVert *vert;
int count = 0;
Array<int> loose_verts(mr.vert_len);
Array<int> loose_verts(mr.verts_num);
BM_ITER_MESH_INDEX (vert, &iter, &bm, BM_VERTS_OF_MESH, i) {
if (vert->e == nullptr) {
loose_verts[count] = i;
count++;
}
}
if (count < mr.vert_len) {
if (count < mr.verts_num) {
cache.loose_geom.verts = loose_verts.as_span().take_front(count);
}
else {
@@ -105,14 +105,14 @@ static void mesh_render_data_loose_edges_bm(const MeshRenderData &mr,
BMIter iter;
BMEdge *edge;
int count = 0;
Array<int> loose_edges(mr.edge_len);
Array<int> loose_edges(mr.edges_num);
BM_ITER_MESH_INDEX (edge, &iter, &bm, BM_EDGES_OF_MESH, i) {
if (edge->l == nullptr) {
loose_edges[count] = i;
count++;
}
}
if (count < mr.edge_len) {
if (count < mr.edges_num) {
cache.loose_geom.edges = loose_edges.as_span().take_front(count);
}
else {
@@ -154,10 +154,10 @@ void mesh_render_data_update_loose_geom(MeshRenderData &mr,
mesh_render_data_loose_geom_ensure(mr, cache);
mr.loose_edges = cache.loose_geom.edges;
mr.loose_verts = cache.loose_geom.verts;
mr.vert_loose_len = cache.loose_geom.verts.size();
mr.edge_loose_len = cache.loose_geom.edges.size();
mr.loose_verts_num = cache.loose_geom.verts.size();
mr.loose_edges_num = cache.loose_geom.edges.size();
mr.loop_loose_len = mr.vert_loose_len + (mr.edge_loose_len * 2);
mr.loose_indices_num = mr.loose_verts_num + (mr.loose_edges_num * 2);
}
}
@@ -207,7 +207,7 @@ static void accumululate_material_counts_mesh(
std::plus<int>());
}
else {
all_tri_counts.local().first() = poly_to_tri_count(mr.face_len, mr.loop_len);
all_tri_counts.local().first() = poly_to_tri_count(mr.faces_num, mr.corners_num);
}
return;
}
@@ -237,7 +237,7 @@ static void accumululate_material_counts_mesh(
static Array<int> mesh_render_data_mat_tri_len_build(const MeshRenderData &mr)
{
threading::EnumerableThreadSpecific<Array<int>> all_tri_counts(
[&]() { return Array<int>(mr.mat_len, 0); });
[&]() { return Array<int>(mr.materials_num, 0); });
if (mr.extract_type == MR_EXTRACT_BMESH) {
accumululate_material_counts_bm(*mr.bm, all_tri_counts);
@@ -263,21 +263,21 @@ static void mesh_render_data_faces_sorted_build(MeshRenderData &mr, MeshBufferCa
const Span<int> mat_tri_len = cache.face_sorted.mat_tri_len;
/* Apply offset. */
int visible_tri_len = 0;
Array<int, 32> mat_tri_offs(mr.mat_len);
int visible_tris_num = 0;
Array<int, 32> mat_tri_offs(mr.materials_num);
{
for (int i = 0; i < mr.mat_len; i++) {
mat_tri_offs[i] = visible_tri_len;
visible_tri_len += mat_tri_len[i];
for (int i = 0; i < mr.materials_num; i++) {
mat_tri_offs[i] = visible_tris_num;
visible_tris_num += mat_tri_len[i];
}
}
cache.face_sorted.visible_tri_len = visible_tri_len;
cache.face_sorted.visible_tris_num = visible_tris_num;
cache.face_sorted.tri_first_index.reinitialize(mr.face_len);
cache.face_sorted.tri_first_index.reinitialize(mr.faces_num);
MutableSpan<int> tri_first_index = cache.face_sorted.tri_first_index;
/* Sort per material. */
int mat_last = mr.mat_len - 1;
int mat_last = mr.materials_num - 1;
if (mr.extract_type == MR_EXTRACT_BMESH) {
BMIter iter;
BMFace *f;
@@ -294,7 +294,7 @@ static void mesh_render_data_faces_sorted_build(MeshRenderData &mr, MeshBufferCa
}
}
else {
for (int i = 0; i < mr.face_len; i++) {
for (int i = 0; i < mr.faces_num; i++) {
if (!(mr.use_hide && !mr.hide_poly.is_empty() && mr.hide_poly[i])) {
const int mat = mr.material_indices.is_empty() ?
0 :
@@ -513,7 +513,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
face_normals = reinterpret_cast<const float(*)[3]>(mr.bm_face_normals.data());
}
mr.bm_loop_normals.reinitialize(mr.loop_len);
mr.bm_loop_normals.reinitialize(mr.corners_num);
const int clnors_offset = CustomData_get_offset(&mr.bm->ldata, CD_CUSTOMLOOPNORMAL);
BM_loops_calc_normal_vcos(mr.bm,
vert_coords,
@@ -552,7 +552,7 @@ MeshRenderData *mesh_render_data_create(Object *object,
{
MeshRenderData *mr = MEM_new<MeshRenderData>(__func__);
mr->toolsettings = ts;
mr->mat_len = mesh_render_mat_len_get(object, mesh);
mr->materials_num = mesh_render_mat_len_get(object, mesh);
mr->object_to_world = object_to_world;
@@ -656,11 +656,11 @@ MeshRenderData *mesh_render_data_create(Object *object,
if (mr->extract_type != MR_EXTRACT_BMESH) {
/* Mesh */
mr->vert_len = mr->mesh->verts_num;
mr->edge_len = mr->mesh->edges_num;
mr->loop_len = mr->mesh->corners_num;
mr->face_len = mr->mesh->faces_num;
mr->tri_len = poly_to_tri_count(mr->face_len, mr->loop_len);
mr->verts_num = mr->mesh->verts_num;
mr->edges_num = mr->mesh->edges_num;
mr->faces_num = mr->mesh->faces_num;
mr->corners_num = mr->mesh->corners_num;
mr->corner_tris_num = poly_to_tri_count(mr->faces_num, mr->corners_num);
mr->vert_positions = mr->mesh->vert_positions();
mr->edges = mr->mesh->edges();
@@ -699,11 +699,11 @@ MeshRenderData *mesh_render_data_create(Object *object,
/* #BMesh */
BMesh *bm = mr->bm;
mr->vert_len = bm->totvert;
mr->edge_len = bm->totedge;
mr->loop_len = bm->totloop;
mr->face_len = bm->totface;
mr->tri_len = poly_to_tri_count(mr->face_len, mr->loop_len);
mr->verts_num = bm->totvert;
mr->edges_num = bm->totedge;
mr->faces_num = bm->totface;
mr->corners_num = bm->totloop;
mr->corner_tris_num = poly_to_tri_count(mr->faces_num, mr->corners_num);
mr->normals_domain = bmesh_normals_domain(bm);
}

18
source/blender/draw/intern/mesh_extractors/extract_mesh.hh
View File

@@ -48,12 +48,17 @@ enum eMRExtractType {
struct MeshRenderData {
eMRExtractType extract_type;
int face_len, edge_len, vert_len, loop_len;
int edge_loose_len;
int vert_loose_len;
int loop_loose_len;
int tri_len;
int mat_len;
int verts_num;
int edges_num;
int faces_num;
int corners_num;
int loose_edges_num;
int loose_verts_num;
int loose_indices_num;
int corner_tris_num;
int materials_num;
bool use_hide;
bool use_subsurf_fdots;
@@ -91,6 +96,7 @@ struct MeshRenderData {
OffsetIndices<int> faces;
Span<int> corner_verts;
Span<int> corner_edges;
BMVert *eve_act;
BMEdge *eed_act;
BMFace *efa_act;

8
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_edituv.cc
View File

@@ -28,7 +28,7 @@ static void extract_edituv_tris_init(const MeshRenderData &mr,
void *tls_data)
{
MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(tls_data);
GPU_indexbuf_init(&data->elb, GPU_PRIM_TRIS, mr.tri_len, mr.loop_len);
GPU_indexbuf_init(&data->elb, GPU_PRIM_TRIS, mr.corner_tris_num, mr.corners_num);
data->sync_selection = (mr.toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
}
@@ -172,7 +172,7 @@ static void extract_edituv_lines_init(const MeshRenderData &mr,
void *tls_data)
{
MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(tls_data);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr.loop_len, mr.loop_len);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr.corners_num, mr.corners_num);
data->sync_selection = (mr.toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
}
@@ -354,7 +354,7 @@ static void extract_edituv_points_init(const MeshRenderData &mr,
void *tls_data)
{
MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(tls_data);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr.loop_len, mr.loop_len);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr.corners_num, mr.corners_num);
data->sync_selection = (mr.toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
}
@@ -508,7 +508,7 @@ static void extract_edituv_fdots_init(const MeshRenderData &mr,
void *tls_data)
{
MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(tls_data);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr.face_len, mr.face_len);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr.faces_num, mr.faces_num);
data->sync_selection = (mr.toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
}

2
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_fdots.cc
View File

@@ -21,7 +21,7 @@ static void extract_fdots_init(const MeshRenderData &mr,
void *tls_data)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(tls_data);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr.face_len, mr.face_len);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr.faces_num, mr.faces_num);
}
static void extract_fdots_iter_face_bm(const MeshRenderData & /*mr*/,

16
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines.cc
View File

@@ -49,8 +49,8 @@ static void extract_lines_init(const MeshRenderData &mr,
/* Put loose edges at the end. */
GPU_indexbuf_init(&data->elb,
GPU_PRIM_LINES,
mr.edge_len + mr.edge_loose_len,
mr.loop_len + mr.loop_loose_len);
mr.edges_num + mr.loose_edges_num,
mr.corners_num + mr.loose_indices_num);
if (mr.extract_type == MR_EXTRACT_MESH) {
data->optimal_display_edges = mr.mesh->runtime->subsurf_optimal_display_edges;
@@ -123,9 +123,9 @@ static void extract_lines_iter_loose_edge_bm(const MeshRenderData &mr,
{
MeshExtract_LinesData *data = static_cast<MeshExtract_LinesData *>(tls_data);
GPUIndexBufBuilder *elb = &data->elb;
const int l_index_offset = mr.edge_len + loose_edge_i;
const int l_index_offset = mr.edges_num + loose_edge_i;
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
const int l_index = mr.loop_len + loose_edge_i * 2;
const int l_index = mr.corners_num + loose_edge_i * 2;
GPU_indexbuf_set_line_verts(elb, l_index_offset, l_index, l_index + 1);
}
else {
@@ -142,10 +142,10 @@ static void extract_lines_iter_loose_edge_mesh(const MeshRenderData &mr,
{
MeshExtract_LinesData *data = static_cast<MeshExtract_LinesData *>(tls_data);
GPUIndexBufBuilder *elb = &data->elb;
const int l_index_offset = mr.edge_len + loose_edge_i;
const int l_index_offset = mr.edges_num + loose_edge_i;
const int e_index = mr.loose_edges[loose_edge_i];
if (is_edge_visible(data, e_index)) {
const int l_index = mr.loop_len + loose_edge_i * 2;
const int l_index = mr.corners_num + loose_edge_i * 2;
GPU_indexbuf_set_line_verts(elb, l_index_offset, l_index, l_index + 1);
}
else {
@@ -302,8 +302,8 @@ static void extract_lines_loose_subbuffer(const MeshRenderData &mr, MeshBatchCac
{
BLI_assert(cache.final.buff.ibo.lines);
/* Multiply by 2 because these are edges indices. */
const int start = mr.edge_len * 2;
const int len = mr.edge_loose_len * 2;
const int start = mr.edges_num * 2;
const int len = mr.loose_edges_num * 2;
GPU_indexbuf_create_subrange_in_place(
cache.final.buff.ibo.lines_loose, cache.final.buff.ibo.lines, start, len);
cache.no_loose_wire = (len == 0);

4
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_adjacency.cc
View File

@@ -54,10 +54,10 @@ static void extract_lines_adjacency_init(const MeshRenderData &mr,
/* Similar to poly_to_tri_count().
* There is always (loop + triangle - 1) edges inside a face.
* Accumulate for all faces and you get : */
uint tess_edge_len = mr.loop_len + mr.tri_len - mr.face_len;
uint tess_edge_len = mr.corners_num + mr.corner_tris_num - mr.faces_num;
MeshExtract_LineAdjacency_Data *data = static_cast<MeshExtract_LineAdjacency_Data *>(tls_data);
line_adjacency_data_init(data, mr.vert_len, mr.loop_len, tess_edge_len);
line_adjacency_data_init(data, mr.verts_num, mr.corners_num, tess_edge_len);
}
BLI_INLINE void lines_adjacency_triangle(

6
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_paint_mask.cc
View File

@@ -33,8 +33,8 @@ static void extract_lines_paint_mask_init(const MeshRenderData &mr,
void *tls_data)
{
MeshExtract_LinePaintMask_Data *data = static_cast<MeshExtract_LinePaintMask_Data *>(tls_data);
data->select_map = BLI_BITMAP_NEW(mr.edge_len, __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr.edge_len, mr.loop_len);
data->select_map = BLI_BITMAP_NEW(mr.edges_num, __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr.edges_num, mr.corners_num);
}
static void extract_lines_paint_mask_iter_face_mesh(const MeshRenderData &mr,
@@ -93,7 +93,7 @@ static void extract_lines_paint_mask_init_subdiv(const DRWSubdivCache &subdiv_ca
void *tls_data)
{
MeshExtract_LinePaintMask_Data *data = static_cast<MeshExtract_LinePaintMask_Data *>(tls_data);
data->select_map = BLI_BITMAP_NEW(mr.edge_len, __func__);
data->select_map = BLI_BITMAP_NEW(mr.edges_num, __func__);
GPU_indexbuf_init(&data->elb,
GPU_PRIM_LINES,
subdiv_cache.num_subdiv_edges,

20
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_points.cc
View File

@@ -23,7 +23,7 @@ static void extract_points_init(const MeshRenderData &mr,
void *tls_data)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(tls_data);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr.vert_len, mr.loop_len + mr.loop_loose_len);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr.verts_num, mr.corners_num + mr.loose_indices_num);
}
BLI_INLINE void vert_set_bm(GPUIndexBufBuilder *elb, const BMVert *eve, int l_index)
@@ -83,8 +83,8 @@ static void extract_points_iter_loose_edge_bm(const MeshRenderData &mr,
void *_userdata)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
vert_set_bm(elb, eed->v1, mr.loop_len + (loose_edge_i * 2));
vert_set_bm(elb, eed->v2, mr.loop_len + (loose_edge_i * 2) + 1);
vert_set_bm(elb, eed->v1, mr.corners_num + (loose_edge_i * 2));
vert_set_bm(elb, eed->v2, mr.corners_num + (loose_edge_i * 2) + 1);
}
static void extract_points_iter_loose_edge_mesh(const MeshRenderData &mr,
@@ -93,8 +93,8 @@ static void extract_points_iter_loose_edge_mesh(const MeshRenderData &mr,
void *_userdata)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
vert_set_mesh(elb, mr, edge[0], mr.loop_len + (loose_edge_i * 2));
vert_set_mesh(elb, mr, edge[1], mr.loop_len + (loose_edge_i * 2) + 1);
vert_set_mesh(elb, mr, edge[0], mr.corners_num + (loose_edge_i * 2));
vert_set_mesh(elb, mr, edge[1], mr.corners_num + (loose_edge_i * 2) + 1);
}
static void extract_points_iter_loose_vert_bm(const MeshRenderData &mr,
@@ -103,7 +103,7 @@ static void extract_points_iter_loose_vert_bm(const MeshRenderData &mr,
void *_userdata)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
vert_set_bm(elb, eve, offset + loose_vert_i);
}
@@ -112,7 +112,7 @@ static void extract_points_iter_loose_vert_mesh(const MeshRenderData &mr,
void *_userdata)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
vert_set_mesh(elb, mr, mr.loose_verts[loose_vert_i], offset + loose_vert_i);
}
@@ -142,7 +142,7 @@ static void extract_points_init_subdiv(const DRWSubdivCache &subdiv_cache,
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(data);
GPU_indexbuf_init(elb,
GPU_PRIM_POINTS,
mr.vert_len,
mr.verts_num,
subdiv_cache.num_subdiv_loops + subdiv_cache.loose_geom.loop_len);
}
@@ -210,8 +210,8 @@ static void extract_points_loose_geom_subdiv(const DRWSubdivCache &subdiv_cache,
void *data)
{
const DRWSubdivLooseGeom &loose_geom = subdiv_cache.loose_geom;
const int loop_loose_len = loose_geom.loop_len;
if (loop_loose_len == 0) {
const int loose_indices_num = loose_geom.loop_len;
if (loose_indices_num == 0) {
return;
}

10
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc
View File

@@ -33,7 +33,7 @@ static void extract_tris_init(const MeshRenderData &mr,
void *tls_data)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(tls_data);
GPU_indexbuf_init(elb, GPU_PRIM_TRIS, mr.face_sorted->visible_tri_len, mr.loop_len);
GPU_indexbuf_init(elb, GPU_PRIM_TRIS, mr.face_sorted->visible_tris_num, mr.corners_num);
}
static void extract_tris_iter_face_bm(const MeshRenderData &mr,
@@ -97,7 +97,7 @@ static void extract_tris_finish(const MeshRenderData &mr,
* is created before the surfaces-per-material. */
if (mr.use_final_mesh && cache.tris_per_mat) {
int mat_start = 0;
for (int i = 0; i < mr.mat_len; i++) {
for (int i = 0; i < mr.materials_num; i++) {
/* These IBOs have not been queried yet but we create them just in case they are needed
* later since they are not tracked by mesh_buffer_cache_create_requested(). */
if (cache.tris_per_mat[i] == nullptr) {
@@ -166,7 +166,7 @@ static void extract_tris_single_mat_init(const MeshRenderData &mr,
void *tls_data)
{
GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(tls_data);
GPU_indexbuf_init(elb, GPU_PRIM_TRIS, mr.tri_len, mr.loop_len);
GPU_indexbuf_init(elb, GPU_PRIM_TRIS, mr.corner_tris_num, mr.corners_num);
}
static void extract_tris_single_mat_iter_looptri_bm(const MeshRenderData & /*mr*/,
@@ -215,14 +215,14 @@ static void extract_tris_single_mat_finish(const MeshRenderData &mr,
/* Create ibo sub-ranges. Always do this to avoid error when the standard surface batch
* is created before the surfaces-per-material. */
if (mr.use_final_mesh && cache.tris_per_mat) {
for (int i = 0; i < mr.mat_len; i++) {
for (int i = 0; i < mr.materials_num; i++) {
/* These IBOs have not been queried yet but we create them just in case they are needed
* later since they are not tracked by mesh_buffer_cache_create_requested(). */
if (cache.tris_per_mat[i] == nullptr) {
cache.tris_per_mat[i] = GPU_indexbuf_calloc();
}
/* Multiply by 3 because these are triangle indices. */
const int len = mr.tri_len * 3;
const int len = mr.corner_tris_num * 3;
GPU_indexbuf_create_subrange_in_place(cache.tris_per_mat[i], ibo, 0, len);
}
}

6
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
View File

@@ -254,7 +254,7 @@ static void extract_attr_init(
{
const DRW_AttributeRequest &request = cache.attr_used.requests[index];
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
init_vbo_for_attribute(mr, vbo, request, false, uint32_t(mr.loop_len));
init_vbo_for_attribute(mr, vbo, request, false, uint32_t(mr.corners_num));
extract_attribute(mr, request, *vbo);
}
@@ -357,9 +357,9 @@ static void extract_mesh_attr_viewer_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
MutableSpan<ColorGeometry4f> attr{static_cast<ColorGeometry4f *>(GPU_vertbuf_get_data(vbo)),
mr.loop_len};
mr.corners_num};
const StringRefNull attr_name = ".viewer";
const bke::AttributeAccessor attributes = mr.mesh->attributes();

16
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
View File

@@ -69,15 +69,15 @@ static void extract_edge_fac_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len + mr.loop_loose_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num + mr.loose_indices_num);
MeshExtract_EdgeFac_Data *data = static_cast<MeshExtract_EdgeFac_Data *>(tls_data);
if (mr.extract_type == MR_EXTRACT_MESH) {
data->use_edge_render = !mr.mesh->runtime->subsurf_optimal_display_edges.is_empty();
data->edge_loop_count = MEM_cnew_array<uint8_t>(mr.edge_len, __func__);
data->edge_loop_count = MEM_cnew_array<uint8_t>(mr.edges_num, __func__);
data->edge_pdata = (MEdgeDataPrev *)MEM_malloc_arrayN(
mr.edge_len, sizeof(MEdgeDataPrev), __func__);
mr.edges_num, sizeof(MEdgeDataPrev), __func__);
}
else {
/* HACK to bypass non-manifold check in mesh_edge_fac_finish(). */
@@ -166,8 +166,8 @@ static void extract_edge_fac_iter_loose_edge_bm(const MeshRenderData &mr,
void *_data)
{
MeshExtract_EdgeFac_Data *data = static_cast<MeshExtract_EdgeFac_Data *>(_data);
data->vbo_data[mr.loop_len + (loose_edge_i * 2) + 0] = 0;
data->vbo_data[mr.loop_len + (loose_edge_i * 2) + 1] = 0;
data->vbo_data[mr.corners_num + (loose_edge_i * 2) + 0] = 0;
data->vbo_data[mr.corners_num + (loose_edge_i * 2) + 1] = 0;
}
static void extract_edge_fac_iter_loose_edge_mesh(const MeshRenderData &mr,
@@ -177,8 +177,8 @@ static void extract_edge_fac_iter_loose_edge_mesh(const MeshRenderData &mr,
{
MeshExtract_EdgeFac_Data *data = static_cast<MeshExtract_EdgeFac_Data *>(_data);
data->vbo_data[mr.loop_len + loose_edge_i * 2 + 0] = 0;
data->vbo_data[mr.loop_len + loose_edge_i * 2 + 1] = 0;
data->vbo_data[mr.corners_num + loose_edge_i * 2 + 0] = 0;
data->vbo_data[mr.corners_num + loose_edge_i * 2 + 1] = 0;
}
static void extract_edge_fac_finish(const MeshRenderData &mr,
@@ -201,7 +201,7 @@ static void extract_edge_fac_finish(const MeshRenderData &mr,
data->vbo_data = static_cast<uchar *>(GPU_vertbuf_steal_data(vbo));
GPU_vertbuf_clear(vbo);
int buf_len = mr.loop_len + mr.loop_loose_len;
int buf_len = mr.corners_num + mr.loose_indices_num;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, buf_len);

10
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edit_data.cc
View File

@@ -123,7 +123,7 @@ static void extract_edit_data_init(const MeshRenderData &mr,
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
GPUVertFormat *format = get_edit_data_format();
GPU_vertbuf_init_with_format(vbo, format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len + mr.loop_loose_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num + mr.loose_indices_num);
EditLoopData *vbo_data = (EditLoopData *)GPU_vertbuf_get_data(vbo);
*(EditLoopData **)tls_data = vbo_data;
}
@@ -178,7 +178,7 @@ static void extract_edit_data_iter_loose_edge_bm(const MeshRenderData &mr,
void *_data)
{
EditLoopData *vbo_data = *(EditLoopData **)_data;
EditLoopData *data = vbo_data + mr.loop_len + (loose_edge_i * 2);
EditLoopData *data = vbo_data + mr.corners_num + (loose_edge_i * 2);
memset(data, 0x0, sizeof(*data) * 2);
mesh_render_data_edge_flag(mr, eed, &data[0]);
data[1] = data[0];
@@ -192,7 +192,7 @@ static void extract_edit_data_iter_loose_edge_mesh(const MeshRenderData &mr,
void *_data)
{
EditLoopData *vbo_data = *(EditLoopData **)_data;
EditLoopData *data = vbo_data + mr.loop_len + loose_edge_i * 2;
EditLoopData *data = vbo_data + mr.corners_num + loose_edge_i * 2;
memset(data, 0x0, sizeof(*data) * 2);
const int e_index = mr.loose_edges[loose_edge_i];
BMEdge *eed = bm_original_edge_get(mr, e_index);
@@ -216,7 +216,7 @@ static void extract_edit_data_iter_loose_vert_bm(const MeshRenderData &mr,
void *_data)
{
EditLoopData *vbo_data = *(EditLoopData **)_data;
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
EditLoopData *data = vbo_data + offset + loose_vert_i;
memset(data, 0x0, sizeof(*data));
mesh_render_data_vert_flag(mr, eve, data);
@@ -227,7 +227,7 @@ static void extract_edit_data_iter_loose_vert_mesh(const MeshRenderData &mr,
void *_data)
{
EditLoopData *vbo_data = *(EditLoopData **)_data;
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
EditLoopData *data = vbo_data + offset + loose_vert_i;
memset(data, 0x0, sizeof(*data));

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_data.cc
View File

@@ -51,7 +51,7 @@ static void extract_edituv_data_init(const MeshRenderData &mr,
{
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
MeshExtract_EditUVData_Data *data = static_cast<MeshExtract_EditUVData_Data *>(tls_data);
extract_edituv_data_init_common(mr, vbo, data, mr.loop_len);
extract_edituv_data_init_common(mr, vbo, data, mr.corners_num);
}
static void extract_edituv_data_iter_face_bm(const MeshRenderData &mr,

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
View File

@@ -100,7 +100,7 @@ static void extract_edituv_stretch_angle_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
MeshExtract_StretchAngle_Data *data = static_cast<MeshExtract_StretchAngle_Data *>(tls_data);
data->vbo_data = (UVStretchAngle *)GPU_vertbuf_get_data(vbo);

10
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
View File

@@ -34,7 +34,7 @@ static void extract_edituv_stretch_area_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
}
BLI_INLINE float area_ratio_get(float area, float uvarea)
@@ -77,7 +77,7 @@ static void compute_area_ratio(const MeshRenderData &mr,
BLI_assert(mr.extract_type == MR_EXTRACT_MESH);
const float2 *uv_data = (const float2 *)CustomData_get_layer(&mr.mesh->corner_data,
CD_PROP_FLOAT2);
for (int face_index = 0; face_index < mr.face_len; face_index++) {
for (int face_index = 0; face_index < mr.faces_num; face_index++) {
const IndexRange face = mr.faces[face_index];
const float area = bke::mesh::face_area_calc(mr.vert_positions, mr.corner_verts.slice(face));
float uvarea = area_poly_v2(reinterpret_cast<const float(*)[2]>(&uv_data[face.start()]),
@@ -98,7 +98,7 @@ static void extract_edituv_stretch_area_finish(const MeshRenderData &mr,
void * /*data*/)
{
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
float *area_ratio = static_cast<float *>(MEM_mallocN(sizeof(float) * mr.face_len, __func__));
float *area_ratio = static_cast<float *>(MEM_mallocN(sizeof(float) * mr.faces_num, __func__));
compute_area_ratio(mr, area_ratio, cache.tot_area, cache.tot_uv_area);
/* Copy face data for each loop. */
@@ -116,7 +116,7 @@ static void extract_edituv_stretch_area_finish(const MeshRenderData &mr,
}
else {
BLI_assert(mr.extract_type == MR_EXTRACT_MESH);
for (int face_index = 0; face_index < mr.face_len; face_index++) {
for (int face_index = 0; face_index < mr.faces_num; face_index++) {
for (const int l_index : mr.faces[face_index]) {
loop_stretch[l_index] = area_ratio[face_index];
}
@@ -148,7 +148,7 @@ static void extract_edituv_stretch_area_init_subdiv(const DRWSubdivCache &subdiv
/* We use the same format as we just copy data around. */
GPU_vertbuf_init_with_format(coarse_data, &format);
GPU_vertbuf_data_alloc(coarse_data, mr.loop_len);
GPU_vertbuf_data_alloc(coarse_data, mr.corners_num);
compute_area_ratio(mr,
static_cast<float *>(GPU_vertbuf_get_data(coarse_data)),

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_edituv_data.cc
View File

@@ -33,7 +33,7 @@ static void extract_fdots_edituv_data_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.face_len);
GPU_vertbuf_data_alloc(vbo, mr.faces_num);
MeshExtract_EditUVFdotData_Data *data = static_cast<MeshExtract_EditUVFdotData_Data *>(tls_data);
data->vbo_data = (EditLoopData *)GPU_vertbuf_get_data(vbo);

12
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_nor.cc
View File

@@ -31,7 +31,7 @@ static void extract_fdots_nor_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.face_len);
GPU_vertbuf_data_alloc(vbo, mr.faces_num);
}
static void extract_fdots_nor_finish(const MeshRenderData &mr,
@@ -46,7 +46,7 @@ static void extract_fdots_nor_finish(const MeshRenderData &mr,
/* Quicker than doing it for each loop. */
if (mr.extract_type == MR_EXTRACT_BMESH) {
for (int f = 0; f < mr.face_len; f++) {
for (int f = 0; f < mr.faces_num; f++) {
efa = BM_face_at_index(mr.bm, f);
const bool is_face_hidden = BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
if (is_face_hidden || (mr.p_origindex && mr.p_origindex[f] == ORIGINDEX_NONE)) {
@@ -63,7 +63,7 @@ static void extract_fdots_nor_finish(const MeshRenderData &mr,
}
}
else {
for (int f = 0; f < mr.face_len; f++) {
for (int f = 0; f < mr.faces_num; f++) {
efa = bm_original_face_get(mr, f);
const bool is_face_hidden = efa && BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
if (is_face_hidden || (mr.p_origindex && mr.p_origindex[f] == ORIGINDEX_NONE)) {
@@ -111,7 +111,7 @@ static void extract_fdots_nor_hq_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.face_len);
GPU_vertbuf_data_alloc(vbo, mr.faces_num);
}
static void extract_fdots_nor_hq_finish(const MeshRenderData &mr,
@@ -126,7 +126,7 @@ static void extract_fdots_nor_hq_finish(const MeshRenderData &mr,
/* Quicker than doing it for each loop. */
if (mr.extract_type == MR_EXTRACT_BMESH) {
for (int f = 0; f < mr.face_len; f++) {
for (int f = 0; f < mr.faces_num; f++) {
efa = BM_face_at_index(mr.bm, f);
const bool is_face_hidden = BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
if (is_face_hidden || (mr.p_origindex && mr.p_origindex[f] == ORIGINDEX_NONE)) {
@@ -143,7 +143,7 @@ static void extract_fdots_nor_hq_finish(const MeshRenderData &mr,
}
}
else {
for (int f = 0; f < mr.face_len; f++) {
for (int f = 0; f < mr.faces_num; f++) {
efa = bm_original_face_get(mr, f);
const bool is_face_hidden = efa && BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
if (is_face_hidden || (mr.p_origindex && mr.p_origindex[f] == ORIGINDEX_NONE)) {

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc
View File

@@ -44,7 +44,7 @@ static void extract_fdots_pos_init(const MeshRenderData &mr,
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
GPUVertFormat *format = get_fdots_pos_format();
GPU_vertbuf_init_with_format(vbo, format);
GPU_vertbuf_data_alloc(vbo, mr.face_len);
GPU_vertbuf_data_alloc(vbo, mr.faces_num);
void *vbo_data = GPU_vertbuf_get_data(vbo);
*(float(**)[3])tls_data = static_cast<float(*)[3]>(vbo_data);
}

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc
View File

@@ -36,11 +36,11 @@ static void extract_fdots_uv_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.face_len);
GPU_vertbuf_data_alloc(vbo, mr.faces_num);
if (!mr.use_subsurf_fdots) {
/* Clear so we can accumulate on it. */
memset(GPU_vertbuf_get_data(vbo), 0x0, mr.face_len * GPU_vertbuf_get_format(vbo)->stride);
memset(GPU_vertbuf_get_data(vbo), 0x0, mr.faces_num * GPU_vertbuf_get_format(vbo)->stride);
}
MeshExtract_FdotUV_Data *data = static_cast<MeshExtract_FdotUV_Data *>(tls_data);

11
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
View File

@@ -139,7 +139,7 @@ static void extract_paint_overlay_flags(const MeshRenderData &mr, MutableSpan<GP
}
if (mr.edit_bmesh && mr.v_origindex) {
const Span<int> corner_verts = mr.corner_verts;
const Span<int> orig_indices(mr.v_origindex, mr.vert_len);
const Span<int> orig_indices(mr.v_origindex, mr.verts_num);
for (const int face : range) {
for (const int corner : faces[face]) {
if (orig_indices[corner_verts[corner]] == ORIGINDEX_NONE) {
@@ -163,10 +163,11 @@ static void extract_lnor_init(const MeshRenderData &mr,
GPU_vertformat_alias_add(&format, "lnor");
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
if (mr.extract_type == MR_EXTRACT_MESH) {
MutableSpan vbo_data(static_cast<GPUPackedNormal *>(GPU_vertbuf_get_data(vbo)), mr.loop_len);
MutableSpan vbo_data(static_cast<GPUPackedNormal *>(GPU_vertbuf_get_data(vbo)),
mr.corners_num);
extract_normals_mesh(mr, vbo_data);
extract_paint_overlay_flags(mr, vbo_data);
}
@@ -258,10 +259,10 @@ static void extract_lnor_hq_init(const MeshRenderData &mr,
GPU_vertformat_alias_add(&format, "lnor");
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
if (mr.extract_type == MR_EXTRACT_MESH) {
MutableSpan vbo_data(static_cast<short4 *>(GPU_vertbuf_get_data(vbo)), mr.loop_len);
MutableSpan vbo_data(static_cast<short4 *>(GPU_vertbuf_get_data(vbo)), mr.corners_num);
extract_normals_mesh(mr, vbo_data);
extract_paint_overlay_flags(mr, vbo_data);
}

20
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
View File

@@ -38,7 +38,7 @@ static void extract_mesh_analysis_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
}
static void axis_from_enum_v3(float v[3], const char axis)
@@ -143,7 +143,7 @@ static void statvis_calc_thickness(const MeshRenderData &mr, float *r_thickness)
{
const float eps_offset = 0.00002f; /* values <= 0.00001 give errors */
/* cheating to avoid another allocation */
float *face_dists = r_thickness + (mr.loop_len - mr.face_len);
float *face_dists = r_thickness + (mr.corners_num - mr.faces_num);
BMEditMesh *em = mr.edit_bmesh;
const float scale = 1.0f / mat4_to_scale(mr.object_to_world.ptr());
const MeshStatVis *statvis = &mr.toolsettings->statvis;
@@ -155,7 +155,7 @@ static void statvis_calc_thickness(const MeshRenderData &mr, float *r_thickness)
BLI_assert(samples <= 32);
BLI_assert(min <= max);
copy_vn_fl(face_dists, mr.face_len, max);
copy_vn_fl(face_dists, mr.faces_num, max);
BLI_jitter_init(jit_ofs, samples);
for (int j = 0; j < samples; j++) {
@@ -168,7 +168,7 @@ static void statvis_calc_thickness(const MeshRenderData &mr, float *r_thickness)
BMBVHTree *bmtree = BKE_bmbvh_new_from_editmesh(em, 0, nullptr, false);
BMLoop *(*looptris)[3] = em->looptris;
for (int i = 0; i < mr.tri_len; i++) {
for (int i = 0; i < mr.corner_tris_num; i++) {
BMLoop **ltri = looptris[i];
const int index = BM_elem_index_get(ltri[0]->f);
const float *cos[3] = {
@@ -307,7 +307,7 @@ static void statvis_calc_intersect(const MeshRenderData &mr, float *r_intersect)
{
BMEditMesh *em = mr.edit_bmesh;
for (int l_index = 0; l_index < mr.loop_len; l_index++) {
for (int l_index = 0; l_index < mr.corners_num; l_index++) {
r_intersect[l_index] = -1.0f;
}
@@ -504,8 +504,8 @@ static void statvis_calc_sharp(const MeshRenderData &mr, float *r_sharp)
const float minmax_irange = 1.0f / (max - min);
/* Can we avoid this extra allocation? */
float *vert_angles = (float *)MEM_mallocN(sizeof(float) * mr.vert_len, __func__);
copy_vn_fl(vert_angles, mr.vert_len, -M_PI);
float *vert_angles = (float *)MEM_mallocN(sizeof(float) * mr.verts_num, __func__);
copy_vn_fl(vert_angles, mr.verts_num, -M_PI);
if (mr.extract_type == MR_EXTRACT_BMESH) {
BMIter iter;
@@ -535,9 +535,9 @@ static void statvis_calc_sharp(const MeshRenderData &mr, float *r_sharp)
/* first assign float values to verts */
Map<OrderedEdge, int> eh;
eh.reserve(mr.edge_len);
eh.reserve(mr.edges_num);
for (int face_index = 0; face_index < mr.face_len; face_index++) {
for (int face_index = 0; face_index < mr.faces_num; face_index++) {
const IndexRange face = mr.faces[face_index];
for (const int corner : face) {
const int vert_curr = mr.corner_verts[corner];
@@ -580,7 +580,7 @@ static void statvis_calc_sharp(const MeshRenderData &mr, float *r_sharp)
*col2 = max_ff(*col2, angle);
}
for (int l_index = 0; l_index < mr.loop_len; l_index++) {
for (int l_index = 0; l_index < mr.corners_num; l_index++) {
const int vert = mr.corner_verts[l_index];
r_sharp[l_index] = sharp_remap(vert_angles[vert], min, max, minmax_irange);
}

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_orco.cc
View File

@@ -35,7 +35,7 @@ static void extract_orco_init(const MeshRenderData &mr,
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
CustomData *cd_vdata = &mr.mesh->vert_data;

12
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos.cc
View File

@@ -43,7 +43,7 @@ static void extract_pos_init(const MeshRenderData &mr,
GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len + mr.loop_loose_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num + mr.loose_indices_num);
MutableSpan vbo_data(static_cast<float3 *>(GPU_vertbuf_get_data(vbo)),
GPU_vertbuf_get_vertex_len(vbo));
@@ -53,7 +53,7 @@ static void extract_pos_init(const MeshRenderData &mr,
extract_mesh_loose_edge_positions(mr.vert_positions,
mr.edges,
mr.loose_edges,
vbo_data.slice(mr.loop_len, mr.loose_edges.size() * 2));
vbo_data.slice(mr.corners_num, mr.loose_edges.size() * 2));
array_utils::gather(
mr.vert_positions, mr.loose_verts, vbo_data.take_back(mr.loose_verts.size()));
}
@@ -82,7 +82,7 @@ static void extract_pos_iter_loose_edge_bm(const MeshRenderData &mr,
void *_data)
{
float3 *data = *static_cast<float3 **>(_data);
int index = mr.loop_len + loose_edge_i * 2;
int index = mr.corners_num + loose_edge_i * 2;
data[index + 0] = bm_vert_co_get(mr, eed->v1);
data[index + 1] = bm_vert_co_get(mr, eed->v2);
}
@@ -93,7 +93,7 @@ static void extract_pos_iter_loose_vert_bm(const MeshRenderData &mr,
void *_data)
{
float3 *data = *static_cast<float3 **>(_data);
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
const int index = offset + loose_vert_i;
data[index] = bm_vert_co_get(mr, eve);
}
@@ -120,7 +120,7 @@ static GPUVertFormat *get_custom_normals_format()
static void extract_vertex_flags(const MeshRenderData &mr, char *flags)
{
for (int i = 0; i < mr.vert_len; i++) {
for (int i = 0; i < mr.verts_num; i++) {
char *flag = &flags[i];
const bool vert_hidden = !mr.hide_vert.is_empty() && mr.hide_vert[i];
/* Flag for paint mode overlay. */
@@ -159,7 +159,7 @@ static void extract_pos_init_subdiv(const DRWSubdivCache &subdiv_cache,
GPU_vertformat_attr_add(&flag_format, "flag", GPU_COMP_I32, 1, GPU_FETCH_INT);
}
GPU_vertbuf_init_with_format(flags_buffer, &flag_format);
GPU_vertbuf_data_alloc(flags_buffer, divide_ceil_u(mr.vert_len, 4));
GPU_vertbuf_data_alloc(flags_buffer, divide_ceil_u(mr.verts_num, 4));
char *flags = static_cast<char *>(GPU_vertbuf_get_data(flags_buffer));
extract_vertex_flags(mr, flags);
GPU_vertbuf_tag_dirty(flags_buffer);

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
View File

@@ -42,7 +42,7 @@ static void extract_sculpt_data_init(const MeshRenderData &mr,
GPUVertFormat *format = get_sculpt_data_format();
GPU_vertbuf_init_with_format(vbo, format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
struct gpuSculptData {
uint8_t face_set_color[4];
@@ -85,7 +85,7 @@ static void extract_sculpt_data_init(const MeshRenderData &mr,
const VArray<int> face_set = *attributes.lookup<int>(".sculpt_face_set",
bke::AttrDomain::Face);
for (int face_index = 0; face_index < mr.face_len; face_index++) {
for (int face_index = 0; face_index < mr.faces_num; face_index++) {
for (const int corner : mr.faces[face_index]) {
float v_mask = 0.0f;
if (mask) {

24
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc
View File

@@ -35,7 +35,7 @@ static void extract_select_idx_init(const MeshRenderData &mr,
void *buf,
void *tls_data)
{
extract_select_idx_init_impl(mr, mr.loop_len + mr.loop_loose_len, buf, tls_data);
extract_select_idx_init_impl(mr, mr.corners_num + mr.loose_indices_num, buf, tls_data);
}
/* TODO: Use #glVertexID to get loop index and use the data structure on the CPU to retrieve the
@@ -87,8 +87,8 @@ static void extract_edge_idx_iter_loose_edge_bm(const MeshRenderData &mr,
const int loose_edge_i,
void *data)
{
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 0] = BM_elem_index_get(eed);
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 1] = BM_elem_index_get(eed);
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = BM_elem_index_get(eed);
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = BM_elem_index_get(eed);
}
static void extract_vert_idx_iter_loose_edge_bm(const MeshRenderData &mr,
@@ -96,8 +96,8 @@ static void extract_vert_idx_iter_loose_edge_bm(const MeshRenderData &mr,
const int loose_edge_i,
void *data)
{
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 0] = BM_elem_index_get(eed->v1);
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 1] = BM_elem_index_get(eed->v2);
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = BM_elem_index_get(eed->v1);
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = BM_elem_index_get(eed->v2);
}
static void extract_vert_idx_iter_loose_vert_bm(const MeshRenderData &mr,
@@ -105,7 +105,7 @@ static void extract_vert_idx_iter_loose_vert_bm(const MeshRenderData &mr,
const int loose_vert_i,
void *data)
{
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
(*(int32_t **)data)[offset + loose_vert_i] = BM_elem_index_get(eve);
}
@@ -146,8 +146,8 @@ static void extract_edge_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
{
const int e_index = mr.loose_edges[loose_edge_i];
const int e_orig = (mr.e_origindex) ? mr.e_origindex[e_index] : e_index;
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 0] = e_orig;
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 1] = e_orig;
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = e_orig;
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = e_orig;
}
static void extract_vert_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
@@ -157,15 +157,15 @@ static void extract_vert_idx_iter_loose_edge_mesh(const MeshRenderData &mr,
{
int v1_orig = (mr.v_origindex) ? mr.v_origindex[edge[0]] : edge[0];
int v2_orig = (mr.v_origindex) ? mr.v_origindex[edge[1]] : edge[1];
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 0] = v1_orig;
(*(int32_t **)data)[mr.loop_len + loose_edge_i * 2 + 1] = v2_orig;
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 0] = v1_orig;
(*(int32_t **)data)[mr.corners_num + loose_edge_i * 2 + 1] = v2_orig;
}
static void extract_vert_idx_iter_loose_vert_mesh(const MeshRenderData &mr,
const int loose_vert_i,
void *data)
{
const int offset = mr.loop_len + (mr.edge_loose_len * 2);
const int offset = mr.corners_num + (mr.loose_edges_num * 2);
const int v_index = mr.loose_verts[loose_vert_i];
const int v_orig = (mr.v_origindex) ? mr.v_origindex[v_index] : v_index;
@@ -360,7 +360,7 @@ static void extract_fdot_idx_init(const MeshRenderData &mr,
void *buf,
void *tls_data)
{
extract_select_idx_init_impl(mr, mr.face_len, buf, tls_data);
extract_select_idx_init_impl(mr, mr.faces_num, buf, tls_data);
}
static void extract_fdot_idx_iter_face_bm(const MeshRenderData & /*mr*/,

30
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
View File

@@ -80,11 +80,11 @@ static void extract_tan_init_common(const MeshRenderData &mr,
}
if (use_orco_tan && orco == nullptr) {
/* If `orco` is not available compute it ourselves */
orco_allocated = (float(*)[3])MEM_mallocN(sizeof(*orco) * mr.vert_len, __func__);
orco_allocated = (float(*)[3])MEM_mallocN(sizeof(*orco) * mr.verts_num, __func__);
if (mr.extract_type == MR_EXTRACT_BMESH) {
BMesh *bm = mr.bm;
for (int v = 0; v < mr.vert_len; v++) {
for (int v = 0; v < mr.verts_num; v++) {
const BMVert *eve = BM_vert_at_index(bm, v);
/* Exceptional case where #bm_vert_co_get can be avoided, as we want the original coords.
* not the distorted ones. */
@@ -92,11 +92,11 @@ static void extract_tan_init_common(const MeshRenderData &mr,
}
}
else {
for (int v = 0; v < mr.vert_len; v++) {
for (int v = 0; v < mr.verts_num; v++) {
copy_v3_v3(orco_allocated[v], mr.vert_positions[v]);
}
}
BKE_mesh_orco_verts_transform(mr.mesh, orco_allocated, mr.vert_len, false);
BKE_mesh_orco_verts_transform(mr.mesh, orco_allocated, mr.verts_num, false);
orco = orco_allocated;
}
@@ -114,7 +114,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
reinterpret_cast<const float(*)[3]>(mr.corner_normals.data()),
orco,
r_loop_data,
mr.loop_len,
mr.corners_num,
&tangent_mask);
}
else {
@@ -123,7 +123,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
mr.corner_verts.data(),
mr.corner_tris.data(),
mr.corner_tri_faces.data(),
mr.tri_len,
mr.corner_tris_num,
mr.sharp_faces,
cd_ldata,
calc_active_tangent,
@@ -151,7 +151,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
MEM_SAFE_FREE(orco_allocated);
int v_len = mr.loop_len;
int v_len = mr.corners_num;
if (format->attr_len == 0) {
GPU_vertformat_attr_add(format, "dummy", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
/* VBO will not be used, only allocate minimum of memory. */
@@ -197,7 +197,7 @@ static void extract_tan_ex_init(const MeshRenderData &mr,
const char *name = tangent_names[i];
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_named(
&corner_data, CD_TANGENT, name);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
normal_float_to_short_v3(*tan_data, layer_data[corner]);
(*tan_data)[3] = (layer_data[corner][3] > 0.0f) ? SHRT_MAX : SHRT_MIN;
tan_data++;
@@ -206,7 +206,7 @@ static void extract_tan_ex_init(const MeshRenderData &mr,
if (use_orco_tan) {
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_n(
&corner_data, CD_TANGENT, 0);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
normal_float_to_short_v3(*tan_data, layer_data[corner]);
(*tan_data)[3] = (layer_data[corner][3] > 0.0f) ? SHRT_MAX : SHRT_MIN;
tan_data++;
@@ -219,7 +219,7 @@ static void extract_tan_ex_init(const MeshRenderData &mr,
const char *name = tangent_names[i];
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_named(
&corner_data, CD_TANGENT, name);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
*tan_data = GPU_normal_convert_i10_v3(layer_data[corner]);
tan_data->w = (layer_data[corner][3] > 0.0f) ? 1 : -2;
tan_data++;
@@ -228,7 +228,7 @@ static void extract_tan_ex_init(const MeshRenderData &mr,
if (use_orco_tan) {
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_n(
&corner_data, CD_TANGENT, 0);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
*tan_data = GPU_normal_convert_i10_v3(layer_data[corner]);
tan_data->w = (layer_data[corner][3] > 0.0f) ? 1 : -2;
tan_data++;
@@ -236,7 +236,7 @@ static void extract_tan_ex_init(const MeshRenderData &mr,
}
}
CustomData_free(&corner_data, mr.loop_len);
CustomData_free(&corner_data, mr.corners_num);
}
static void extract_tan_init(const MeshRenderData &mr,
@@ -298,7 +298,7 @@ static void extract_tan_init_subdiv(const DRWSubdivCache &subdiv_cache,
const char *name = tangent_names[i];
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_named(
&corner_data, CD_TANGENT, name);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
copy_v3_v3(*tan_data, layer_data[corner]);
(*tan_data)[3] = (layer_data[corner][3] > 0.0f) ? 1.0f : -1.0f;
tan_data++;
@@ -315,7 +315,7 @@ static void extract_tan_init_subdiv(const DRWSubdivCache &subdiv_cache,
float(*tan_data)[4] = (float(*)[4])GPU_vertbuf_get_data(coarse_vbo);
const float(*layer_data)[4] = (const float(*)[4])CustomData_get_layer_n(
&corner_data, CD_TANGENT, 0);
for (int corner = 0; corner < mr.loop_len; corner++) {
for (int corner = 0; corner < mr.corners_num; corner++) {
copy_v3_v3(*tan_data, layer_data[corner]);
(*tan_data)[3] = (layer_data[corner][3] > 0.0f) ? 1.0f : -1.0f;
tan_data++;
@@ -329,7 +329,7 @@ static void extract_tan_init_subdiv(const DRWSubdivCache &subdiv_cache,
subdiv_cache, coarse_vbo, dst_buffer, GPU_COMP_F32, 4, dst_offset);
}
CustomData_free(&corner_data, mr.loop_len);
CustomData_free(&corner_data, mr.corners_num);
GPU_vertbuf_discard(coarse_vbo);
}

8
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_uv.cc
View File

@@ -91,7 +91,7 @@ static void extract_uv_init(const MeshRenderData &mr,
CustomData *cd_ldata = (mr.extract_type == MR_EXTRACT_BMESH) ? &mr.bm->ldata :
&mr.mesh->corner_data;
int v_len = mr.loop_len;
int v_len = mr.corners_num;
uint32_t uv_layers = cache.cd_used.uv;
if (!mesh_extract_uv_format_init(&format, cache, cd_ldata, mr.extract_type, uv_layers)) {
/* VBO will not be used, only allocate minimum of memory. */
@@ -122,9 +122,9 @@ static void extract_uv_init(const MeshRenderData &mr,
else {
const Span<float2> uv_map(
static_cast<const float2 *>(CustomData_get_layer_n(cd_ldata, CD_PROP_FLOAT2, i)),
mr.loop_len);
array_utils::copy(uv_map, uv_data.slice(vbo_index, mr.loop_len));
vbo_index += mr.loop_len;
mr.corners_num);
array_utils::copy(uv_map, uv_data.slice(vbo_index, mr.corners_num));
vbo_index += mr.corners_num;
}
}
}

5
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_vnor.cc
View File

@@ -27,10 +27,11 @@ static void extract_vnor_init(const MeshRenderData &mr,
GPU_vertformat_attr_add(&format, "vnor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num);
if (mr.extract_type == MR_EXTRACT_MESH) {
MutableSpan vbo_data(static_cast<GPUPackedNormal *>(GPU_vertbuf_get_data(vbo)), mr.loop_len);
MutableSpan vbo_data(static_cast<GPUPackedNormal *>(GPU_vertbuf_get_data(vbo)),
mr.corners_num);
extract_vert_normals(mr, vbo_data);
}
else {

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc
View File

@@ -93,7 +93,7 @@ static void extract_weights_init(const MeshRenderData &mr,
GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr.loop_len + mr.loop_loose_len);
GPU_vertbuf_data_alloc(vbo, mr.corners_num + mr.loose_indices_num);
MeshExtract_Weight_Data *data = static_cast<MeshExtract_Weight_Data *>(tls_data);
data->vbo_data = (float *)GPU_vertbuf_get_data(vbo);