tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity
tornavis/source/blender/draw/intern/draw_cache_extract_mesh.c

4886 lines
156 KiB
C
Raw Normal View History

Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2017 by Blender Foundation.
* All rights reserved.
*/
/** \file
* \ingroup draw
*
* \brief Extraction of Mesh data into VBO to feed to GPU.
*/
#include "MEM_guardedalloc.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_alloca.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "BLI_bitmap.h"
#include "BLI_buffer.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_edgehash.h"
#include "BLI_jitter_2d.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "BLI_math_bits.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_math_vector.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "BLI_string.h"
#include "BLI_task.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_utildefines.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "BKE_bvhutils.h"
#include "BKE_customdata.h"
#include "BKE_deform.h"
#include "BKE_editmesh.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BKE_editmesh_bvh.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "BKE_editmesh_cache.h"
#include "BKE_editmesh_tangent.h"
#include "BKE_mesh.h"
#include "BKE_mesh_runtime.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BKE_mesh_tangent.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "BKE_modifier.h"
#include "BKE_object_deform.h"
#include "atomic_ops.h"
#include "bmesh.h"
#include "GPU_batch.h"
#include "GPU_extensions.h"
#include "DRW_render.h"
#include "ED_mesh.h"
#include "ED_uvedit.h"
#include "draw_cache_impl.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "draw_cache_inline.h"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
#include "draw_cache_extract.h"
// #define DEBUG_TIME
#ifdef DEBUG_TIME
# include "PIL_time_utildefines.h"
#endif
/* ---------------------------------------------------------------------- */
/** \name Mesh/BMesh Interface (indirect, partially cached access to complex data).
* \{ */
typedef struct MeshRenderData {
eMRExtractType extract_type;
int poly_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;
bool use_hide;
bool use_subsurf_fdots;
bool use_final_mesh;
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
/** Use for #MeshStatVis calculation which use world-space coords. */
float obmat[4][4];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const ToolSettings *toolsettings;
/* HACK not supposed to be there but it's needed. */
struct MeshBatchCache *cache;
/** Edit Mesh */
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *edit_bmesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
BMesh *bm;
EditMeshData *edit_data;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
/* For deformed edit-mesh data. */
/* Use for #ME_WRAPPER_TYPE_BMESH. */
const float (*bm_vert_coords)[3];
const float (*bm_vert_normals)[3];
const float (*bm_poly_normals)[3];
const float (*bm_poly_centers)[3];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int *v_origindex, *e_origindex, *p_origindex;
int crease_ofs;
int bweight_ofs;
int freestyle_edge_ofs;
int freestyle_face_ofs;
/** Mesh */
Mesh *me;
const MVert *mvert;
const MEdge *medge;
const MLoop *mloop;
const MPoly *mpoly;
BMVert *eve_act;
BMEdge *eed_act;
BMFace *efa_act;
BMFace *efa_act_uv;
/* Data created on-demand (usually not for bmesh-based data). */
MLoopTri *mlooptri;
float (*loop_normals)[3];
float (*poly_normals)[3];
int *lverts, *ledges;
} MeshRenderData;
static MeshRenderData *mesh_render_data_create(Mesh *me,
Fix T72667: Collection delete hierarchy in edit-mode crashes Also resolves T72848, although updating multiple windows doesn't work, this matches 2.7x behavior.
2020-01-08 12:20:45 +01:00
const bool is_editmode,
Fix T75343: Wireframe overylay is not working properly with multiple modifiers Since rBcf258b02f449, only wires and edges that are mapped to the original mesh were drawn if the mesh was modified by modifiers. Above commit was only meant for showing orig wires for paint mask overlays [where final wireframe is not desired], so now only use MR_EXTRACT_MAPPED when we are in a paint mode. Maniphest Tasks: T75343 Differential Revision: https://developer.blender.org/D7333
2020-04-04 11:14:45 +02:00
const bool is_paint_mode,
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
const float obmat[4][4],
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const bool do_final,
const bool do_uvedit,
const eMRIterType iter_type,
const eMRDataType data_flag,
const DRW_MeshCDMask *UNUSED(cd_used),
const ToolSettings *ts)
{
MeshRenderData *mr = MEM_callocN(sizeof(*mr), __func__);
mr->toolsettings = ts;
mr->mat_len = mesh_render_mat_len_get(me);
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
copy_m4_m4(mr->obmat, obmat);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const bool is_auto_smooth = (me->flag & ME_AUTOSMOOTH) != 0;
const float split_angle = is_auto_smooth ? me->smoothresh : (float)M_PI;
Fix T72667: Collection delete hierarchy in edit-mode crashes Also resolves T72848, although updating multiple windows doesn't work, this matches 2.7x behavior.
2020-01-08 12:20:45 +01:00
if (is_editmode) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
BLI_assert(me->edit_mesh->mesh_eval_cage && me->edit_mesh->mesh_eval_final);
mr->bm = me->edit_mesh->bm;
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
mr->edit_bmesh = me->edit_mesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->me = (do_final) ? me->edit_mesh->mesh_eval_final : me->edit_mesh->mesh_eval_cage;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
mr->edit_data = mr->me->runtime.edit_data;
if (mr->edit_data) {
EditMeshData *emd = mr->edit_data;
if (emd->vertexCos) {
BKE_editmesh_cache_ensure_vert_normals(mr->edit_bmesh, emd);
BKE_editmesh_cache_ensure_poly_normals(mr->edit_bmesh, emd);
}
mr->bm_vert_coords = mr->edit_data->vertexCos;
mr->bm_vert_normals = mr->edit_data->vertexNos;
mr->bm_poly_normals = mr->edit_data->polyNos;
mr->bm_poly_centers = mr->edit_data->polyCos;
}
bool has_mdata = (mr->me->runtime.wrapper_type == ME_WRAPPER_TYPE_MDATA);
bool use_mapped = has_mdata && !do_uvedit && mr->me && !mr->me->runtime.is_original;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int bm_ensure_types = BM_VERT | BM_EDGE | BM_LOOP | BM_FACE;
BM_mesh_elem_index_ensure(mr->bm, bm_ensure_types);
BM_mesh_elem_table_ensure(mr->bm, bm_ensure_types & ~BM_LOOP);
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
mr->efa_act_uv = EDBM_uv_active_face_get(mr->edit_bmesh, false, false);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->efa_act = BM_mesh_active_face_get(mr->bm, false, true);
mr->eed_act = BM_mesh_active_edge_get(mr->bm);
mr->eve_act = BM_mesh_active_vert_get(mr->bm);
mr->crease_ofs = CustomData_get_offset(&mr->bm->edata, CD_CREASE);
mr->bweight_ofs = CustomData_get_offset(&mr->bm->edata, CD_BWEIGHT);
#ifdef WITH_FREESTYLE
mr->freestyle_edge_ofs = CustomData_get_offset(&mr->bm->edata, CD_FREESTYLE_EDGE);
mr->freestyle_face_ofs = CustomData_get_offset(&mr->bm->pdata, CD_FREESTYLE_FACE);
#endif
if (use_mapped) {
mr->v_origindex = CustomData_get_layer(&mr->me->vdata, CD_ORIGINDEX);
mr->e_origindex = CustomData_get_layer(&mr->me->edata, CD_ORIGINDEX);
mr->p_origindex = CustomData_get_layer(&mr->me->pdata, CD_ORIGINDEX);
use_mapped = (mr->v_origindex || mr->e_origindex || mr->p_origindex);
}
mr->extract_type = use_mapped ? MR_EXTRACT_MAPPED : MR_EXTRACT_BMESH;
/* Seems like the mesh_eval_final do not have the right origin indices.
* Force not mapped in this case. */
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
if (has_mdata && do_final && me->edit_mesh->mesh_eval_final != me->edit_mesh->mesh_eval_cage) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
// mr->edit_bmesh = NULL;
mr->extract_type = MR_EXTRACT_MESH;
}
}
else {
mr->me = me;
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
mr->edit_bmesh = NULL;
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
Fix T75343: Wireframe overylay is not working properly with multiple modifiers Since rBcf258b02f449, only wires and edges that are mapped to the original mesh were drawn if the mesh was modified by modifiers. Above commit was only meant for showing orig wires for paint mask overlays [where final wireframe is not desired], so now only use MR_EXTRACT_MAPPED when we are in a paint mode. Maniphest Tasks: T75343 Differential Revision: https://developer.blender.org/D7333
2020-04-04 11:14:45 +02:00
bool use_mapped = is_paint_mode && mr->me && !mr->me->runtime.is_original;
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
if (use_mapped) {
mr->v_origindex = CustomData_get_layer(&mr->me->vdata, CD_ORIGINDEX);
mr->e_origindex = CustomData_get_layer(&mr->me->edata, CD_ORIGINDEX);
mr->p_origindex = CustomData_get_layer(&mr->me->pdata, CD_ORIGINDEX);
use_mapped = (mr->v_origindex || mr->e_origindex || mr->p_origindex);
}
mr->extract_type = use_mapped ? MR_EXTRACT_MAPPED : MR_EXTRACT_MESH;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
if (mr->extract_type != MR_EXTRACT_BMESH) {
/* Mesh */
mr->vert_len = mr->me->totvert;
mr->edge_len = mr->me->totedge;
mr->loop_len = mr->me->totloop;
mr->poly_len = mr->me->totpoly;
mr->tri_len = poly_to_tri_count(mr->poly_len, mr->loop_len);
mr->mvert = CustomData_get_layer(&mr->me->vdata, CD_MVERT);
mr->medge = CustomData_get_layer(&mr->me->edata, CD_MEDGE);
mr->mloop = CustomData_get_layer(&mr->me->ldata, CD_MLOOP);
mr->mpoly = CustomData_get_layer(&mr->me->pdata, CD_MPOLY);
mr->v_origindex = CustomData_get_layer(&mr->me->vdata, CD_ORIGINDEX);
mr->e_origindex = CustomData_get_layer(&mr->me->edata, CD_ORIGINDEX);
mr->p_origindex = CustomData_get_layer(&mr->me->pdata, CD_ORIGINDEX);
if (data_flag & (MR_DATA_POLY_NOR | MR_DATA_LOOP_NOR | MR_DATA_TAN_LOOP_NOR)) {
mr->poly_normals = MEM_mallocN(sizeof(*mr->poly_normals) * mr->poly_len, __func__);
BKE_mesh_calc_normals_poly((MVert *)mr->mvert,
NULL,
mr->vert_len,
mr->mloop,
mr->mpoly,
mr->loop_len,
mr->poly_len,
mr->poly_normals,
true);
}
if (((data_flag & MR_DATA_LOOP_NOR) && is_auto_smooth) || (data_flag & MR_DATA_TAN_LOOP_NOR)) {
mr->loop_normals = MEM_mallocN(sizeof(*mr->loop_normals) * mr->loop_len, __func__);
short(*clnors)[2] = CustomData_get_layer(&mr->me->ldata, CD_CUSTOMLOOPNORMAL);
BKE_mesh_normals_loop_split(mr->me->mvert,
mr->vert_len,
mr->me->medge,
mr->edge_len,
mr->me->mloop,
mr->loop_normals,
mr->loop_len,
mr->me->mpoly,
mr->poly_normals,
mr->poly_len,
is_auto_smooth,
split_angle,
NULL,
clnors,
NULL);
}
if ((iter_type & MR_ITER_LOOPTRI) || (data_flag & MR_DATA_LOOPTRI)) {
mr->mlooptri = MEM_mallocN(sizeof(*mr->mlooptri) * mr->tri_len, "MR_DATATYPE_LOOPTRI");
BKE_mesh_recalc_looptri(mr->me->mloop,
mr->me->mpoly,
mr->me->mvert,
mr->me->totloop,
mr->me->totpoly,
mr->mlooptri);
}
if (iter_type & (MR_ITER_LEDGE | MR_ITER_LVERT)) {
mr->vert_loose_len = 0;
mr->edge_loose_len = 0;
BLI_bitmap *lvert_map = BLI_BITMAP_NEW(mr->vert_len, "lvert map");
mr->ledges = MEM_mallocN(mr->edge_len * sizeof(int), __func__);
const MEdge *medge = mr->medge;
for (int e = 0; e < mr->edge_len; e++, medge++) {
if (medge->flag & ME_LOOSEEDGE) {
mr->ledges[mr->edge_loose_len++] = e;
}
/* Tag verts as not loose. */
BLI_BITMAP_ENABLE(lvert_map, medge->v1);
BLI_BITMAP_ENABLE(lvert_map, medge->v2);
}
if (mr->edge_loose_len < mr->edge_len) {
mr->ledges = MEM_reallocN(mr->ledges, mr->edge_loose_len * sizeof(*mr->ledges));
}
mr->lverts = MEM_mallocN(mr->vert_len * sizeof(*mr->lverts), __func__);
for (int v = 0; v < mr->vert_len; v++) {
if (!BLI_BITMAP_TEST(lvert_map, v)) {
mr->lverts[mr->vert_loose_len++] = v;
}
}
if (mr->vert_loose_len < mr->vert_len) {
mr->lverts = MEM_reallocN(mr->lverts, mr->vert_loose_len * sizeof(*mr->lverts));
}
MEM_freeN(lvert_map);
mr->loop_loose_len = mr->vert_loose_len + mr->edge_loose_len * 2;
}
}
else {
/* BMesh */
BMesh *bm = mr->bm;
mr->vert_len = bm->totvert;
mr->edge_len = bm->totedge;
mr->loop_len = bm->totloop;
mr->poly_len = bm->totface;
mr->tri_len = poly_to_tri_count(mr->poly_len, mr->loop_len);
if (data_flag & MR_DATA_POLY_NOR) {
/* Use bmface->no instead. */
}
if (((data_flag & MR_DATA_LOOP_NOR) && is_auto_smooth) || (data_flag & MR_DATA_TAN_LOOP_NOR)) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
const float(*vert_coords)[3] = NULL;
const float(*vert_normals)[3] = NULL;
const float(*poly_normals)[3] = NULL;
if (mr->edit_data && mr->edit_data->vertexCos) {
vert_coords = mr->bm_vert_coords;
vert_normals = mr->bm_vert_normals;
poly_normals = mr->bm_poly_normals;
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->loop_normals = MEM_mallocN(sizeof(*mr->loop_normals) * mr->loop_len, __func__);
int clnors_offset = CustomData_get_offset(&mr->bm->ldata, CD_CUSTOMLOOPNORMAL);
BM_loops_calc_normal_vcos(mr->bm,
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
vert_coords,
vert_normals,
poly_normals,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
is_auto_smooth,
split_angle,
mr->loop_normals,
NULL,
NULL,
clnors_offset,
false);
}
if ((iter_type & MR_ITER_LOOPTRI) || (data_flag & MR_DATA_LOOPTRI)) {
/* Edit mode ensures this is valid, no need to calculate. */
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BLI_assert((bm->totloop == 0) || (mr->edit_bmesh->looptris != NULL));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
if (iter_type & (MR_ITER_LEDGE | MR_ITER_LVERT)) {
int elem_id;
BMIter iter;
BMVert *eve;
BMEdge *ede;
mr->vert_loose_len = 0;
mr->edge_loose_len = 0;
mr->lverts = MEM_mallocN(mr->vert_len * sizeof(*mr->lverts), __func__);
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, elem_id) {
if (eve->e == NULL) {
mr->lverts[mr->vert_loose_len++] = elem_id;
}
}
if (mr->vert_loose_len < mr->vert_len) {
mr->lverts = MEM_reallocN(mr->lverts, mr->vert_loose_len * sizeof(*mr->lverts));
}
mr->ledges = MEM_mallocN(mr->edge_len * sizeof(*mr->ledges), __func__);
BM_ITER_MESH_INDEX (ede, &iter, bm, BM_EDGES_OF_MESH, elem_id) {
if (ede->l == NULL) {
mr->ledges[mr->edge_loose_len++] = elem_id;
}
}
if (mr->edge_loose_len < mr->edge_len) {
mr->ledges = MEM_reallocN(mr->ledges, mr->edge_loose_len * sizeof(*mr->ledges));
}
mr->loop_loose_len = mr->vert_loose_len + mr->edge_loose_len * 2;
}
}
return mr;
}
static void mesh_render_data_free(MeshRenderData *mr)
{
MEM_SAFE_FREE(mr->mlooptri);
MEM_SAFE_FREE(mr->poly_normals);
MEM_SAFE_FREE(mr->loop_normals);
MEM_SAFE_FREE(mr->lverts);
MEM_SAFE_FREE(mr->ledges);
MEM_freeN(mr);
}
BLI_INLINE BMFace *bm_original_face_get(const MeshRenderData *mr, int idx)
{
return ((mr->p_origindex != NULL) && (mr->p_origindex[idx] != ORIGINDEX_NONE) && mr->bm) ?
BM_face_at_index(mr->bm, mr->p_origindex[idx]) :
NULL;
}
BLI_INLINE BMEdge *bm_original_edge_get(const MeshRenderData *mr, int idx)
{
return ((mr->e_origindex != NULL) && (mr->e_origindex[idx] != ORIGINDEX_NONE) && mr->bm) ?
BM_edge_at_index(mr->bm, mr->e_origindex[idx]) :
NULL;
}
BLI_INLINE BMVert *bm_original_vert_get(const MeshRenderData *mr, int idx)
{
return ((mr->v_origindex != NULL) && (mr->v_origindex[idx] != ORIGINDEX_NONE) && mr->bm) ?
BM_vert_at_index(mr->bm, mr->v_origindex[idx]) :
NULL;
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
BLI_INLINE const float *bm_vert_co_get(const MeshRenderData *mr, const BMVert *eve)
{
const float(*vert_coords)[3] = mr->bm_vert_coords;
if (vert_coords != NULL) {
return vert_coords[BM_elem_index_get(eve)];
}
else {
UNUSED_VARS(mr);
return eve->co;
}
}
BLI_INLINE const float *bm_vert_no_get(const MeshRenderData *mr, const BMVert *eve)
{
const float(*vert_normals)[3] = mr->bm_vert_normals;
if (vert_normals != NULL) {
return vert_normals[BM_elem_index_get(eve)];
}
else {
UNUSED_VARS(mr);
return eve->co;
}
}
BLI_INLINE const float *bm_face_no_get(const MeshRenderData *mr, const BMFace *efa)
{
const float(*poly_normals)[3] = mr->bm_poly_normals;
if (poly_normals != NULL) {
return poly_normals[BM_elem_index_get(efa)];
}
else {
UNUSED_VARS(mr);
return efa->no;
}
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Mesh Elements Extract Iter
* \{ */
typedef void *(ExtractInitFn)(const MeshRenderData *mr, void *buffer);
typedef void(ExtractEditTriFn)(const MeshRenderData *mr, int t, BMLoop **e, void *data);
typedef void(ExtractEditLoopFn)(const MeshRenderData *mr, int l, BMLoop *el, void *data);
typedef void(ExtractEditLedgeFn)(const MeshRenderData *mr, int e, BMEdge *ed, void *data);
typedef void(ExtractEditLvertFn)(const MeshRenderData *mr, int v, BMVert *ev, void *data);
typedef void(ExtractTriFn)(const MeshRenderData *mr, int t, const MLoopTri *mlt, void *data);
typedef void(ExtractLoopFn)(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *data);
typedef void(ExtractLedgeFn)(const MeshRenderData *mr, int e, const MEdge *medge, void *data);
typedef void(ExtractLvertFn)(const MeshRenderData *mr, int v, const MVert *mvert, void *data);
typedef void(ExtractFinishFn)(const MeshRenderData *mr, void *buffer, void *data);
typedef struct MeshExtract {
/** Executed on main thread and return user data for iter functions. */
ExtractInitFn *init;
/** Executed on one (or more if use_threading) worker thread(s). */
ExtractEditTriFn *iter_looptri_bm;
ExtractTriFn *iter_looptri;
ExtractEditLoopFn *iter_loop_bm;
ExtractLoopFn *iter_loop;
ExtractEditLedgeFn *iter_ledge_bm;
ExtractLedgeFn *iter_ledge;
ExtractEditLvertFn *iter_lvert_bm;
ExtractLvertFn *iter_lvert;
/** Executed on one worker thread after all elements iterations. */
ExtractFinishFn *finish;
/** Used to request common data. */
const eMRDataType data_flag;
/** Used to know if the element callbacks are threadsafe and can be parallelized. */
const bool use_threading;
} MeshExtract;
BLI_INLINE eMRIterType mesh_extract_iter_type(const MeshExtract *ext)
{
eMRIterType type = 0;
SET_FLAG_FROM_TEST(type, (ext->iter_looptri_bm || ext->iter_looptri), MR_ITER_LOOPTRI);
SET_FLAG_FROM_TEST(type, (ext->iter_loop_bm || ext->iter_loop), MR_ITER_LOOP);
SET_FLAG_FROM_TEST(type, (ext->iter_ledge_bm || ext->iter_ledge), MR_ITER_LEDGE);
SET_FLAG_FROM_TEST(type, (ext->iter_lvert_bm || ext->iter_lvert), MR_ITER_LVERT);
return type;
}
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Triangles Indices
* \{ */
typedef struct MeshExtract_Tri_Data {
GPUIndexBufBuilder elb;
int *tri_mat_start;
int *tri_mat_end;
} MeshExtract_Tri_Data;
static void *extract_tris_init(const MeshRenderData *mr, void *UNUSED(ibo))
{
MeshExtract_Tri_Data *data = MEM_callocN(sizeof(*data), __func__);
size_t mat_tri_idx_size = sizeof(int) * mr->mat_len;
data->tri_mat_start = MEM_callocN(mat_tri_idx_size, __func__);
data->tri_mat_end = MEM_callocN(mat_tri_idx_size, __func__);
int *mat_tri_len = data->tri_mat_start;
/* Count how many triangle for each material. */
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMIter iter;
BMFace *efa;
BM_ITER_MESH (efa, &iter, mr->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
2019-08-18 22:40:47 +02:00
int mat = min_ii(efa->mat_nr, mr->mat_len - 1);
mat_tri_len[mat] += efa->len - 2;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
}
else {
const MPoly *mpoly = mr->mpoly;
for (int p = 0; p < mr->poly_len; p++, mpoly++) {
if (!(mr->use_hide && (mpoly->flag & ME_HIDE))) {
Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
2019-08-18 22:40:47 +02:00
int mat = min_ii(mpoly->mat_nr, mr->mat_len - 1);
mat_tri_len[mat] += mpoly->totloop - 2;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
}
/* Accumulate tri len per mat to have correct offsets. */
int ofs = mat_tri_len[0];
mat_tri_len[0] = 0;
for (int i = 1; i < mr->mat_len; i++) {
int tmp = mat_tri_len[i];
mat_tri_len[i] = ofs;
ofs += tmp;
}
memcpy(data->tri_mat_end, mat_tri_len, mat_tri_idx_size);
int visible_tri_tot = ofs;
GPU_indexbuf_init(&data->elb, GPU_PRIM_TRIS, visible_tri_tot, mr->loop_len);
return data;
}
Fix T71319, T71015: crash in edit mode with out of range material assignments
2019-11-06 16:06:57 +01:00
static void extract_tris_looptri_bmesh(const MeshRenderData *mr,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int UNUSED(t),
BMLoop **elt,
void *_data)
{
if (!BM_elem_flag_test(elt[0]->f, BM_ELEM_HIDDEN)) {
MeshExtract_Tri_Data *data = _data;
int *mat_tri_ofs = data->tri_mat_end;
Fix T71319, T71015: crash in edit mode with out of range material assignments
2019-11-06 16:06:57 +01:00
int mat = min_ii(elt[0]->f->mat_nr, mr->mat_len - 1);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_indexbuf_set_tri_verts(&data->elb,
Fix T71319, T71015: crash in edit mode with out of range material assignments
2019-11-06 16:06:57 +01:00
mat_tri_ofs[mat]++,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
BM_elem_index_get(elt[0]),
BM_elem_index_get(elt[1]),
BM_elem_index_get(elt[2]));
}
}
static void extract_tris_looptri_mesh(const MeshRenderData *mr,
int UNUSED(t),
const MLoopTri *mlt,
void *_data)
{
const MPoly *mpoly = &mr->mpoly[mlt->poly];
Fix T68715 Hidden polygon Edit mode are hidden in Object level
2019-08-16 15:00:38 +02:00
if (!(mr->use_hide && (mpoly->flag & ME_HIDE))) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
MeshExtract_Tri_Data *data = _data;
int *mat_tri_ofs = data->tri_mat_end;
Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
2019-08-18 22:40:47 +02:00
int mat = min_ii(mpoly->mat_nr, mr->mat_len - 1);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_indexbuf_set_tri_verts(
Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
2019-08-18 22:40:47 +02:00
&data->elb, mat_tri_ofs[mat]++, mlt->tri[0], mlt->tri[1], mlt->tri[2]);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
static void extract_tris_finish(const MeshRenderData *mr, void *ibo, void *_data)
{
MeshExtract_Tri_Data *data = _data;
GPU_indexbuf_build_in_place(&data->elb, ibo);
/* HACK Create ibo subranges and assign them to each GPUBatch. */
if (mr->use_final_mesh && mr->cache->surface_per_mat && mr->cache->surface_per_mat[0]) {
BLI_assert(mr->cache->surface_per_mat[0]->elem == ibo);
Cleanup: use post increment/decrement When the result isn't used, prefer post increment/decrement (already used nearly everywhere in Blender).
2019-09-07 16:12:26 +02:00
for (int i = 0; i < mr->mat_len; i++) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Multiply by 3 because these are triangle indices. */
int start = data->tri_mat_start[i] * 3;
int len = data->tri_mat_end[i] * 3 - data->tri_mat_start[i] * 3;
GPUIndexBuf *sub_ibo = GPU_indexbuf_create_subrange(ibo, start, len);
/* WARNING: We modify the GPUBatch here! */
GPU_batch_elembuf_set(mr->cache->surface_per_mat[i], sub_ibo, true);
}
}
MEM_freeN(data->tri_mat_start);
MEM_freeN(data->tri_mat_end);
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_tris = {
extract_tris_init,
extract_tris_looptri_bmesh,
extract_tris_looptri_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
extract_tris_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edges Indices
* \{ */
static void *extract_lines_init(const MeshRenderData *mr, void *UNUSED(buf))
{
GPUIndexBufBuilder *elb = MEM_mallocN(sizeof(*elb), __func__);
/* Put loose edges at the end. */
GPU_indexbuf_init(
elb, GPU_PRIM_LINES, mr->edge_len + mr->edge_loose_len, mr->loop_len + mr->loop_loose_len);
return elb;
}
static void extract_lines_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *elb)
{
if (!BM_elem_flag_test(loop->e, BM_ELEM_HIDDEN)) {
GPU_indexbuf_set_line_verts(elb, BM_elem_index_get(loop->e), l, BM_elem_index_get(loop->next));
}
else {
GPU_indexbuf_set_line_restart(elb, BM_elem_index_get(loop->e));
}
}
static void extract_lines_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *mpoly,
void *elb)
{
const MEdge *medge = &mr->medge[mloop->e];
if (!((mr->use_hide && (medge->flag & ME_HIDE)) ||
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) &&
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
(mr->e_origindex[mloop->e] == ORIGINDEX_NONE)))) {
int loopend = mpoly->totloop + mpoly->loopstart - 1;
int other_loop = (l == loopend) ? mpoly->loopstart : (l + 1);
GPU_indexbuf_set_line_verts(elb, mloop->e, l, other_loop);
}
else {
GPU_indexbuf_set_line_restart(elb, mloop->e);
}
}
static void extract_lines_ledge_bmesh(const MeshRenderData *mr, int e, BMEdge *eed, void *elb)
{
int ledge_idx = mr->edge_len + e;
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
int l = mr->loop_len + e * 2;
GPU_indexbuf_set_line_verts(elb, ledge_idx, l, l + 1);
}
else {
GPU_indexbuf_set_line_restart(elb, ledge_idx);
}
/* Don't render the edge twice. */
GPU_indexbuf_set_line_restart(elb, BM_elem_index_get(eed));
}
static void extract_lines_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *medge,
void *elb)
{
int ledge_idx = mr->edge_len + e;
int edge_idx = mr->ledges[e];
if (!((mr->use_hide && (medge->flag & ME_HIDE)) ||
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) &&
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
(mr->e_origindex[edge_idx] == ORIGINDEX_NONE)))) {
int l = mr->loop_len + e * 2;
GPU_indexbuf_set_line_verts(elb, ledge_idx, l, l + 1);
}
else {
GPU_indexbuf_set_line_restart(elb, ledge_idx);
}
/* Don't render the edge twice. */
GPU_indexbuf_set_line_restart(elb, edge_idx);
}
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
static void extract_lines_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *elb)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
GPU_indexbuf_build_in_place(elb, ibo);
MEM_freeN(elb);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_lines = {
extract_lines_init,
NULL,
NULL,
extract_lines_loop_bmesh,
extract_lines_loop_mesh,
extract_lines_ledge_bmesh,
extract_lines_ledge_mesh,
NULL,
NULL,
extract_lines_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
/* ---------------------------------------------------------------------- */
/** \name Extract Loose Edges Indices
* \{ */
static void *extract_lines_loose_init(const MeshRenderData *UNUSED(mr), void *UNUSED(buf))
{
return NULL;
}
static void extract_lines_loose_ledge_mesh(const MeshRenderData *UNUSED(mr),
int UNUSED(e),
const MEdge *UNUSED(medge),
void *UNUSED(elb))
{
/* This function is intentionally empty. The existence of this functions ensures that
* `iter_type` `MR_ITER_LVERT` is set when initializing the `MeshRenderData` (See
* `mesh_extract_iter_type`). This flag ensures that `mr->edge_loose_len` field is filled. This
* field we use in the `extract_lines_loose_finish` function to create a subrange from the
* `ibo.lines`. */
}
Fix T72788: Crash Edit Custom Bone Object In a recent refactor we splitted the lines extractor in `extract_lines` and `extract_lines_loose`. When an object is in edit mode the extracted lines loose also had to include a dummy bmesh edge iterator. This change adds this missing dummy method. Reviewed By: antoniov Differential Revision: https://developer.blender.org/D6499
2019-12-30 13:04:09 +01:00
static void extract_lines_loose_ledge_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(e),
BMEdge *UNUSED(eed),
void *UNUSED(elb))
{
/* This function is intentionally empty. The existence of this functions ensures that
* `iter_type` `MR_ITER_LVERT` is set when initializing the `MeshRenderData` (See
* `mesh_extract_iter_type`). This flag ensures that `mr->edge_loose_len` field is filled. This
* field we use in the `extract_lines_loose_finish` function to create a subrange from the
* `ibo.lines`. */
}
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
static void extract_lines_loose_finish(const MeshRenderData *mr,
void *UNUSED(ibo),
void *UNUSED(elb))
{
/* Multiply by 2 because these are edges indices. */
const int start = mr->edge_len * 2;
const int len = mr->edge_loose_len * 2;
GPU_indexbuf_create_subrange_in_place(
mr->cache->final.ibo.lines_loose, mr->cache->final.ibo.lines, start, len);
mr->cache->no_loose_wire = (len == 0);
}
static const MeshExtract extract_lines_loose = {
extract_lines_loose_init,
NULL,
NULL,
NULL,
NULL,
Fix T72788: Crash Edit Custom Bone Object In a recent refactor we splitted the lines extractor in `extract_lines` and `extract_lines_loose`. When an object is in edit mode the extracted lines loose also had to include a dummy bmesh edge iterator. This change adds this missing dummy method. Reviewed By: antoniov Differential Revision: https://developer.blender.org/D6499
2019-12-30 13:04:09 +01:00
extract_lines_loose_ledge_bmesh,
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
extract_lines_loose_ledge_mesh,
NULL,
NULL,
extract_lines_loose_finish,
0,
false,
};
/** \} */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract Point Indices
* \{ */
static void *extract_points_init(const MeshRenderData *mr, void *UNUSED(buf))
{
GPUIndexBufBuilder *elb = MEM_mallocN(sizeof(*elb), __func__);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr->vert_len, mr->loop_len + mr->loop_loose_len);
return elb;
}
BLI_INLINE void vert_set_bmesh(GPUIndexBufBuilder *elb, BMVert *eve, int loop)
{
int vert_idx = BM_elem_index_get(eve);
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
GPU_indexbuf_set_point_vert(elb, vert_idx, loop);
}
else {
GPU_indexbuf_set_point_restart(elb, vert_idx);
}
}
BLI_INLINE void vert_set_mesh(GPUIndexBufBuilder *elb,
const MeshRenderData *mr,
int vert_idx,
int loop)
{
const MVert *mvert = &mr->mvert[vert_idx];
if (!((mr->use_hide && (mvert->flag & ME_HIDE)) ||
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->v_origindex) &&
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
(mr->v_origindex[vert_idx] == ORIGINDEX_NONE)))) {
GPU_indexbuf_set_point_vert(elb, vert_idx, loop);
}
else {
GPU_indexbuf_set_point_restart(elb, vert_idx);
}
}
static void extract_points_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *elb)
{
vert_set_bmesh(elb, loop->v, l);
}
static void extract_points_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *UNUSED(mpoly),
void *elb)
{
vert_set_mesh(elb, mr, mloop->v, l);
}
static void extract_points_ledge_bmesh(const MeshRenderData *mr, int e, BMEdge *eed, void *elb)
{
vert_set_bmesh(elb, eed->v1, mr->loop_len + e * 2);
vert_set_bmesh(elb, eed->v2, mr->loop_len + e * 2 + 1);
}
static void extract_points_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *medge,
void *elb)
{
vert_set_mesh(elb, mr, medge->v1, mr->loop_len + e * 2);
vert_set_mesh(elb, mr, medge->v2, mr->loop_len + e * 2 + 1);
}
static void extract_points_lvert_bmesh(const MeshRenderData *mr, int v, BMVert *eve, void *elb)
{
vert_set_bmesh(elb, eve, mr->loop_len + mr->edge_loose_len * 2 + v);
}
static void extract_points_lvert_mesh(const MeshRenderData *mr,
int v,
const MVert *UNUSED(mvert),
void *elb)
{
vert_set_mesh(elb, mr, mr->lverts[v], mr->loop_len + mr->edge_loose_len * 2 + v);
}
static void extract_points_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *elb)
{
GPU_indexbuf_build_in_place(elb, ibo);
MEM_freeN(elb);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_points = {
extract_points_init,
NULL,
NULL,
extract_points_loop_bmesh,
extract_points_loop_mesh,
extract_points_ledge_bmesh,
extract_points_ledge_mesh,
extract_points_lvert_bmesh,
extract_points_lvert_mesh,
extract_points_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Facedots Indices
* \{ */
static void *extract_fdots_init(const MeshRenderData *mr, void *UNUSED(buf))
{
GPUIndexBufBuilder *elb = MEM_mallocN(sizeof(*elb), __func__);
GPU_indexbuf_init(elb, GPU_PRIM_POINTS, mr->poly_len, mr->poly_len);
return elb;
}
static void extract_fdots_loop_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(l),
BMLoop *loop,
void *elb)
{
int face_idx = BM_elem_index_get(loop->f);
if (!BM_elem_flag_test(loop->f, BM_ELEM_HIDDEN)) {
GPU_indexbuf_set_point_vert(elb, face_idx, face_idx);
}
else {
GPU_indexbuf_set_point_restart(elb, face_idx);
}
}
static void extract_fdots_loop_mesh(const MeshRenderData *mr,
int UNUSED(l),
const MLoop *mloop,
int p,
const MPoly *mpoly,
void *elb)
{
const MVert *mvert = &mr->mvert[mloop->v];
if ((!mr->use_subsurf_fdots || (mvert->flag & ME_VERT_FACEDOT)) &&
!(mr->use_hide && (mpoly->flag & ME_HIDE))) {
GPU_indexbuf_set_point_vert(elb, p, p);
}
else {
GPU_indexbuf_set_point_restart(elb, p);
}
}
static void extract_fdots_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *elb)
{
GPU_indexbuf_build_in_place(elb, ibo);
MEM_freeN(elb);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdots = {
extract_fdots_init,
NULL,
NULL,
extract_fdots_loop_bmesh,
extract_fdots_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_fdots_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Paint Mask Line Indices
* \{ */
typedef struct MeshExtract_LinePaintMask_Data {
GPUIndexBufBuilder elb;
/** One bit per edge set if face is selected. */
BLI_bitmap select_map[0];
} MeshExtract_LinePaintMask_Data;
static void *extract_lines_paint_mask_init(const MeshRenderData *mr, void *UNUSED(buf))
{
size_t bitmap_size = BLI_BITMAP_SIZE(mr->edge_len);
MeshExtract_LinePaintMask_Data *data = MEM_callocN(sizeof(*data) + bitmap_size, __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr->edge_len, mr->loop_len);
return data;
}
static void extract_lines_paint_mask_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *mpoly,
void *_data)
{
MeshExtract_LinePaintMask_Data *data = (MeshExtract_LinePaintMask_Data *)_data;
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
const int edge_idx = mloop->e;
const MEdge *medge = &mr->medge[edge_idx];
if (!((mr->use_hide && (medge->flag & ME_HIDE)) ||
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->e_origindex) &&
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
(mr->e_origindex[edge_idx] == ORIGINDEX_NONE)))) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int loopend = mpoly->totloop + mpoly->loopstart - 1;
int other_loop = (l == loopend) ? mpoly->loopstart : (l + 1);
if (mpoly->flag & ME_FACE_SEL) {
if (BLI_BITMAP_TEST_AND_SET_ATOMIC(data->select_map, edge_idx)) {
/* Hide edge as it has more than 2 selected loop. */
GPU_indexbuf_set_line_restart(&data->elb, edge_idx);
}
else {
/* First selected loop. Set edge visible, overwritting any unsel loop. */
GPU_indexbuf_set_line_verts(&data->elb, edge_idx, l, other_loop);
}
}
else {
/* Set theses unselected loop only if this edge has no other selected loop. */
if (!BLI_BITMAP_TEST(data->select_map, edge_idx)) {
GPU_indexbuf_set_line_verts(&data->elb, edge_idx, l, other_loop);
}
}
}
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
else {
GPU_indexbuf_set_line_restart(&data->elb, edge_idx);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_lines_paint_mask_finish(const MeshRenderData *UNUSED(mr),
void *ibo,
void *_data)
{
MeshExtract_LinePaintMask_Data *data = (MeshExtract_LinePaintMask_Data *)_data;
GPU_indexbuf_build_in_place(&data->elb, ibo);
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_lines_paint_mask = {
extract_lines_paint_mask_init,
NULL,
NULL,
NULL,
extract_lines_paint_mask_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_lines_paint_mask_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Line Adjacency Indices
* \{ */
#define NO_EDGE INT_MAX
typedef struct MeshExtract_LineAdjacency_Data {
GPUIndexBufBuilder elb;
EdgeHash *eh;
bool is_manifold;
/* Array to convert vert index to any loop index of this vert. */
uint vert_to_loop[0];
} MeshExtract_LineAdjacency_Data;
static void *extract_lines_adjacency_init(const MeshRenderData *mr, void *UNUSED(buf))
{
/* Similar to poly_to_tri_count().
* There is always loop + tri - 1 edges inside a polygon.
Cleanup: spelling
2019-08-16 16:54:22 +02:00
* Accumulate for all polys and you get : */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
uint tess_edge_len = mr->loop_len + mr->tri_len - mr->poly_len;
size_t vert_to_loop_size = sizeof(uint) * mr->vert_len;
MeshExtract_LineAdjacency_Data *data = MEM_callocN(sizeof(*data) + vert_to_loop_size, __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES_ADJ, tess_edge_len, mr->loop_len);
data->eh = BLI_edgehash_new_ex(__func__, tess_edge_len);
data->is_manifold = true;
return data;
}
BLI_INLINE void lines_adjacency_triangle(
uint v1, uint v2, uint v3, uint l1, uint l2, uint l3, MeshExtract_LineAdjacency_Data *data)
{
GPUIndexBufBuilder *elb = &data->elb;
/* Iter around the triangle's edges. */
for (int e = 0; e < 3; e++) {
Cleanup: extra semicolon, comma warnings
2019-09-21 03:34:39 +02:00
SHIFT3(uint, v3, v2, v1);
SHIFT3(uint, l3, l2, l1);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
bool inv_indices = (v2 > v3);
void **pval;
bool value_is_init = BLI_edgehash_ensure_p(data->eh, v2, v3, &pval);
int v_data = POINTER_AS_INT(*pval);
if (!value_is_init || v_data == NO_EDGE) {
/* Save the winding order inside the sign bit. Because the
* edgehash sort the keys and we need to compare winding later. */
int value = (int)l1 + 1; /* 0 cannot be signed so add one. */
*pval = POINTER_FROM_INT((inv_indices) ? -value : value);
/* Store loop indices for remaining non-manifold edges. */
data->vert_to_loop[v2] = l2;
data->vert_to_loop[v3] = l3;
}
else {
/* HACK Tag as not used. Prevent overhead of BLI_edgehash_remove. */
*pval = POINTER_FROM_INT(NO_EDGE);
bool inv_opposite = (v_data < 0);
uint l_opposite = (uint)abs(v_data) - 1;
/* TODO Make this part threadsafe. */
if (inv_opposite == inv_indices) {
/* Don't share edge if triangles have non matching winding. */
GPU_indexbuf_add_line_adj_verts(elb, l1, l2, l3, l1);
GPU_indexbuf_add_line_adj_verts(elb, l_opposite, l2, l3, l_opposite);
data->is_manifold = false;
}
else {
GPU_indexbuf_add_line_adj_verts(elb, l1, l2, l3, l_opposite);
}
}
}
}
static void extract_lines_adjacency_looptri_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(t),
BMLoop **elt,
void *data)
{
if (!BM_elem_flag_test(elt[0]->f, BM_ELEM_HIDDEN)) {
lines_adjacency_triangle(BM_elem_index_get(elt[0]->v),
BM_elem_index_get(elt[1]->v),
BM_elem_index_get(elt[2]->v),
BM_elem_index_get(elt[0]),
BM_elem_index_get(elt[1]),
BM_elem_index_get(elt[2]),
data);
}
}
static void extract_lines_adjacency_looptri_mesh(const MeshRenderData *mr,
int UNUSED(t),
const MLoopTri *mlt,
void *data)
{
const MPoly *mpoly = &mr->mpoly[mlt->poly];
Fix T74643: Outline Overlay Shows Hidden Faces When in editmode faces can be hidden, but in object mode these faces are still visible. The flag if a face was hidden in edit mode is stored in object mode, but should not be used. The edge detection gpu batch did detect hidden faces and didn't add them to the draw batch. The edge detection gpu batch is used for workbench shadows, custom bone shapes and object outlines. This patch adds all faces to the edge detection batch. Reviewed By: fclem Differential Revision: https://developer.blender.org/D7157
2020-03-17 12:05:45 +01:00
if (!(mr->use_hide && (mpoly->flag & ME_HIDE))) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
lines_adjacency_triangle(mr->mloop[mlt->tri[0]].v,
mr->mloop[mlt->tri[1]].v,
mr->mloop[mlt->tri[2]].v,
mlt->tri[0],
mlt->tri[1],
mlt->tri[2],
data);
}
}
static void extract_lines_adjacency_finish(const MeshRenderData *mr, void *ibo, void *_data)
{
MeshExtract_LineAdjacency_Data *data = (MeshExtract_LineAdjacency_Data *)_data;
/* Create edges for remaining non manifold edges. */
EdgeHashIterator *ehi = BLI_edgehashIterator_new(data->eh);
for (; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
uint v2, v3, l1, l2, l3;
int v_data = POINTER_AS_INT(BLI_edgehashIterator_getValue(ehi));
if (v_data != NO_EDGE) {
BLI_edgehashIterator_getKey(ehi, &v2, &v3);
l1 = (uint)abs(v_data) - 1;
if (v_data < 0) { /* inv_opposite */
SWAP(uint, v2, v3);
}
l2 = data->vert_to_loop[v2];
l3 = data->vert_to_loop[v3];
GPU_indexbuf_add_line_adj_verts(&data->elb, l1, l2, l3, l1);
data->is_manifold = false;
}
}
BLI_edgehashIterator_free(ehi);
BLI_edgehash_free(data->eh, NULL);
mr->cache->is_manifold = data->is_manifold;
GPU_indexbuf_build_in_place(&data->elb, ibo);
MEM_freeN(data);
}
#undef NO_EDGE
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_lines_adjacency = {
extract_lines_adjacency_init,
extract_lines_adjacency_looptri_bmesh,
extract_lines_adjacency_looptri_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
extract_lines_adjacency_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV Triangles Indices
* \{ */
typedef struct MeshExtract_EditUvElem_Data {
GPUIndexBufBuilder elb;
bool sync_selection;
} MeshExtract_EditUvElem_Data;
static void *extract_edituv_tris_init(const MeshRenderData *mr, void *UNUSED(ibo))
{
MeshExtract_EditUvElem_Data *data = MEM_callocN(sizeof(*data), __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_TRIS, mr->tri_len, mr->loop_len);
data->sync_selection = (mr->toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
return data;
}
BLI_INLINE void edituv_tri_add(
MeshExtract_EditUvElem_Data *data, bool hidden, bool selected, int v1, int v2, int v3)
{
if (!hidden && (data->sync_selection || selected)) {
GPU_indexbuf_add_tri_verts(&data->elb, v1, v2, v3);
}
}
static void extract_edituv_tris_looptri_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(t),
BMLoop **elt,
void *data)
{
edituv_tri_add(data,
BM_elem_flag_test(elt[0]->f, BM_ELEM_HIDDEN),
BM_elem_flag_test(elt[0]->f, BM_ELEM_SELECT),
BM_elem_index_get(elt[0]),
BM_elem_index_get(elt[1]),
BM_elem_index_get(elt[2]));
}
static void extract_edituv_tris_looptri_mesh(const MeshRenderData *mr,
int UNUSED(t),
const MLoopTri *mlt,
void *data)
{
const MPoly *mpoly = &mr->mpoly[mlt->poly];
edituv_tri_add(data,
(mpoly->flag & ME_HIDE) != 0,
(mpoly->flag & ME_FACE_SEL) != 0,
mlt->tri[0],
mlt->tri[1],
mlt->tri[2]);
}
static void extract_edituv_tris_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *data)
{
MeshExtract_EditUvElem_Data *extract_data = (MeshExtract_EditUvElem_Data *)data;
GPU_indexbuf_build_in_place(&extract_data->elb, ibo);
MEM_freeN(extract_data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edituv_tris = {
extract_edituv_tris_init,
extract_edituv_tris_looptri_bmesh,
extract_edituv_tris_looptri_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
extract_edituv_tris_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV Line Indices around faces
* \{ */
static void *extract_edituv_lines_init(const MeshRenderData *mr, void *UNUSED(ibo))
{
MeshExtract_EditUvElem_Data *data = MEM_callocN(sizeof(*data), __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_LINES, mr->loop_len, mr->loop_len);
data->sync_selection = (mr->toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
return data;
}
BLI_INLINE void edituv_edge_add(
MeshExtract_EditUvElem_Data *data, bool hidden, bool selected, int v1, int v2)
{
if (!hidden && (data->sync_selection || selected)) {
GPU_indexbuf_add_line_verts(&data->elb, v1, v2);
}
}
static void extract_edituv_lines_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
edituv_edge_add(data,
BM_elem_flag_test(loop->f, BM_ELEM_HIDDEN),
BM_elem_flag_test(loop->f, BM_ELEM_SELECT),
l,
BM_elem_index_get(loop->next));
}
static void extract_edituv_lines_loop_mesh(const MeshRenderData *mr,
int loop_idx,
const MLoop *mloop,
int UNUSED(p),
const MPoly *mpoly,
void *data)
{
int loopend = mpoly->totloop + mpoly->loopstart - 1;
int loop_next_idx = (loop_idx == loopend) ? mpoly->loopstart : (loop_idx + 1);
Fix T70206 Texture Paint: UV shadow doesnt show up
2019-10-01 16:02:01 +02:00
const bool real_edge = (mr->e_origindex == NULL || mr->e_origindex[mloop->e] != ORIGINDEX_NONE);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
edituv_edge_add(data,
(mpoly->flag & ME_HIDE) != 0 || !real_edge,
(mpoly->flag & ME_FACE_SEL) != 0,
loop_idx,
loop_next_idx);
}
static void extract_edituv_lines_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *data)
{
MeshExtract_EditUvElem_Data *extract_data = (MeshExtract_EditUvElem_Data *)data;
GPU_indexbuf_build_in_place(&extract_data->elb, ibo);
MEM_freeN(extract_data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edituv_lines = {
extract_edituv_lines_init,
NULL,
NULL,
extract_edituv_lines_loop_bmesh,
extract_edituv_lines_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_edituv_lines_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV Points Indices
* \{ */
static void *extract_edituv_points_init(const MeshRenderData *mr, void *UNUSED(ibo))
{
MeshExtract_EditUvElem_Data *data = MEM_callocN(sizeof(*data), __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr->loop_len, mr->loop_len);
data->sync_selection = (mr->toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
return data;
}
BLI_INLINE void edituv_point_add(MeshExtract_EditUvElem_Data *data,
bool hidden,
bool selected,
int v1)
{
if (!hidden && (data->sync_selection || selected)) {
GPU_indexbuf_add_point_vert(&data->elb, v1);
}
}
static void extract_edituv_points_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
edituv_point_add(data,
BM_elem_flag_test(loop->f, BM_ELEM_HIDDEN),
BM_elem_flag_test(loop->f, BM_ELEM_SELECT),
l);
}
static void extract_edituv_points_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *mpoly,
void *data)
{
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
const bool real_vert = (mr->extract_type == MR_EXTRACT_MAPPED && (mr->v_origindex) &&
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->v_origindex[mloop->v] != ORIGINDEX_NONE);
edituv_point_add(
data, ((mpoly->flag & ME_HIDE) != 0) || !real_vert, (mpoly->flag & ME_FACE_SEL) != 0, l);
}
static void extract_edituv_points_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *data)
{
MeshExtract_EditUvElem_Data *extract_data = (MeshExtract_EditUvElem_Data *)data;
GPU_indexbuf_build_in_place(&extract_data->elb, ibo);
MEM_freeN(extract_data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edituv_points = {
extract_edituv_points_init,
NULL,
NULL,
extract_edituv_points_loop_bmesh,
extract_edituv_points_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_edituv_points_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV Facedots Indices
* \{ */
static void *extract_edituv_fdots_init(const MeshRenderData *mr, void *UNUSED(ibo))
{
MeshExtract_EditUvElem_Data *data = MEM_callocN(sizeof(*data), __func__);
GPU_indexbuf_init(&data->elb, GPU_PRIM_POINTS, mr->poly_len, mr->poly_len);
data->sync_selection = (mr->toolsettings->uv_flag & UV_SYNC_SELECTION) != 0;
return data;
}
BLI_INLINE void edituv_facedot_add(MeshExtract_EditUvElem_Data *data,
bool hidden,
bool selected,
int face_idx)
{
if (!hidden && (data->sync_selection || selected)) {
GPU_indexbuf_set_point_vert(&data->elb, face_idx, face_idx);
}
else {
GPU_indexbuf_set_point_restart(&data->elb, face_idx);
}
}
static void extract_edituv_fdots_loop_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(l),
BMLoop *loop,
void *data)
{
edituv_facedot_add(data,
BM_elem_flag_test(loop->f, BM_ELEM_HIDDEN),
BM_elem_flag_test(loop->f, BM_ELEM_SELECT),
BM_elem_index_get(loop->f));
}
static void extract_edituv_fdots_loop_mesh(const MeshRenderData *mr,
int UNUSED(l),
const MLoop *mloop,
int p,
const MPoly *mpoly,
void *data)
{
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
const bool real_fdot = (mr->extract_type == MR_EXTRACT_MAPPED && mr->p_origindex &&
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->p_origindex[p] != ORIGINDEX_NONE);
const bool subd_fdot = (!mr->use_subsurf_fdots ||
(mr->mvert[mloop->v].flag & ME_VERT_FACEDOT) != 0);
edituv_facedot_add(data,
((mpoly->flag & ME_HIDE) != 0) || !real_fdot || !subd_fdot,
(mpoly->flag & ME_FACE_SEL) != 0,
p);
}
static void extract_edituv_fdots_finish(const MeshRenderData *UNUSED(mr), void *ibo, void *_data)
{
MeshExtract_EditUvElem_Data *data = (MeshExtract_EditUvElem_Data *)_data;
GPU_indexbuf_build_in_place(&data->elb, ibo);
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edituv_fdots = {
extract_edituv_fdots_init,
NULL,
NULL,
extract_edituv_fdots_loop_bmesh,
extract_edituv_fdots_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_edituv_fdots_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Position and Vertex Normal
* \{ */
typedef struct PosNorLoop {
float pos[3];
GPUPackedNormal nor;
} PosNorLoop;
typedef struct MeshExtract_PosNor_Data {
PosNorLoop *vbo_data;
GPUPackedNormal packed_nor[];
} MeshExtract_PosNor_Data;
static void *extract_pos_nor_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* WARNING Adjust PosNorLoop struct accordingly. */
GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
GPU_vertformat_attr_add(&format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
GPU_vertformat_alias_add(&format, "vnor");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len + mr->loop_loose_len);
/* Pack normals per vert, reduce amount of computation. */
size_t packed_nor_len = sizeof(GPUPackedNormal) * mr->vert_len;
MeshExtract_PosNor_Data *data = MEM_mallocN(sizeof(*data) + packed_nor_len, __func__);
data->vbo_data = (PosNorLoop *)vbo->data;
/* Quicker than doing it for each loop. */
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMIter iter;
BMVert *eve;
int v;
BM_ITER_MESH_INDEX (eve, &iter, mr->bm, BM_VERTS_OF_MESH, v) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
data->packed_nor[v] = GPU_normal_convert_i10_v3(bm_vert_no_get(mr, eve));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
else {
const MVert *mvert = mr->mvert;
for (int v = 0; v < mr->vert_len; v++, mvert++) {
data->packed_nor[v] = GPU_normal_convert_i10_s3(mvert->no);
}
}
return data;
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
static void extract_pos_nor_loop_bmesh(const MeshRenderData *mr, int l, BMLoop *loop, void *_data)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
copy_v3_v3(vert->pos, bm_vert_co_get(mr, loop->v));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert->nor = data->packed_nor[BM_elem_index_get(loop->v)];
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
BMFace *efa = loop->f;
vert->nor.w = BM_elem_flag_test(efa, BM_ELEM_HIDDEN) ? -1 : 0;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_pos_nor_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
const MPoly *mpoly,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
void *_data)
{
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
const MVert *mvert = &mr->mvert[mloop->v];
copy_v3_v3(vert->pos, mvert->co);
vert->nor = data->packed_nor[mloop->v];
/* Flag for paint mode overlay. */
Fix T75053: Paint Overlay Show Modified Wires and Edges The paint mask overlay showed the wires and edges of the final mesh. This change will only draw wires and edges that are mapped to the original mesh. This change enables mapping data in regular Mesh extraction. This can also be used for better drawing of the normal overlay. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7277
2020-03-30 11:20:29 +02:00
if (mpoly->flag & ME_HIDE || mvert->flag & ME_HIDE ||
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
((mr->extract_type == MR_EXTRACT_MAPPED) && (mr->v_origindex) &&
(mr->v_origindex[mloop->v] == ORIGINDEX_NONE))) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert->nor.w = -1;
Clean: style
2019-08-27 05:45:26 +02:00
}
else if (mvert->flag & SELECT) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert->nor.w = 1;
Clean: style
2019-08-27 05:45:26 +02:00
}
else {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert->nor.w = 0;
Clean: style
2019-08-27 05:45:26 +02:00
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_pos_nor_ledge_bmesh(const MeshRenderData *mr, int e, BMEdge *eed, void *_data)
{
int l = mr->loop_len + e * 2;
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
copy_v3_v3(vert[0].pos, bm_vert_co_get(mr, eed->v1));
copy_v3_v3(vert[1].pos, bm_vert_co_get(mr, eed->v2));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert[0].nor = data->packed_nor[BM_elem_index_get(eed->v1)];
vert[1].nor = data->packed_nor[BM_elem_index_get(eed->v2)];
}
static void extract_pos_nor_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *medge,
void *_data)
{
int l = mr->loop_len + e * 2;
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
copy_v3_v3(vert[0].pos, mr->mvert[medge->v1].co);
copy_v3_v3(vert[1].pos, mr->mvert[medge->v2].co);
vert[0].nor = data->packed_nor[medge->v1];
vert[1].nor = data->packed_nor[medge->v2];
}
static void extract_pos_nor_lvert_bmesh(const MeshRenderData *mr, int v, BMVert *eve, void *_data)
{
int l = mr->loop_len + mr->edge_loose_len * 2 + v;
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
copy_v3_v3(vert->pos, bm_vert_co_get(mr, eve));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
vert->nor = data->packed_nor[BM_elem_index_get(eve)];
}
static void extract_pos_nor_lvert_mesh(const MeshRenderData *mr,
int v,
const MVert *mvert,
void *_data)
{
int l = mr->loop_len + mr->edge_loose_len * 2 + v;
int v_idx = mr->lverts[v];
MeshExtract_PosNor_Data *data = _data;
PosNorLoop *vert = data->vbo_data + l;
copy_v3_v3(vert->pos, mvert->co);
vert->nor = data->packed_nor[v_idx];
}
static void extract_pos_nor_finish(const MeshRenderData *UNUSED(mr), void *UNUSED(vbo), void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_pos_nor = {
extract_pos_nor_init,
NULL,
NULL,
extract_pos_nor_loop_bmesh,
extract_pos_nor_loop_mesh,
extract_pos_nor_ledge_bmesh,
extract_pos_nor_ledge_mesh,
extract_pos_nor_lvert_bmesh,
extract_pos_nor_lvert_mesh,
extract_pos_nor_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
/* ---------------------------------------------------------------------- */
/** \name Extract HQ Loop Normal
* \{ */
typedef struct gpuHQNor {
short x, y, z, w;
} gpuHQNor;
static void *extract_lnor_hq_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "nor", GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
GPU_vertformat_alias_add(&format, "lnor");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
return vbo->data;
}
static void extract_lnor_hq_loop_bmesh(const MeshRenderData *mr, int l, BMLoop *loop, void *data)
{
if (mr->loop_normals) {
normal_float_to_short_v3(&((gpuHQNor *)data)[l].x, mr->loop_normals[l]);
}
else if (BM_elem_flag_test(loop->f, BM_ELEM_SMOOTH)) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
normal_float_to_short_v3(&((gpuHQNor *)data)[l].x, bm_vert_no_get(mr, loop->v));
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
else {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
normal_float_to_short_v3(&((gpuHQNor *)data)[l].x, bm_face_no_get(mr, loop->f));
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
}
static void extract_lnor_hq_loop_mesh(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *data)
{
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
gpuHQNor *lnor_data = &((gpuHQNor *)data)[l];
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
if (mr->loop_normals) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
normal_float_to_short_v3(&lnor_data->x, mr->loop_normals[l]);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
else if (mpoly->flag & ME_SMOOTH) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
copy_v3_v3_short(&lnor_data->x, mr->mvert[mloop->v].no);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
else {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
normal_float_to_short_v3(&lnor_data->x, mr->poly_normals[p]);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
Fix T75567: Paint Mode Wireframe Incorrect The loop normal VBO is used in two manners. In edit mode to draw the edge normals. And in paint mode to draw the wireframe. This commit checks which VBO is needed and build the correct one. This allows show the wireframe correct in paint mode, when the object is subdivided. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7419
2020-04-14 09:33:15 +02:00
/* Flag for paint mode overlay.
* Only use MR_EXTRACT_MAPPED in edit mode where it is used to display the edge-normals. In paint
* mode it will use the unmapped data to draw the wireframe. */
if (mpoly->flag & ME_HIDE ||
(mr->edit_bmesh && mr->extract_type == MR_EXTRACT_MAPPED && (mr->v_origindex) &&
mr->v_origindex[mloop->v] == ORIGINDEX_NONE)) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = -1;
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
else if (mpoly->flag & ME_FACE_SEL) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = 1;
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
else {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = 0;
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
}
static const MeshExtract extract_lnor_hq = {
extract_lnor_hq_init,
NULL,
NULL,
extract_lnor_hq_loop_bmesh,
extract_lnor_hq_loop_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
MR_DATA_LOOP_NOR,
true,
};
/** \} */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract Loop Normal
* \{ */
static void *extract_lnor_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
Fix T69051 Vertex Paint: Selection not show in vertex select mode.
2019-08-26 18:43:46 +02:00
GPU_vertformat_attr_add(&format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_vertformat_alias_add(&format, "lnor");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
return vbo->data;
}
static void extract_lnor_loop_bmesh(const MeshRenderData *mr, int l, BMLoop *loop, void *data)
{
if (mr->loop_normals) {
((GPUPackedNormal *)data)[l] = GPU_normal_convert_i10_v3(mr->loop_normals[l]);
}
else if (BM_elem_flag_test(loop->f, BM_ELEM_SMOOTH)) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
((GPUPackedNormal *)data)[l] = GPU_normal_convert_i10_v3(bm_vert_no_get(mr, loop->v));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
else {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
((GPUPackedNormal *)data)[l] = GPU_normal_convert_i10_v3(bm_face_no_get(mr, loop->f));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
BMFace *efa = loop->f;
((GPUPackedNormal *)data)[l].w = BM_elem_flag_test(efa, BM_ELEM_HIDDEN) ? -1 : 0;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_lnor_loop_mesh(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *data)
{
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
GPUPackedNormal *lnor_data = &((GPUPackedNormal *)data)[l];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
if (mr->loop_normals) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
*lnor_data = GPU_normal_convert_i10_v3(mr->loop_normals[l]);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
else if (mpoly->flag & ME_SMOOTH) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
*lnor_data = GPU_normal_convert_i10_s3(mr->mvert[mloop->v].no);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
else {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
*lnor_data = GPU_normal_convert_i10_v3(mr->poly_normals[p]);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
Fix T75567: Paint Mode Wireframe Incorrect The loop normal VBO is used in two manners. In edit mode to draw the edge normals. And in paint mode to draw the wireframe. This commit checks which VBO is needed and build the correct one. This allows show the wireframe correct in paint mode, when the object is subdivided. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D7419
2020-04-14 09:33:15 +02:00
/* Flag for paint mode overlay.
* Only use MR_EXTRACT_MAPPED in edit mode where it is used to display the edge-normals. In paint
* mode it will use the unmapped data to draw the wireframe. */
if (mpoly->flag & ME_HIDE ||
(mr->edit_bmesh && mr->extract_type == MR_EXTRACT_MAPPED && (mr->v_origindex) &&
mr->v_origindex[mloop->v] == ORIGINDEX_NONE)) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = -1;
Clean: style
2019-08-27 05:45:26 +02:00
}
else if (mpoly->flag & ME_FACE_SEL) {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = 1;
Clean: style
2019-08-27 05:45:26 +02:00
}
else {
Normal Overlay: Hide Normals Of Generated Loops The loop normals were always drawn. We used to only draw the normals if it was mapped to an original loop of the mesh. Due to recent changes we can not find the correct loop and decide if we need to draw them. Note still need to check the face dots normals. This is more complicated as facedot normals needs to be encoded in a different way
2020-03-30 14:03:28 +02:00
lnor_data->w = 0;
Clean: style
2019-08-27 05:45:26 +02:00
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_lnor = {
extract_lnor_init,
NULL,
NULL,
extract_lnor_loop_bmesh,
extract_lnor_loop_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
MR_DATA_LOOP_NOR,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
/** \name Extract UV layers
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
* \{ */
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
static void *extract_uv_init(const MeshRenderData *mr, void *buf)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
GPUVertFormat format = {0};
GPU_vertformat_deinterleave(&format);
CustomData *cd_ldata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->ldata : &mr->me->ldata;
uint32_t uv_layers = mr->cache->cd_used.uv;
Fix T68857 EditUV: Crash on Remesh modifier with 'Display in Edit Mode'
2019-10-08 18:35:57 +02:00
/* HACK to fix T68857 */
if (mr->extract_type == MR_EXTRACT_BMESH && mr->cache->cd_used.edit_uv == 1) {
int layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
if (layer != -1) {
uv_layers |= (1 << layer);
}
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
for (int i = 0; i < MAX_MTFACE; i++) {
if (uv_layers & (1 << i)) {
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
char attr_name[32], attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const char *layer_name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i);
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
GPU_vertformat_safe_attr_name(layer_name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* UV layer name. */
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(attr_name), "u%s", attr_safe_name);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
/* Auto layer name. */
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(attr_name), "a%s", attr_safe_name);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_vertformat_alias_add(&format, attr_name);
/* Active render layer name. */
if (i == CustomData_get_render_layer(cd_ldata, CD_MLOOPUV)) {
GPU_vertformat_alias_add(&format, "u");
}
/* Active display layer name. */
if (i == CustomData_get_active_layer(cd_ldata, CD_MLOOPUV)) {
GPU_vertformat_alias_add(&format, "au");
/* Alias to pos for edit uvs. */
GPU_vertformat_alias_add(&format, "pos");
}
/* Stencil mask uv layer name. */
if (i == CustomData_get_stencil_layer(cd_ldata, CD_MLOOPUV)) {
GPU_vertformat_alias_add(&format, "mu");
}
}
}
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
int v_len = mr->loop_len;
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. */
v_len = 1;
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, v_len);
float(*uv_data)[2] = (float(*)[2])vbo->data;
for (int i = 0; i < MAX_MTFACE; i++) {
if (uv_layers & (1 << i)) {
if (mr->extract_type == MR_EXTRACT_BMESH) {
int cd_ofs = CustomData_get_n_offset(cd_ldata, CD_MLOOPUV, i);
BMIter f_iter, l_iter;
BMFace *efa;
BMLoop *loop;
BM_ITER_MESH (efa, &f_iter, mr->bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (loop, &l_iter, efa, BM_LOOPS_OF_FACE) {
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_ofs);
memcpy(uv_data, luv->uv, sizeof(*uv_data));
uv_data++;
}
}
}
else {
MLoopUV *layer_data = CustomData_get_layer_n(cd_ldata, CD_MLOOPUV, i);
for (int l = 0; l < mr->loop_len; l++, uv_data++, layer_data++) {
memcpy(uv_data, layer_data->uv, sizeof(*uv_data));
}
}
}
}
return NULL;
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_uv = {
extract_uv_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
false,
};
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Tangent layers
* \{ */
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
static void extract_tan_ex(const MeshRenderData *mr, GPUVertBuf *vbo, const bool do_hq)
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
{
Fix T74019 Eevee High Quality Normals causing pitch black faces Was due to a mistake when removing previous code...
2020-02-20 00:13:48 +01:00
GPUVertCompType comp_type = do_hq ? GPU_COMP_I16 : GPU_COMP_I10;
GPUVertFetchMode fetch_mode = GPU_FETCH_INT_TO_FLOAT_UNIT;
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
GPUVertFormat format = {0};
GPU_vertformat_deinterleave(&format);
CustomData *cd_ldata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->ldata : &mr->me->ldata;
CustomData *cd_vdata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->vdata : &mr->me->vdata;
uint32_t tan_layers = mr->cache->cd_used.tan;
float(*orco)[3] = CustomData_get_layer(cd_vdata, CD_ORCO);
bool orco_allocated = false;
const bool use_orco_tan = mr->cache->cd_used.tan_orco != 0;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int tan_len = 0;
char tangent_names[MAX_MTFACE][MAX_CUSTOMDATA_LAYER_NAME];
for (int i = 0; i < MAX_MTFACE; i++) {
if (tan_layers & (1 << i)) {
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
char attr_name[32], attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const char *layer_name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i);
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
GPU_vertformat_safe_attr_name(layer_name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Tangent layer name. */
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(attr_name), "t%s", attr_safe_name);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
GPU_vertformat_attr_add(&format, attr_name, comp_type, 4, fetch_mode);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Active render layer name. */
if (i == CustomData_get_render_layer(cd_ldata, CD_MLOOPUV)) {
GPU_vertformat_alias_add(&format, "t");
}
/* Active display layer name. */
if (i == CustomData_get_active_layer(cd_ldata, CD_MLOOPUV)) {
GPU_vertformat_alias_add(&format, "at");
}
BLI_strncpy(tangent_names[tan_len++], layer_name, MAX_CUSTOMDATA_LAYER_NAME);
}
}
if (use_orco_tan && orco == NULL) {
/* If orco is not available compute it ourselves */
orco_allocated = true;
orco = MEM_mallocN(sizeof(*orco) * mr->vert_len, __func__);
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMesh *bm = mr->bm;
for (int v = 0; v < mr->vert_len; v++) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
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. */
copy_v3_v3(orco[v], eve->co);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
else {
const MVert *mvert = mr->mvert;
for (int v = 0; v < mr->vert_len; v++, mvert++) {
copy_v3_v3(orco[v], mvert->co);
}
}
BKE_mesh_orco_verts_transform(mr->me, orco, mr->vert_len, 0);
}
/* Start Fresh */
CustomData_free_layers(cd_ldata, CD_TANGENT, mr->loop_len);
if (tan_len != 0 || use_orco_tan) {
short tangent_mask = 0;
bool calc_active_tangent = false;
if (mr->extract_type == MR_EXTRACT_BMESH) {
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BKE_editmesh_loop_tangent_calc(mr->edit_bmesh,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
calc_active_tangent,
tangent_names,
tan_len,
mr->poly_normals,
mr->loop_normals,
orco,
cd_ldata,
mr->loop_len,
&tangent_mask);
}
else {
BKE_mesh_calc_loop_tangent_ex(mr->mvert,
mr->mpoly,
mr->poly_len,
mr->mloop,
mr->mlooptri,
mr->tri_len,
cd_ldata,
calc_active_tangent,
tangent_names,
tan_len,
mr->poly_normals,
mr->loop_normals,
orco,
cd_ldata,
mr->loop_len,
&tangent_mask);
}
}
if (use_orco_tan) {
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
char attr_name[32], attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const char *layer_name = CustomData_get_layer_name(cd_ldata, CD_TANGENT, 0);
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
GPU_vertformat_safe_attr_name(layer_name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(*attr_name), "t%s", attr_safe_name);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
GPU_vertformat_attr_add(&format, attr_name, comp_type, 4, fetch_mode);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_vertformat_alias_add(&format, "t");
GPU_vertformat_alias_add(&format, "at");
}
if (orco_allocated) {
MEM_SAFE_FREE(orco);
}
int v_len = mr->loop_len;
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. */
v_len = 1;
}
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, v_len);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
if (do_hq) {
short(*tan_data)[4] = (short(*)[4])vbo->data;
for (int i = 0; i < tan_len; i++) {
const char *name = tangent_names[i];
float(*layer_data)[4] = (float(*)[4])CustomData_get_layer_named(cd_ldata, CD_TANGENT, name);
for (int l = 0; l < mr->loop_len; l++) {
normal_float_to_short_v3(*tan_data, layer_data[l]);
(*tan_data)[3] = (layer_data[l][3] > 0.0f) ? SHRT_MAX : SHRT_MIN;
tan_data++;
}
}
if (use_orco_tan) {
float(*layer_data)[4] = (float(*)[4])CustomData_get_layer_n(cd_ldata, CD_TANGENT, 0);
for (int l = 0; l < mr->loop_len; l++) {
normal_float_to_short_v3(*tan_data, layer_data[l]);
(*tan_data)[3] = (layer_data[l][3] > 0.0f) ? SHRT_MAX : SHRT_MIN;
tan_data++;
}
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
else {
GPUPackedNormal *tan_data = (GPUPackedNormal *)vbo->data;
for (int i = 0; i < tan_len; i++) {
const char *name = tangent_names[i];
float(*layer_data)[4] = (float(*)[4])CustomData_get_layer_named(cd_ldata, CD_TANGENT, name);
for (int l = 0; l < mr->loop_len; l++) {
*tan_data = GPU_normal_convert_i10_v3(layer_data[l]);
tan_data->w = (layer_data[l][3] > 0.0f) ? 1 : -2;
tan_data++;
}
}
if (use_orco_tan) {
float(*layer_data)[4] = (float(*)[4])CustomData_get_layer_n(cd_ldata, CD_TANGENT, 0);
for (int l = 0; l < mr->loop_len; l++) {
*tan_data = GPU_normal_convert_i10_v3(layer_data[l]);
tan_data->w = (layer_data[l][3] > 0.0f) ? 1 : -2;
tan_data++;
}
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
CustomData_free_layers(cd_ldata, CD_TANGENT, mr->loop_len);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
static void *extract_tan_init(const MeshRenderData *mr, void *buf)
{
extract_tan_ex(mr, buf, false);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
return NULL;
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_tan = {
extract_tan_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR | MR_DATA_LOOPTRI,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
/* ---------------------------------------------------------------------- */
/** \name Extract HQ Tangent layers
* \{ */
static void *extract_tan_hq_init(const MeshRenderData *mr, void *buf)
{
extract_tan_ex(mr, buf, true);
return NULL;
}
static const MeshExtract extract_tan_hq = {
extract_tan_hq_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
MR_DATA_POLY_NOR | MR_DATA_TAN_LOOP_NOR | MR_DATA_LOOPTRI,
false,
};
/** \} */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract VCol
* \{ */
static void *extract_vcol_init(const MeshRenderData *mr, void *buf)
{
GPUVertFormat format = {0};
GPU_vertformat_deinterleave(&format);
CustomData *cd_ldata = &mr->me->ldata;
uint32_t vcol_layers = mr->cache->cd_used.vcol;
for (int i = 0; i < 8; i++) {
if (vcol_layers & (1 << i)) {
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
char attr_name[32], attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const char *layer_name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i);
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
GPU_vertformat_safe_attr_name(layer_name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(attr_name), "c%s", attr_safe_name);
DRW: Use USHORT for vertex color and upload them in linear color to the GPU This way we remove the need for the srgb boolean uniform and a lot of code complexity. However, mesh update is going to be a bit slower. I did not benchmark the performance impact. This also fix a typo in draw_cache_impl_particles.c and fix hair not using vertex color in workbench. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D6610
2020-01-17 16:05:19 +01:00
GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_U16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
if (i == CustomData_get_render_layer(cd_ldata, CD_MLOOPCOL)) {
GPU_vertformat_alias_add(&format, "c");
}
if (i == CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL)) {
GPU_vertformat_alias_add(&format, "ac");
}
/* Gather number of auto layers. */
/* We only do vcols that are not overridden by uvs */
if (CustomData_get_named_layer_index(cd_ldata, CD_MLOOPUV, layer_name) == -1) {
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
BLI_snprintf(attr_name, sizeof(attr_name), "a%s", attr_safe_name);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPU_vertformat_alias_add(&format, attr_name);
}
}
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
DRW: Use USHORT for vertex color and upload them in linear color to the GPU This way we remove the need for the srgb boolean uniform and a lot of code complexity. However, mesh update is going to be a bit slower. I did not benchmark the performance impact. This also fix a typo in draw_cache_impl_particles.c and fix hair not using vertex color in workbench. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D6610
2020-01-17 16:05:19 +01:00
typedef struct gpuMeshVcol {
ushort r, g, b, a;
} gpuMeshVcol;
gpuMeshVcol *vcol_data = (gpuMeshVcol *)vbo->data;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
for (int i = 0; i < 8; i++) {
if (vcol_layers & (1 << i)) {
DRW: Use USHORT for vertex color and upload them in linear color to the GPU This way we remove the need for the srgb boolean uniform and a lot of code complexity. However, mesh update is going to be a bit slower. I did not benchmark the performance impact. This also fix a typo in draw_cache_impl_particles.c and fix hair not using vertex color in workbench. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D6610
2020-01-17 16:05:19 +01:00
MLoopCol *mcol = (MLoopCol *)CustomData_get_layer_n(cd_ldata, CD_MLOOPCOL, i);
for (int l = 0; l < mr->loop_len; l++, mcol++, vcol_data++) {
vcol_data->r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol->r]);
vcol_data->g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol->g]);
vcol_data->b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol->b]);
vcol_data->a = unit_float_to_ushort_clamp(mcol->a * (1.0f / 255.0f));
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
return NULL;
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_vcol = {
extract_vcol_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
/** \} */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract Orco
* \{ */
typedef struct MeshExtract_Orco_Data {
float (*vbo_data)[4];
float (*orco)[3];
} MeshExtract_Orco_Data;
static void *extract_orco_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* FIXME(fclem): We use the last component as a way to differentiate from generic vertex
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
* attributes. This is a substantial waste of Vram and should be done another way.
Cleanup: spelling
2019-08-16 16:54:22 +02:00
* Unfortunately, at the time of writing, I did not found any other "non disruptive"
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
* alternative. */
GPU_vertformat_attr_add(&format, "orco", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
CustomData *cd_vdata = &mr->me->vdata;
MeshExtract_Orco_Data *data = MEM_mallocN(sizeof(*data), __func__);
data->vbo_data = (float(*)[4])vbo->data;
data->orco = CustomData_get_layer(cd_vdata, CD_ORCO);
/* Make sure orco layer was requested only if needed! */
BLI_assert(data->orco);
return data;
}
static void extract_orco_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
MeshExtract_Orco_Data *orco_data = (MeshExtract_Orco_Data *)data;
float *loop_orco = orco_data->vbo_data[l];
copy_v3_v3(loop_orco, orco_data->orco[BM_elem_index_get(loop->v)]);
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
loop_orco[3] = 0.0; /* Tag as not a generic attribute. */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_orco_loop_mesh(const MeshRenderData *UNUSED(mr),
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *UNUSED(mpoly),
void *data)
{
MeshExtract_Orco_Data *orco_data = (MeshExtract_Orco_Data *)data;
float *loop_orco = orco_data->vbo_data[l];
copy_v3_v3(loop_orco, orco_data->orco[mloop->v]);
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 07:59:34 +02:00
loop_orco[3] = 0.0; /* Tag as not a generic attribute. */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_orco_finish(const MeshRenderData *UNUSED(mr), void *UNUSED(buf), void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_orco = {
extract_orco_init,
NULL,
NULL,
extract_orco_loop_bmesh,
extract_orco_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_orco_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edge Factor
* Defines how much an edge is visible.
* \{ */
typedef struct MeshExtract_EdgeFac_Data {
uchar *vbo_data;
bool use_edge_render;
/* Number of loop per edge. */
uchar edge_loop_count[0];
} MeshExtract_EdgeFac_Data;
static float loop_edge_factor_get(const float f_no[3],
const float v_co[3],
const float v_no[3],
const float v_next_co[3])
{
float enor[3], evec[3];
sub_v3_v3v3(evec, v_next_co, v_co);
cross_v3_v3v3(enor, v_no, evec);
normalize_v3(enor);
float d = fabsf(dot_v3v3(enor, f_no));
/* Rescale to the slider range. */
d *= (1.0f / 0.065f);
CLAMP(d, 0.0f, 1.0f);
return d;
}
static void *extract_edge_fac_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "wd", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len + mr->loop_loose_len);
MeshExtract_EdgeFac_Data *data;
if (mr->extract_type == MR_EXTRACT_MESH) {
size_t edge_loop_count_size = sizeof(uint32_t) * mr->edge_len;
data = MEM_callocN(sizeof(*data) + edge_loop_count_size, __func__);
/* HACK(fclem) Detecting the need for edge render.
* We could have a flag in the mesh instead or check the modifier stack. */
const MEdge *medge = mr->medge;
for (int e = 0; e < mr->edge_len; e++, medge++) {
if ((medge->flag & ME_EDGERENDER) == 0) {
data->use_edge_render = true;
break;
}
}
}
else {
data = MEM_callocN(sizeof(*data), __func__);
/* HACK to bypass non-manifold check in mesh_edge_fac_finish(). */
data->use_edge_render = true;
}
data->vbo_data = vbo->data;
return data;
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
static void extract_edge_fac_loop_bmesh(const MeshRenderData *mr, int l, BMLoop *loop, void *_data)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
MeshExtract_EdgeFac_Data *data = (MeshExtract_EdgeFac_Data *)_data;
if (BM_edge_is_manifold(loop->e)) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
float ratio = loop_edge_factor_get(bm_face_no_get(mr, loop->f),
bm_vert_co_get(mr, loop->v),
bm_vert_no_get(mr, loop->v),
bm_vert_co_get(mr, loop->next->v));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
data->vbo_data[l] = ratio * 253 + 1;
}
else {
data->vbo_data[l] = 255;
}
}
static void extract_edge_fac_loop_mesh(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *_data)
{
MeshExtract_EdgeFac_Data *data = (MeshExtract_EdgeFac_Data *)_data;
if (data->use_edge_render) {
const MEdge *medge = &mr->medge[mloop->e];
data->vbo_data[l] = (medge->flag & ME_EDGERENDER) ? 255 : 0;
}
else {
/* Count loop per edge to detect non-manifold. */
if (data->edge_loop_count[mloop->e] < 3) {
data->edge_loop_count[mloop->e]++;
}
if (data->edge_loop_count[mloop->e] == 2) {
/* Manifold */
int loopend = mpoly->totloop + mpoly->loopstart - 1;
int other_loop = (l == loopend) ? mpoly->loopstart : (l + 1);
const MLoop *mloop_next = &mr->mloop[other_loop];
const MVert *v1 = &mr->mvert[mloop->v];
const MVert *v2 = &mr->mvert[mloop_next->v];
float vnor_f[3];
normal_short_to_float_v3(vnor_f, v1->no);
float ratio = loop_edge_factor_get(mr->poly_normals[p], v1->co, vnor_f, v2->co);
data->vbo_data[l] = ratio * 253 + 1;
}
else {
/* Non-manifold */
data->vbo_data[l] = 255;
}
}
}
static void extract_edge_fac_ledge_bmesh(const MeshRenderData *mr,
int e,
BMEdge *UNUSED(eed),
void *_data)
{
MeshExtract_EdgeFac_Data *data = (MeshExtract_EdgeFac_Data *)_data;
data->vbo_data[mr->loop_len + e * 2 + 0] = 255;
data->vbo_data[mr->loop_len + e * 2 + 1] = 255;
}
static void extract_edge_fac_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *UNUSED(edge),
void *_data)
{
MeshExtract_EdgeFac_Data *data = (MeshExtract_EdgeFac_Data *)_data;
data->vbo_data[mr->loop_len + e * 2 + 0] = 255;
data->vbo_data[mr->loop_len + e * 2 + 1] = 255;
}
static void extract_edge_fac_finish(const MeshRenderData *mr, void *buf, void *_data)
{
MeshExtract_EdgeFac_Data *data = (MeshExtract_EdgeFac_Data *)_data;
if (GPU_crappy_amd_driver()) {
GPUVertBuf *vbo = (GPUVertBuf *)buf;
/* Some AMD drivers strangely crash with VBOs with a one byte format.
* To workaround we reinit the vbo with another format and convert
* all bytes to floats. */
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "wd", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
}
/* We keep the data reference in data->vbo_data. */
vbo->data = NULL;
GPU_vertbuf_clear(vbo);
int buf_len = mr->loop_len + mr->loop_loose_len;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, buf_len);
float *fdata = (float *)vbo->data;
for (int l = 0; l < buf_len; l++, fdata++) {
*fdata = data->vbo_data[l] / 255.0f;
}
/* Free old byte data. */
MEM_freeN(data->vbo_data);
}
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edge_fac = {
extract_edge_fac_init,
NULL,
NULL,
extract_edge_fac_loop_bmesh,
extract_edge_fac_loop_mesh,
extract_edge_fac_ledge_bmesh,
extract_edge_fac_ledge_mesh,
NULL,
NULL,
extract_edge_fac_finish,
MR_DATA_POLY_NOR,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Vertex Weight
* \{ */
typedef struct MeshExtract_Weight_Data {
float *vbo_data;
const DRW_MeshWeightState *wstate;
const MDeformVert *dvert; /* For Mesh. */
int cd_ofs; /* For BMesh. */
} MeshExtract_Weight_Data;
static float evaluate_vertex_weight(const MDeformVert *dvert, const DRW_MeshWeightState *wstate)
{
/* Error state. */
if ((wstate->defgroup_active < 0) && (wstate->defgroup_len > 0)) {
return -2.0f;
}
else if (dvert == NULL) {
return (wstate->alert_mode != OB_DRAW_GROUPUSER_NONE) ? -1.0f : 0.0f;
}
float input = 0.0f;
if (wstate->flags & DRW_MESH_WEIGHT_STATE_MULTIPAINT) {
/* Multi-Paint feature */
Weight Paint: Implement a new Lock-Relative mode. This check box alters how weights are displayed and painted, similar to Multi Paint, but in a different way. Specifically, weights are presented as if all locked vertex groups were deleted, and the remaining deform groups normalized. The new feature is intended for use when balancing weights within a group of bones while all others are locked. Enabling the option presents weight as if the locked bones didn't exist, and their weight was proportionally redistributed to the editable bones. Conversely, the Multi-Paint feature allows balancing a group of bones as a whole against all unselected bones, while ignoring weight distribution within the selected group. This mode also allows temporarily viewing non-normalized weights as if they were normalized, without actually changing the values. Differential Revision: https://developer.blender.org/D3837
2018-10-07 17:25:51 +02:00
bool is_normalized = (wstate->flags & (DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE |
DRW_MESH_WEIGHT_STATE_LOCK_RELATIVE));
input = BKE_defvert_multipaint_collective_weight(dvert,
wstate->defgroup_len,
wstate->defgroup_sel,
wstate->defgroup_sel_count,
is_normalized);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* make it black if the selected groups have no weight on a vertex */
if (input == 0.0f) {
return -1.0f;
}
}
else {
/* default, non tricky behavior */
Cleanup: use 'BKE_' prefix for BKE_deform API calls - Use 'BKE_object_defgroup' prefix for object functions. - Rename 'defvert_verify_index' to 'defvert_ensure_index' since this adds the group if it isn't found.
2020-03-06 02:50:56 +01:00
input = BKE_defvert_find_weight(dvert, wstate->defgroup_active);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
if (input == 0.0f) {
switch (wstate->alert_mode) {
case OB_DRAW_GROUPUSER_ACTIVE:
return -1.0f;
break;
case OB_DRAW_GROUPUSER_ALL:
Cleanup: use 'BKE_' prefix for BKE_deform API calls - Use 'BKE_object_defgroup' prefix for object functions. - Rename 'defvert_verify_index' to 'defvert_ensure_index' since this adds the group if it isn't found.
2020-03-06 02:50:56 +01:00
if (BKE_defvert_is_weight_zero(dvert, wstate->defgroup_len)) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
return -1.0f;
}
break;
}
}
}
Weight Paint: Implement a new Lock-Relative mode. This check box alters how weights are displayed and painted, similar to Multi Paint, but in a different way. Specifically, weights are presented as if all locked vertex groups were deleted, and the remaining deform groups normalized. The new feature is intended for use when balancing weights within a group of bones while all others are locked. Enabling the option presents weight as if the locked bones didn't exist, and their weight was proportionally redistributed to the editable bones. Conversely, the Multi-Paint feature allows balancing a group of bones as a whole against all unselected bones, while ignoring weight distribution within the selected group. This mode also allows temporarily viewing non-normalized weights as if they were normalized, without actually changing the values. Differential Revision: https://developer.blender.org/D3837
2018-10-07 17:25:51 +02:00
/* Lock-Relative: display the fraction of current weight vs total unlocked weight. */
if (wstate->flags & DRW_MESH_WEIGHT_STATE_LOCK_RELATIVE) {
input = BKE_defvert_lock_relative_weight(
input, dvert, wstate->defgroup_len, wstate->defgroup_locked, wstate->defgroup_unlocked);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
CLAMP(input, 0.0f, 1.0f);
return input;
}
static void *extract_weights_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len + mr->loop_loose_len);
MeshExtract_Weight_Data *data = MEM_callocN(sizeof(*data), __func__);
data->vbo_data = (float *)vbo->data;
data->wstate = &mr->cache->weight_state;
if (data->wstate->defgroup_active == -1) {
/* Nothing to show. */
data->dvert = NULL;
data->cd_ofs = -1;
}
else if (mr->extract_type == MR_EXTRACT_BMESH) {
data->dvert = NULL;
data->cd_ofs = CustomData_get_offset(&mr->bm->vdata, CD_MDEFORMVERT);
}
else {
data->dvert = CustomData_get_layer(&mr->me->vdata, CD_MDEFORMVERT);
data->cd_ofs = -1;
}
return data;
}
static void extract_weights_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *_data)
{
MeshExtract_Weight_Data *data = (MeshExtract_Weight_Data *)_data;
const MDeformVert *dvert = (data->cd_ofs != -1) ? BM_ELEM_CD_GET_VOID_P(loop->v, data->cd_ofs) :
NULL;
data->vbo_data[l] = evaluate_vertex_weight(dvert, data->wstate);
}
static void extract_weights_loop_mesh(const MeshRenderData *UNUSED(mr),
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *UNUSED(mpoly),
void *_data)
{
MeshExtract_Weight_Data *data = (MeshExtract_Weight_Data *)_data;
const MDeformVert *dvert = data->dvert ? &data->dvert[mloop->v] : NULL;
data->vbo_data[l] = evaluate_vertex_weight(dvert, data->wstate);
}
static void extract_weights_finish(const MeshRenderData *UNUSED(mr), void *UNUSED(buf), void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_weights = {
extract_weights_init,
NULL,
NULL,
extract_weights_loop_bmesh,
extract_weights_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_weights_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit Mode Data / Flags
* \{ */
typedef struct EditLoopData {
uchar v_flag;
uchar e_flag;
uchar crease;
uchar bweight;
} EditLoopData;
static void mesh_render_data_face_flag(const MeshRenderData *mr,
BMFace *efa,
const int cd_ofs,
EditLoopData *eattr)
{
if (efa == mr->efa_act) {
eattr->v_flag |= VFLAG_FACE_ACTIVE;
}
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
eattr->v_flag |= VFLAG_FACE_SELECTED;
}
if (efa == mr->efa_act_uv) {
eattr->v_flag |= VFLAG_FACE_UV_ACTIVE;
}
if ((cd_ofs != -1) && uvedit_face_select_test_ex(mr->toolsettings, (BMFace *)efa, cd_ofs)) {
eattr->v_flag |= VFLAG_FACE_UV_SELECT;
}
#ifdef WITH_FREESTYLE
if (mr->freestyle_face_ofs != -1) {
const FreestyleFace *ffa = BM_ELEM_CD_GET_VOID_P(efa, mr->freestyle_face_ofs);
if (ffa->flag & FREESTYLE_FACE_MARK) {
eattr->v_flag |= VFLAG_FACE_FREESTYLE;
}
}
#endif
}
static void mesh_render_data_edge_flag(const MeshRenderData *mr, BMEdge *eed, EditLoopData *eattr)
{
const ToolSettings *ts = mr->toolsettings;
const bool is_vertex_select_mode = (ts != NULL) && (ts->selectmode & SCE_SELECT_VERTEX) != 0;
const bool is_face_only_select_mode = (ts != NULL) && (ts->selectmode == SCE_SELECT_FACE);
if (eed == mr->eed_act) {
eattr->e_flag |= VFLAG_EDGE_ACTIVE;
}
if (!is_vertex_select_mode && BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
eattr->e_flag |= VFLAG_EDGE_SELECTED;
}
if (is_vertex_select_mode && BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) &&
BM_elem_flag_test(eed->v2, BM_ELEM_SELECT)) {
eattr->e_flag |= VFLAG_EDGE_SELECTED;
eattr->e_flag |= VFLAG_VERT_SELECTED;
}
if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
eattr->e_flag |= VFLAG_EDGE_SEAM;
}
if (!BM_elem_flag_test(eed, BM_ELEM_SMOOTH)) {
eattr->e_flag |= VFLAG_EDGE_SHARP;
}
/* Use active edge color for active face edges because
* specular highlights make it hard to see T55456#510873.
*
* This isn't ideal since it can't be used when mixing edge/face modes
* but it's still better then not being able to see the active face. */
if (is_face_only_select_mode) {
if (mr->efa_act != NULL) {
if (BM_edge_in_face(eed, mr->efa_act)) {
eattr->e_flag |= VFLAG_EDGE_ACTIVE;
}
}
}
/* Use a byte for value range */
if (mr->crease_ofs != -1) {
float crease = BM_ELEM_CD_GET_FLOAT(eed, mr->crease_ofs);
if (crease > 0) {
eattr->crease = (uchar)(crease * 255.0f);
}
}
/* Use a byte for value range */
if (mr->bweight_ofs != -1) {
float bweight = BM_ELEM_CD_GET_FLOAT(eed, mr->bweight_ofs);
if (bweight > 0) {
eattr->bweight = (uchar)(bweight * 255.0f);
}
}
#ifdef WITH_FREESTYLE
if (mr->freestyle_edge_ofs != -1) {
const FreestyleEdge *fed = BM_ELEM_CD_GET_VOID_P(eed, mr->freestyle_edge_ofs);
if (fed->flag & FREESTYLE_EDGE_MARK) {
eattr->e_flag |= VFLAG_EDGE_FREESTYLE;
}
}
#endif
}
static void mesh_render_data_loop_flag(const MeshRenderData *mr,
BMLoop *loop,
const int cd_ofs,
EditLoopData *eattr)
{
if (cd_ofs == -1) {
return;
}
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_ofs);
if (luv != NULL && (luv->flag & MLOOPUV_PINNED)) {
eattr->v_flag |= VFLAG_VERT_UV_PINNED;
}
if (uvedit_uv_select_test_ex(mr->toolsettings, loop, cd_ofs)) {
eattr->v_flag |= VFLAG_VERT_UV_SELECT;
}
}
static void mesh_render_data_loop_edge_flag(const MeshRenderData *mr,
BMLoop *loop,
const int cd_ofs,
EditLoopData *eattr)
{
if (cd_ofs == -1) {
return;
}
if (uvedit_edge_select_test_ex(mr->toolsettings, loop, cd_ofs)) {
eattr->v_flag |= VFLAG_EDGE_UV_SELECT;
eattr->v_flag |= VFLAG_VERT_UV_SELECT;
}
}
static void mesh_render_data_vert_flag(const MeshRenderData *mr, BMVert *eve, EditLoopData *eattr)
{
if (eve == mr->eve_act) {
eattr->e_flag |= VFLAG_VERT_ACTIVE;
}
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
eattr->e_flag |= VFLAG_VERT_SELECTED;
}
}
static void *extract_edit_data_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* WARNING Adjust EditLoopData struct accordingly. */
GPU_vertformat_attr_add(&format, "data", GPU_COMP_U8, 4, GPU_FETCH_INT);
GPU_vertformat_alias_add(&format, "flag");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len + mr->loop_loose_len);
return vbo->data;
}
static void extract_edit_data_loop_bmesh(const MeshRenderData *mr,
int l,
BMLoop *loop,
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + l;
memset(data, 0x0, sizeof(*data));
mesh_render_data_face_flag(mr, loop->f, -1, data);
mesh_render_data_edge_flag(mr, loop->e, data);
mesh_render_data_vert_flag(mr, loop->v, data);
}
static void extract_edit_data_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int p,
const MPoly *UNUSED(mpoly),
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + l;
memset(data, 0x0, sizeof(*data));
BMFace *efa = bm_original_face_get(mr, p);
BMEdge *eed = bm_original_edge_get(mr, mloop->e);
BMVert *eve = bm_original_vert_get(mr, mloop->v);
if (efa) {
mesh_render_data_face_flag(mr, efa, -1, data);
}
if (eed) {
mesh_render_data_edge_flag(mr, eed, data);
}
if (eve) {
mesh_render_data_vert_flag(mr, eve, data);
}
}
static void extract_edit_data_ledge_bmesh(const MeshRenderData *mr,
int e,
BMEdge *eed,
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + mr->loop_len + e * 2;
memset(data, 0x0, sizeof(*data) * 2);
mesh_render_data_edge_flag(mr, eed, &data[0]);
data[1] = data[0];
mesh_render_data_vert_flag(mr, eed->v1, &data[0]);
mesh_render_data_vert_flag(mr, eed->v2, &data[1]);
}
static void extract_edit_data_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *edge,
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + mr->loop_len + e * 2;
memset(data, 0x0, sizeof(*data) * 2);
int e_idx = mr->ledges[e];
BMEdge *eed = bm_original_edge_get(mr, e_idx);
BMVert *eve1 = bm_original_vert_get(mr, edge->v1);
BMVert *eve2 = bm_original_vert_get(mr, edge->v2);
if (eed) {
mesh_render_data_edge_flag(mr, eed, &data[0]);
data[1] = data[0];
}
if (eve1) {
mesh_render_data_vert_flag(mr, eve1, &data[0]);
}
if (eve2) {
mesh_render_data_vert_flag(mr, eve2, &data[1]);
}
}
static void extract_edit_data_lvert_bmesh(const MeshRenderData *mr,
int v,
BMVert *eve,
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + mr->loop_len + mr->edge_loose_len * 2 + v;
memset(data, 0x0, sizeof(*data));
mesh_render_data_vert_flag(mr, eve, data);
}
static void extract_edit_data_lvert_mesh(const MeshRenderData *mr,
int v,
const MVert *UNUSED(mvert),
void *_data)
{
EditLoopData *data = (EditLoopData *)_data + mr->loop_len + mr->edge_loose_len * 2 + v;
memset(data, 0x0, sizeof(*data));
int v_idx = mr->lverts[v];
BMVert *eve = bm_original_vert_get(mr, v_idx);
if (eve) {
mesh_render_data_vert_flag(mr, eve, data);
}
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edit_data = {
extract_edit_data_init,
NULL,
NULL,
extract_edit_data_loop_bmesh,
extract_edit_data_loop_mesh,
extract_edit_data_ledge_bmesh,
extract_edit_data_ledge_mesh,
extract_edit_data_lvert_bmesh,
extract_edit_data_lvert_mesh,
NULL,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV Data / Flags
* \{ */
typedef struct MeshExtract_EditUVData_Data {
EditLoopData *vbo_data;
int cd_ofs;
} MeshExtract_EditUVData_Data;
static void *extract_edituv_data_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* WARNING Adjust EditLoopData struct accordingly. */
GPU_vertformat_attr_add(&format, "data", GPU_COMP_U8, 4, GPU_FETCH_INT);
GPU_vertformat_alias_add(&format, "flag");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
Fix T68954 UVEdit: Auto Smooth option conflicts with uvs display
2019-08-26 16:28:32 +02:00
CustomData *cd_ldata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->ldata : &mr->me->ldata;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
MeshExtract_EditUVData_Data *data = MEM_callocN(sizeof(*data), __func__);
data->vbo_data = (EditLoopData *)vbo->data;
data->cd_ofs = CustomData_get_offset(cd_ldata, CD_MLOOPUV);
return data;
}
static void extract_edituv_data_loop_bmesh(const MeshRenderData *mr,
int l,
BMLoop *loop,
void *_data)
{
MeshExtract_EditUVData_Data *data = (MeshExtract_EditUVData_Data *)_data;
EditLoopData *eldata = data->vbo_data + l;
memset(eldata, 0x0, sizeof(*eldata));
mesh_render_data_loop_flag(mr, loop, data->cd_ofs, eldata);
Fix T72119: UV/Image Editor theme face colors with no effect The `in int flag;` in `gpu_shader_2D_edituvs_faces_vert.glsl` don't have the values `FACE_UV_ACTIVE` and `FACE_UV_SELECT`. Add face flags then. Original patch is from @EitanSomething Differential revision: https://developer.blender.org/D6520
2020-01-08 13:21:25 +01:00
mesh_render_data_face_flag(mr, loop->f, data->cd_ofs, eldata);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mesh_render_data_loop_edge_flag(mr, loop, data->cd_ofs, eldata);
}
static void extract_edituv_data_loop_mesh(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *_data)
{
MeshExtract_EditUVData_Data *data = (MeshExtract_EditUVData_Data *)_data;
EditLoopData *eldata = data->vbo_data + l;
memset(eldata, 0x0, sizeof(*eldata));
BMFace *efa = bm_original_face_get(mr, p);
if (efa) {
BMEdge *eed = bm_original_edge_get(mr, mloop->e);
BMVert *eve = bm_original_vert_get(mr, mloop->v);
if (eed && eve) {
/* Loop on an edge endpoint. */
BMLoop *loop = BM_face_edge_share_loop(efa, eed);
mesh_render_data_loop_flag(mr, loop, data->cd_ofs, eldata);
mesh_render_data_loop_edge_flag(mr, loop, data->cd_ofs, eldata);
}
else {
if (eed == NULL) {
/* Find if the loop's vert is not part of an edit edge.
* For this, we check if the previous loop was on an edge. */
int loopend = mpoly->loopstart + mpoly->totloop - 1;
int l_prev = (l == mpoly->loopstart) ? loopend : (l - 1);
const MLoop *mloop_prev = &mr->mloop[l_prev];
eed = bm_original_edge_get(mr, mloop_prev->e);
}
if (eed) {
/* Mapped points on an edge between two edit verts. */
BMLoop *loop = BM_face_edge_share_loop(efa, eed);
mesh_render_data_loop_edge_flag(mr, loop, data->cd_ofs, eldata);
}
}
}
}
static void extract_edituv_data_finish(const MeshRenderData *UNUSED(mr),
void *UNUSED(buf),
void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_edituv_data = {
extract_edituv_data_init,
NULL,
NULL,
extract_edituv_data_loop_bmesh,
extract_edituv_data_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_edituv_data_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV area stretch
* \{ */
static void *extract_stretch_area_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
Fix T72236: UV Stretching Overlay The ratio for area stretching was packed into an unsigned int, but could contain negative numbers. This flipped the negative numbers to high positive numbers and rendered the wrong color in the stretching overlay. I can remember during {T63755} I had to flip the sign to get the correct result, but couldn't find out why that was needed. Now I know. Reviewed By: fclem, mano-wii Differential Revision: https://developer.blender.org/D6440
2019-12-18 16:10:01 +01:00
GPU_vertformat_attr_add(&format, "ratio", GPU_COMP_I16, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
return NULL;
}
BLI_INLINE float area_ratio_get(float area, float uvarea)
{
if (area >= FLT_EPSILON && uvarea >= FLT_EPSILON) {
/* Tag inversion by using the sign. */
return (area > uvarea) ? (uvarea / area) : -(area / uvarea);
}
return 0.0f;
}
BLI_INLINE float area_ratio_to_stretch(float ratio, float tot_ratio, float inv_tot_ratio)
{
ratio *= (ratio > 0.0f) ? tot_ratio : -inv_tot_ratio;
return (ratio > 1.0f) ? (1.0f / ratio) : ratio;
}
static void mesh_stretch_area_finish(const MeshRenderData *mr, void *buf, void *UNUSED(data))
{
Fix T63755: Area Stretching Overlay Support for UV Stretching overlay during multi object editing. The VBO now holds the ratios per fase. In the shader these ratios will be compared against the global ratios. The global rations are created from all selected objects. The current implementation does not fit well with the draw module. The plan is to move the drawing of other spaces towards the draw manager what leads to a better fit. Currently the details on this solution is unclear but this requirement will become an attentionpoint in the future design. Reviewed By: fclem Differential Revision: https://developer.blender.org/D5665
2019-09-03 13:42:11 +02:00
float tot_area = 0.0f, tot_uv_area = 0.0f;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
float *area_ratio = MEM_mallocN(sizeof(float) * mr->poly_len, __func__);
if (mr->extract_type == MR_EXTRACT_BMESH) {
CustomData *cd_ldata = &mr->bm->ldata;
int uv_ofs = CustomData_get_offset(cd_ldata, CD_MLOOPUV);
BMFace *efa;
BMIter f_iter;
int f;
BM_ITER_MESH_INDEX (efa, &f_iter, mr->bm, BM_FACES_OF_MESH, f) {
float area = BM_face_calc_area(efa);
float uvarea = BM_face_calc_area_uv(efa, uv_ofs);
Fix T63755: Area Stretching Overlay Support for UV Stretching overlay during multi object editing. The VBO now holds the ratios per fase. In the shader these ratios will be compared against the global ratios. The global rations are created from all selected objects. The current implementation does not fit well with the draw module. The plan is to move the drawing of other spaces towards the draw manager what leads to a better fit. Currently the details on this solution is unclear but this requirement will become an attentionpoint in the future design. Reviewed By: fclem Differential Revision: https://developer.blender.org/D5665
2019-09-03 13:42:11 +02:00
tot_area += area;
tot_uv_area += uvarea;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
area_ratio[f] = area_ratio_get(area, uvarea);
}
}
else if (mr->extract_type == MR_EXTRACT_MAPPED) {
const MLoopUV *uv_data = CustomData_get_layer(&mr->me->ldata, CD_MLOOPUV);
const MPoly *mpoly = mr->mpoly;
for (int p = 0; p < mr->poly_len; p++, mpoly++) {
float area = BKE_mesh_calc_poly_area(mpoly, &mr->mloop[mpoly->loopstart], mr->mvert);
float uvarea = BKE_mesh_calc_poly_uv_area(mpoly, uv_data);
Fix T63755: Area Stretching Overlay Support for UV Stretching overlay during multi object editing. The VBO now holds the ratios per fase. In the shader these ratios will be compared against the global ratios. The global rations are created from all selected objects. The current implementation does not fit well with the draw module. The plan is to move the drawing of other spaces towards the draw manager what leads to a better fit. Currently the details on this solution is unclear but this requirement will become an attentionpoint in the future design. Reviewed By: fclem Differential Revision: https://developer.blender.org/D5665
2019-09-03 13:42:11 +02:00
tot_area += area;
tot_uv_area += uvarea;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
area_ratio[p] = area_ratio_get(area, uvarea);
}
}
else {
/* Should not happen. */
BLI_assert(0);
}
Fix T63755: Area Stretching Overlay Support for UV Stretching overlay during multi object editing. The VBO now holds the ratios per fase. In the shader these ratios will be compared against the global ratios. The global rations are created from all selected objects. The current implementation does not fit well with the draw module. The plan is to move the drawing of other spaces towards the draw manager what leads to a better fit. Currently the details on this solution is unclear but this requirement will become an attentionpoint in the future design. Reviewed By: fclem Differential Revision: https://developer.blender.org/D5665
2019-09-03 13:42:11 +02:00
mr->cache->tot_area = tot_area;
mr->cache->tot_uv_area = tot_uv_area;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Convert in place to avoid an extra allocation */
uint16_t *poly_stretch = (uint16_t *)area_ratio;
for (int p = 0; p < mr->poly_len; p++) {
Fix T72236: UV Stretching Overlay The ratio for area stretching was packed into an unsigned int, but could contain negative numbers. This flipped the negative numbers to high positive numbers and rendered the wrong color in the stretching overlay. I can remember during {T63755} I had to flip the sign to get the correct result, but couldn't find out why that was needed. Now I know. Reviewed By: fclem, mano-wii Differential Revision: https://developer.blender.org/D6440
2019-12-18 16:10:01 +01:00
poly_stretch[p] = area_ratio[p] * SHRT_MAX;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
/* Copy face data for each loop. */
GPUVertBuf *vbo = buf;
uint16_t *loop_stretch = (uint16_t *)vbo->data;
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMFace *efa;
BMIter f_iter;
int f, l = 0;
BM_ITER_MESH_INDEX (efa, &f_iter, mr->bm, BM_FACES_OF_MESH, f) {
for (int i = 0; i < efa->len; i++, l++) {
loop_stretch[l] = poly_stretch[f];
}
}
}
else if (mr->extract_type == MR_EXTRACT_MAPPED) {
const MPoly *mpoly = mr->mpoly;
for (int p = 0, l = 0; p < mr->poly_len; p++, mpoly++) {
for (int i = 0; i < mpoly->totloop; i++, l++) {
loop_stretch[l] = poly_stretch[p];
}
}
}
else {
/* Should not happen. */
BLI_assert(0);
}
MEM_freeN(area_ratio);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_stretch_area = {
extract_stretch_area_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
mesh_stretch_area_finish,
0,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Edit UV angle stretch
* \{ */
typedef struct UVStretchAngle {
int16_t angle;
int16_t uv_angles[2];
} UVStretchAngle;
typedef struct MeshExtract_StretchAngle_Data {
UVStretchAngle *vbo_data;
MLoopUV *luv;
float auv[2][2], last_auv[2];
float av[2][3], last_av[3];
int cd_ofs;
} MeshExtract_StretchAngle_Data;
static void compute_normalize_edge_vectors(float auv[2][2],
float av[2][3],
const float uv[2],
const float uv_prev[2],
DrawManager: UV Stretching Calculating UV Stretching on large meshes showed garbage. The reason is that the calculation is not thread save. Temporarily disable threading for UV Stretching
2019-08-30 16:14:59 +02:00
const float co[3],
const float co_prev[3])
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
/* Move previous edge. */
copy_v2_v2(auv[0], auv[1]);
copy_v3_v3(av[0], av[1]);
/* 2d edge */
sub_v2_v2v2(auv[1], uv_prev, uv);
normalize_v2(auv[1]);
/* 3d edge */
sub_v3_v3v3(av[1], co_prev, co);
normalize_v3(av[1]);
}
static short v2_to_short_angle(float v[2])
{
return atan2f(v[1], v[0]) * (float)M_1_PI * SHRT_MAX;
}
static void edituv_get_stretch_angle(float auv[2][2], float av[2][3], UVStretchAngle *r_stretch)
{
/* Send uvs to the shader and let it compute the aspect corrected angle. */
r_stretch->uv_angles[0] = v2_to_short_angle(auv[0]);
r_stretch->uv_angles[1] = v2_to_short_angle(auv[1]);
/* Compute 3D angle here. */
r_stretch->angle = angle_normalized_v3v3(av[0], av[1]) * (float)M_1_PI * SHRT_MAX;
#if 0 /* here for reference, this is done in shader now. */
float uvang = angle_normalized_v2v2(auv0, auv1);
float ang = angle_normalized_v3v3(av0, av1);
float stretch = fabsf(uvang - ang) / (float)M_PI;
return 1.0f - pow2f(1.0f - stretch);
#endif
}
static void *extract_stretch_angle_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* WARNING Adjust UVStretchAngle struct accordingly. */
GPU_vertformat_attr_add(&format, "angle", GPU_COMP_I16, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
GPU_vertformat_attr_add(&format, "uv_angles", GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
MeshExtract_StretchAngle_Data *data = MEM_callocN(sizeof(*data), __func__);
data->vbo_data = (UVStretchAngle *)vbo->data;
/* Special iter nneded to save about half of the computing cost. */
if (mr->extract_type == MR_EXTRACT_BMESH) {
data->cd_ofs = CustomData_get_offset(&mr->bm->ldata, CD_MLOOPUV);
}
else if (mr->extract_type == MR_EXTRACT_MAPPED) {
data->luv = CustomData_get_layer(&mr->me->ldata, CD_MLOOPUV);
}
else {
BLI_assert(0);
}
return data;
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
static void extract_stretch_angle_loop_bmesh(const MeshRenderData *mr,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int l,
BMLoop *loop,
void *_data)
{
MeshExtract_StretchAngle_Data *data = (MeshExtract_StretchAngle_Data *)_data;
float(*auv)[2] = data->auv, *last_auv = data->last_auv;
float(*av)[3] = data->av, *last_av = data->last_av;
const MLoopUV *luv, *luv_next;
BMLoop *l_next = loop->next;
BMFace *efa = loop->f;
if (loop == efa->l_first) {
/* First loop in face. */
BMLoop *l_tmp = loop->prev;
BMLoop *l_next_tmp = loop;
luv = BM_ELEM_CD_GET_VOID_P(l_tmp, data->cd_ofs);
luv_next = BM_ELEM_CD_GET_VOID_P(l_next_tmp, data->cd_ofs);
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
compute_normalize_edge_vectors(auv,
av,
luv->uv,
luv_next->uv,
bm_vert_co_get(mr, l_tmp->v),
bm_vert_co_get(mr, l_next_tmp->v));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Save last edge. */
copy_v2_v2(last_auv, auv[1]);
copy_v3_v3(last_av, av[1]);
}
if (l_next == efa->l_first) {
/* Move previous edge. */
copy_v2_v2(auv[0], auv[1]);
copy_v3_v3(av[0], av[1]);
/* Copy already calculated last edge. */
copy_v2_v2(auv[1], last_auv);
copy_v3_v3(av[1], last_av);
}
else {
luv = BM_ELEM_CD_GET_VOID_P(loop, data->cd_ofs);
luv_next = BM_ELEM_CD_GET_VOID_P(l_next, data->cd_ofs);
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
compute_normalize_edge_vectors(auv,
av,
luv->uv,
luv_next->uv,
bm_vert_co_get(mr, loop->v),
bm_vert_co_get(mr, l_next->v));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
edituv_get_stretch_angle(auv, av, data->vbo_data + l);
}
static void extract_stretch_angle_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *UNUSED(mloop),
int UNUSED(p),
const MPoly *mpoly,
void *_data)
{
MeshExtract_StretchAngle_Data *data = (MeshExtract_StretchAngle_Data *)_data;
float(*auv)[2] = data->auv, *last_auv = data->last_auv;
float(*av)[3] = data->av, *last_av = data->last_av;
int l_next = l + 1, loopend = mpoly->loopstart + mpoly->totloop;
const MVert *v, *v_next;
if (l == mpoly->loopstart) {
/* First loop in face. */
int l_tmp = loopend - 1;
int l_next_tmp = mpoly->loopstart;
v = &mr->mvert[mr->mloop[l_tmp].v];
v_next = &mr->mvert[mr->mloop[l_next_tmp].v];
compute_normalize_edge_vectors(
auv, av, data->luv[l_tmp].uv, data->luv[l_next_tmp].uv, v->co, v_next->co);
/* Save last edge. */
copy_v2_v2(last_auv, auv[1]);
copy_v3_v3(last_av, av[1]);
}
if (l_next == loopend) {
l_next = mpoly->loopstart;
/* Move previous edge. */
copy_v2_v2(auv[0], auv[1]);
copy_v3_v3(av[0], av[1]);
/* Copy already calculated last edge. */
copy_v2_v2(auv[1], last_auv);
copy_v3_v3(av[1], last_av);
}
else {
v = &mr->mvert[mr->mloop[l].v];
v_next = &mr->mvert[mr->mloop[l_next].v];
compute_normalize_edge_vectors(
auv, av, data->luv[l].uv, data->luv[l_next].uv, v->co, v_next->co);
}
edituv_get_stretch_angle(auv, av, data->vbo_data + l);
}
static void extract_stretch_angle_finish(const MeshRenderData *UNUSED(mr),
void *UNUSED(buf),
void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_stretch_angle = {
extract_stretch_angle_init,
NULL,
NULL,
extract_stretch_angle_loop_bmesh,
extract_stretch_angle_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_stretch_angle_finish,
0,
DrawManager: UV Stretching Calculating UV Stretching on large meshes showed garbage. The reason is that the calculation is not thread save. Temporarily disable threading for UV Stretching
2019-08-30 16:14:59 +02:00
false,
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
Cleanup: spelling
2020-03-18 12:28:54 +01:00
/** \name Extract Edit Mesh Analysis Colors
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
* \{ */
static void *extract_mesh_analysis_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len);
return NULL;
}
static void axis_from_enum_v3(float v[3], const char axis)
{
zero_v3(v);
if (axis < 3) {
v[axis] = 1.0f;
}
else {
v[axis - 3] = -1.0f;
}
}
BLI_INLINE float overhang_remap(float fac, float min, float max, float minmax_irange)
{
if (fac < min) {
fac = 1.0f;
}
else if (fac > max) {
fac = -1.0f;
}
else {
fac = (fac - min) * minmax_irange;
fac = 1.0f - fac;
CLAMP(fac, 0.0f, 1.0f);
}
return fac;
}
static void statvis_calc_overhang(const MeshRenderData *mr, float *r_overhang)
{
const MeshStatVis *statvis = &mr->toolsettings->statvis;
const float min = statvis->overhang_min / (float)M_PI;
const float max = statvis->overhang_max / (float)M_PI;
const char axis = statvis->overhang_axis;
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *em = mr->edit_bmesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
BMIter iter;
BMesh *bm = em->bm;
BMFace *f;
float dir[3];
const float minmax_irange = 1.0f / (max - min);
BLI_assert(min <= max);
axis_from_enum_v3(dir, axis);
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
/* now convert into global space */
mul_transposed_mat3_m4_v3(mr->obmat, dir);
normalize_v3(dir);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
if (mr->extract_type == MR_EXTRACT_BMESH) {
int l = 0;
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
float fac = angle_normalized_v3v3(bm_face_no_get(mr, f), dir) / (float)M_PI;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
fac = overhang_remap(fac, min, max, minmax_irange);
for (int i = 0; i < f->len; i++, l++) {
r_overhang[l] = fac;
}
}
}
else {
const MPoly *mpoly = mr->mpoly;
for (int p = 0, l = 0; p < mr->poly_len; p++, mpoly++) {
float fac = angle_normalized_v3v3(mr->poly_normals[p], dir) / (float)M_PI;
fac = overhang_remap(fac, min, max, minmax_irange);
for (int i = 0; i < mpoly->totloop; i++, l++) {
r_overhang[l] = fac;
}
}
}
}
/* so we can use jitter values for face interpolation */
static void uv_from_jitter_v2(float uv[2])
{
uv[0] += 0.5f;
uv[1] += 0.5f;
if (uv[0] + uv[1] > 1.0f) {
uv[0] = 1.0f - uv[0];
uv[1] = 1.0f - uv[1];
}
Cleanup: replace CLAMP macros with functions
2020-03-04 01:31:51 +01:00
clamp_v2(uv, 0.0f, 1.0f);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
BLI_INLINE float thickness_remap(float fac, float min, float max, float minmax_irange)
{
/* important not '<=' */
if (fac < max) {
fac = (fac - min) * minmax_irange;
fac = 1.0f - fac;
CLAMP(fac, 0.0f, 1.0f);
}
else {
fac = -1.0f;
}
return fac;
}
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->poly_len);
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *em = mr->edit_bmesh;
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
const float scale = 1.0f / mat4_to_scale(mr->obmat);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const MeshStatVis *statvis = &mr->toolsettings->statvis;
const float min = statvis->thickness_min * scale;
const float max = statvis->thickness_max * scale;
const float minmax_irange = 1.0f / (max - min);
const int samples = statvis->thickness_samples;
float jit_ofs[32][2];
BLI_assert(samples <= 32);
BLI_assert(min <= max);
copy_vn_fl(face_dists, mr->poly_len, max);
BLI_jitter_init(jit_ofs, samples);
for (int j = 0; j < samples; j++) {
uv_from_jitter_v2(jit_ofs[j]);
}
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMesh *bm = em->bm;
BM_mesh_elem_index_ensure(bm, BM_FACE);
struct BMBVHTree *bmtree = BKE_bmbvh_new_from_editmesh(em, 0, NULL, false);
struct BMLoop *(*looptris)[3] = em->looptris;
for (int i = 0; i < mr->tri_len; i++) {
BMLoop **ltri = looptris[i];
const int index = BM_elem_index_get(ltri[0]->f);
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
const float *cos[3] = {
bm_vert_co_get(mr, ltri[0]->v),
bm_vert_co_get(mr, ltri[1]->v),
bm_vert_co_get(mr, ltri[2]->v),
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
float ray_co[3];
float ray_no[3];
normal_tri_v3(ray_no, cos[2], cos[1], cos[0]);
for (int j = 0; j < samples; j++) {
float dist = face_dists[index];
interp_v3_v3v3v3_uv(ray_co, cos[0], cos[1], cos[2], jit_ofs[j]);
madd_v3_v3fl(ray_co, ray_no, eps_offset);
BMFace *f_hit = BKE_bmbvh_ray_cast(bmtree, ray_co, ray_no, 0.0f, &dist, NULL, NULL);
if (f_hit && dist < face_dists[index]) {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
float angle_fac = fabsf(
dot_v3v3(bm_face_no_get(mr, ltri[0]->f), bm_face_no_get(mr, f_hit)));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
angle_fac = 1.0f - angle_fac;
angle_fac = angle_fac * angle_fac * angle_fac;
angle_fac = 1.0f - angle_fac;
dist /= angle_fac;
if (dist < face_dists[index]) {
face_dists[index] = dist;
}
}
}
}
BKE_bmbvh_free(bmtree);
BMIter iter;
BMFace *f;
int l = 0;
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
float fac = face_dists[BM_elem_index_get(f)];
fac = thickness_remap(fac, min, max, minmax_irange);
for (int i = 0; i < f->len; i++, l++) {
r_thickness[l] = fac;
}
}
}
else {
BVHTreeFromMesh treeData = {NULL};
BVHTree *tree = BKE_bvhtree_from_mesh_get(&treeData, mr->me, BVHTREE_FROM_LOOPTRI, 4);
const MLoopTri *mlooptri = mr->mlooptri;
for (int i = 0; i < mr->tri_len; i++, mlooptri++) {
const int index = mlooptri->poly;
const float *cos[3] = {mr->mvert[mr->mloop[mlooptri->tri[0]].v].co,
mr->mvert[mr->mloop[mlooptri->tri[1]].v].co,
mr->mvert[mr->mloop[mlooptri->tri[2]].v].co};
float ray_co[3];
float ray_no[3];
normal_tri_v3(ray_no, cos[2], cos[1], cos[0]);
for (int j = 0; j < samples; j++) {
interp_v3_v3v3v3_uv(ray_co, cos[0], cos[1], cos[2], jit_ofs[j]);
madd_v3_v3fl(ray_co, ray_no, eps_offset);
BVHTreeRayHit hit;
hit.index = -1;
hit.dist = face_dists[index];
if ((BLI_bvhtree_ray_cast(
tree, ray_co, ray_no, 0.0f, &hit, treeData.raycast_callback, &treeData) != -1) &&
hit.dist < face_dists[index]) {
float angle_fac = fabsf(dot_v3v3(mr->poly_normals[index], hit.no));
angle_fac = 1.0f - angle_fac;
angle_fac = angle_fac * angle_fac * angle_fac;
angle_fac = 1.0f - angle_fac;
hit.dist /= angle_fac;
if (hit.dist < face_dists[index]) {
face_dists[index] = hit.dist;
}
}
}
}
const MPoly *mpoly = mr->mpoly;
for (int p = 0, l = 0; p < mr->poly_len; p++, mpoly++) {
float fac = face_dists[p];
fac = thickness_remap(fac, min, max, minmax_irange);
for (int i = 0; i < mpoly->totloop; i++, l++) {
r_thickness[l] = fac;
}
}
}
}
struct BVHTree_OverlapData {
const Mesh *me;
const MLoopTri *mlooptri;
float epsilon;
};
static bool bvh_overlap_cb(void *userdata, int index_a, int index_b, int UNUSED(thread))
{
struct BVHTree_OverlapData *data = userdata;
const Mesh *me = data->me;
const MLoopTri *tri_a = &data->mlooptri[index_a];
const MLoopTri *tri_b = &data->mlooptri[index_b];
if (UNLIKELY(tri_a->poly == tri_b->poly)) {
return false;
}
const float *tri_a_co[3] = {me->mvert[me->mloop[tri_a->tri[0]].v].co,
me->mvert[me->mloop[tri_a->tri[1]].v].co,
me->mvert[me->mloop[tri_a->tri[2]].v].co};
const float *tri_b_co[3] = {me->mvert[me->mloop[tri_b->tri[0]].v].co,
me->mvert[me->mloop[tri_b->tri[1]].v].co,
me->mvert[me->mloop[tri_b->tri[2]].v].co};
float ix_pair[2][3];
int verts_shared = 0;
verts_shared = (ELEM(tri_a_co[0], UNPACK3(tri_b_co)) + ELEM(tri_a_co[1], UNPACK3(tri_b_co)) +
ELEM(tri_a_co[2], UNPACK3(tri_b_co)));
/* if 2 points are shared, bail out */
if (verts_shared >= 2) {
return false;
}
return (isect_tri_tri_epsilon_v3(
UNPACK3(tri_a_co), UNPACK3(tri_b_co), ix_pair[0], ix_pair[1], data->epsilon) &&
/* if we share a vertex, check the intersection isn't a 'point' */
((verts_shared == 0) || (len_squared_v3v3(ix_pair[0], ix_pair[1]) > data->epsilon)));
}
static void statvis_calc_intersect(const MeshRenderData *mr, float *r_intersect)
{
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *em = mr->edit_bmesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
for (int l = 0; l < mr->loop_len; l++) {
r_intersect[l] = -1.0f;
}
if (mr->extract_type == MR_EXTRACT_BMESH) {
uint overlap_len;
BMesh *bm = em->bm;
BM_mesh_elem_index_ensure(bm, BM_FACE);
struct BMBVHTree *bmtree = BKE_bmbvh_new_from_editmesh(em, 0, NULL, false);
BVHTreeOverlap *overlap = BKE_bmbvh_overlap(bmtree, bmtree, &overlap_len);
if (overlap) {
for (int i = 0; i < overlap_len; i++) {
BMFace *f_hit_pair[2] = {
em->looptris[overlap[i].indexA][0]->f,
em->looptris[overlap[i].indexB][0]->f,
};
for (int j = 0; j < 2; j++) {
BMFace *f_hit = f_hit_pair[j];
BMLoop *l_first = BM_FACE_FIRST_LOOP(f_hit);
int l = BM_elem_index_get(l_first);
for (int k = 0; k < f_hit->len; k++, l++) {
r_intersect[l] = 1.0f;
}
}
}
MEM_freeN(overlap);
}
BKE_bmbvh_free(bmtree);
}
else {
uint overlap_len;
BVHTreeFromMesh treeData = {NULL};
BVHTree *tree = BKE_bvhtree_from_mesh_get(&treeData, mr->me, BVHTREE_FROM_LOOPTRI, 4);
struct BVHTree_OverlapData data = {
.me = mr->me, .mlooptri = mr->mlooptri, .epsilon = BLI_bvhtree_get_epsilon(tree)};
BVHTreeOverlap *overlap = BLI_bvhtree_overlap(tree, tree, &overlap_len, bvh_overlap_cb, &data);
if (overlap) {
for (int i = 0; i < overlap_len; i++) {
const MPoly *f_hit_pair[2] = {
&mr->mpoly[mr->mlooptri[overlap[i].indexA].poly],
&mr->mpoly[mr->mlooptri[overlap[i].indexB].poly],
};
for (int j = 0; j < 2; j++) {
const MPoly *f_hit = f_hit_pair[j];
int l = f_hit->loopstart;
for (int k = 0; k < f_hit->totloop; k++, l++) {
r_intersect[l] = 1.0f;
}
}
}
MEM_freeN(overlap);
}
}
}
BLI_INLINE float distort_remap(float fac, float min, float UNUSED(max), float minmax_irange)
{
if (fac >= min) {
fac = (fac - min) * minmax_irange;
CLAMP(fac, 0.0f, 1.0f);
}
else {
/* fallback */
fac = -1.0f;
}
return fac;
}
static void statvis_calc_distort(const MeshRenderData *mr, float *r_distort)
{
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *em = mr->edit_bmesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const MeshStatVis *statvis = &mr->toolsettings->statvis;
const float min = statvis->distort_min;
const float max = statvis->distort_max;
const float minmax_irange = 1.0f / (max - min);
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMIter iter;
BMesh *bm = em->bm;
BMFace *f;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
if (mr->bm_vert_coords != NULL) {
BKE_editmesh_cache_ensure_poly_normals(em, mr->edit_data);
/* Most likely this is already valid, ensure just in case.
* Needed for #BM_loop_calc_face_normal_safe_vcos. */
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int l = 0;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
int p = 0;
BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, p) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
float fac = -1.0f;
if (f->len > 3) {
BMLoop *l_iter, *l_first;
fac = 0.0f;
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
const float *no_face;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
float no_corner[3];
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
if (mr->bm_vert_coords != NULL) {
no_face = mr->bm_poly_normals[p];
BM_loop_calc_face_normal_safe_vcos(l_iter, no_face, mr->bm_vert_coords, no_corner);
}
else {
no_face = f->no;
BM_loop_calc_face_normal_safe(l_iter, no_corner);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* simple way to detect (what is most likely) concave */
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
if (dot_v3v3(no_face, no_corner) < 0.0f) {
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
negate_v3(no_corner);
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
fac = max_ff(fac, angle_normalized_v3v3(no_face, no_corner));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
} while ((l_iter = l_iter->next) != l_first);
fac *= 2.0f;
}
fac = distort_remap(fac, min, max, minmax_irange);
for (int i = 0; i < f->len; i++, l++) {
r_distort[l] = fac;
}
}
}
else {
const MPoly *mpoly = mr->mpoly;
for (int p = 0, l = 0; p < mr->poly_len; p++, mpoly++) {
float fac = -1.0f;
if (mpoly->totloop > 3) {
float *f_no = mr->poly_normals[p];
fac = 0.0f;
for (int i = 1; i <= mpoly->totloop; i++) {
const MLoop *l_prev = &mr->mloop[mpoly->loopstart + (i - 1) % mpoly->totloop];
const MLoop *l_curr = &mr->mloop[mpoly->loopstart + (i + 0) % mpoly->totloop];
const MLoop *l_next = &mr->mloop[mpoly->loopstart + (i + 1) % mpoly->totloop];
float no_corner[3];
normal_tri_v3(no_corner,
mr->mvert[l_prev->v].co,
mr->mvert[l_curr->v].co,
mr->mvert[l_next->v].co);
/* simple way to detect (what is most likely) concave */
if (dot_v3v3(f_no, no_corner) < 0.0f) {
negate_v3(no_corner);
}
fac = max_ff(fac, angle_normalized_v3v3(f_no, no_corner));
}
fac *= 2.0f;
}
fac = distort_remap(fac, min, max, minmax_irange);
for (int i = 0; i < mpoly->totloop; i++, l++) {
r_distort[l] = fac;
}
}
}
}
BLI_INLINE float sharp_remap(float fac, float min, float UNUSED(max), float minmax_irange)
{
/* important not '>=' */
if (fac > min) {
fac = (fac - min) * minmax_irange;
CLAMP(fac, 0.0f, 1.0f);
}
else {
/* fallback */
fac = -1.0f;
}
return fac;
}
static void statvis_calc_sharp(const MeshRenderData *mr, float *r_sharp)
{
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMEditMesh *em = mr->edit_bmesh;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const MeshStatVis *statvis = &mr->toolsettings->statvis;
const float min = statvis->sharp_min;
const float max = statvis->sharp_max;
const float minmax_irange = 1.0f / (max - min);
/* Can we avoid this extra allocation? */
float *vert_angles = MEM_mallocN(sizeof(float) * mr->vert_len, __func__);
copy_vn_fl(vert_angles, mr->vert_len, -M_PI);
if (mr->extract_type == MR_EXTRACT_BMESH) {
BMIter iter, l_iter;
BMesh *bm = em->bm;
BMFace *efa;
BMEdge *e;
BMLoop *loop;
/* first assign float values to verts */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
float angle = BM_edge_calc_face_angle_signed(e);
float *col1 = &vert_angles[BM_elem_index_get(e->v1)];
float *col2 = &vert_angles[BM_elem_index_get(e->v2)];
*col1 = max_ff(*col1, angle);
*col2 = max_ff(*col2, angle);
}
/* Copy vert value to loops. */
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (loop, &l_iter, efa, BM_LOOPS_OF_FACE) {
int l = BM_elem_index_get(loop);
int v = BM_elem_index_get(loop->v);
r_sharp[l] = sharp_remap(vert_angles[v], min, max, minmax_irange);
}
}
}
else {
/* first assign float values to verts */
const MPoly *mpoly = mr->mpoly;
EdgeHash *eh = BLI_edgehash_new_ex(__func__, mr->edge_len);
for (int p = 0; p < mr->poly_len; p++, mpoly++) {
for (int i = 0; i < mpoly->totloop; i++) {
const MLoop *l_curr = &mr->mloop[mpoly->loopstart + (i + 0) % mpoly->totloop];
const MLoop *l_next = &mr->mloop[mpoly->loopstart + (i + 1) % mpoly->totloop];
const MVert *v_curr = &mr->mvert[l_curr->v];
const MVert *v_next = &mr->mvert[l_next->v];
float angle;
void **pval;
bool value_is_init = BLI_edgehash_ensure_p(eh, l_curr->v, l_next->v, &pval);
if (!value_is_init) {
*pval = mr->poly_normals[p];
/* non-manifold edge, yet... */
continue;
}
else if (*pval != NULL) {
const float *f1_no = mr->poly_normals[p];
const float *f2_no = *pval;
angle = angle_normalized_v3v3(f1_no, f2_no);
angle = is_edge_convex_v3(v_curr->co, v_next->co, f1_no, f2_no) ? angle : -angle;
/* Tag as manifold. */
*pval = NULL;
}
else {
/* non-manifold edge */
angle = DEG2RADF(90.0f);
}
float *col1 = &vert_angles[l_curr->v];
float *col2 = &vert_angles[l_next->v];
*col1 = max_ff(*col1, angle);
*col2 = max_ff(*col2, angle);
}
}
/* Remaining non manifold edges. */
EdgeHashIterator *ehi = BLI_edgehashIterator_new(eh);
for (; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
if (BLI_edgehashIterator_getValue(ehi) != NULL) {
uint v1, v2;
const float angle = DEG2RADF(90.0f);
BLI_edgehashIterator_getKey(ehi, &v1, &v2);
float *col1 = &vert_angles[v1];
float *col2 = &vert_angles[v2];
*col1 = max_ff(*col1, angle);
*col2 = max_ff(*col2, angle);
}
}
BLI_edgehashIterator_free(ehi);
BLI_edgehash_free(eh, NULL);
const MLoop *mloop = mr->mloop;
for (int l = 0; l < mr->loop_len; l++, mloop++) {
r_sharp[l] = sharp_remap(vert_angles[mloop->v], min, max, minmax_irange);
}
}
MEM_freeN(vert_angles);
}
static void extract_mesh_analysis_finish(const MeshRenderData *mr, void *buf, void *UNUSED(data))
{
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BLI_assert(mr->edit_bmesh);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPUVertBuf *vbo = buf;
float *l_weight = (float *)vbo->data;
switch (mr->toolsettings->statvis.type) {
case SCE_STATVIS_OVERHANG:
statvis_calc_overhang(mr, l_weight);
break;
case SCE_STATVIS_THICKNESS:
statvis_calc_thickness(mr, l_weight);
break;
case SCE_STATVIS_INTERSECT:
statvis_calc_intersect(mr, l_weight);
break;
case SCE_STATVIS_DISTORT:
statvis_calc_distort(mr, l_weight);
break;
case SCE_STATVIS_SHARP:
statvis_calc_sharp(mr, l_weight);
break;
}
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_mesh_analysis = {
extract_mesh_analysis_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
extract_mesh_analysis_finish,
/* This is not needed for all vis type.
* Maybe split into different extract. */
MR_DATA_POLY_NOR | MR_DATA_LOOPTRI,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Facedots positions
* \{ */
static void *extract_fdots_pos_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->poly_len);
if (!mr->use_subsurf_fdots) {
/* Clear so we can accumulate on it. */
memset(vbo->data, 0x0, mr->poly_len * vbo->format.stride);
}
return vbo->data;
}
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
static void extract_fdots_pos_loop_bmesh(const MeshRenderData *mr,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
int UNUSED(l),
BMLoop *loop,
void *data)
{
float(*center)[3] = (float(*)[3])data;
float w = 1.0f / (float)loop->f->len;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
madd_v3_v3fl(center[BM_elem_index_get(loop->f)], bm_vert_co_get(mr, loop->v), w);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_fdots_pos_loop_mesh(const MeshRenderData *mr,
int UNUSED(l),
const MLoop *mloop,
int p,
const MPoly *mpoly,
void *data)
{
float(*center)[3] = (float(*)[3])data;
const MVert *mvert = &mr->mvert[mloop->v];
if (mr->use_subsurf_fdots) {
if (mvert->flag & ME_VERT_FACEDOT) {
copy_v3_v3(center[p], mvert->co);
}
}
else {
float w = 1.0f / (float)mpoly->totloop;
madd_v3_v3fl(center[p], mvert->co, w);
}
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdots_pos = {
extract_fdots_pos_init,
NULL,
NULL,
extract_fdots_pos_loop_bmesh,
extract_fdots_pos_loop_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Facedots Normal and edit flag
* \{ */
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
#define NOR_AND_FLAG_DEFAULT 0
#define NOR_AND_FLAG_SELECT 1
#define NOR_AND_FLAG_ACTIVE -1
#define NOR_AND_FLAG_HIDDEN -2
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
static void *extract_fdots_nor_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->poly_len);
return NULL;
}
static void extract_fdots_nor_finish(const MeshRenderData *mr, void *buf, void *UNUSED(data))
{
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
static float invalid_normal[3] = {0.0f, 0.0f, 0.0f};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
GPUVertBuf *vbo = buf;
GPUPackedNormal *nor = (GPUPackedNormal *)vbo->data;
BMFace *efa;
/* Quicker than doing it for each loop. */
if (mr->extract_type == MR_EXTRACT_BMESH) {
for (int f = 0; f < mr->poly_len; f++) {
efa = BM_face_at_index(mr->bm, f);
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
const bool is_face_hidden = BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
if (is_face_hidden || (mr->extract_type == MR_EXTRACT_MAPPED && mr->p_origindex &&
mr->p_origindex[f] == ORIGINDEX_NONE)) {
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
nor[f] = GPU_normal_convert_i10_v3(invalid_normal);
nor[f].w = NOR_AND_FLAG_HIDDEN;
}
else {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
nor[f] = GPU_normal_convert_i10_v3(bm_face_no_get(mr, efa));
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
/* Select / Active Flag. */
nor[f].w = (BM_elem_flag_test(efa, BM_ELEM_SELECT) ?
((efa == mr->efa_act) ? NOR_AND_FLAG_ACTIVE : NOR_AND_FLAG_SELECT) :
NOR_AND_FLAG_DEFAULT);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
else {
for (int f = 0; f < mr->poly_len; f++) {
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
efa = bm_original_face_get(mr, f);
NormalOverlay: Center Dot Normal Drawing With Modifiers When using generative modifiers too many center dots were rendered in the normal overlay. This patch only renders the normals of original center dots. Known issue: decoding the `norAndFlag` has issues on Intel GPU.
2020-03-30 14:39:16 +02:00
const bool is_face_hidden = efa && BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
Fix T75244: Screw Modifier Crash Draw batch extraction wrongly assumed that when mapped extraction happened that all original data could be found. This is not the case as mapped extraction is also enabled when part of the data is present. This fix does additional nullptr checks.
2020-03-31 16:05:19 +02:00
if (is_face_hidden || (mr->extract_type == MR_EXTRACT_MAPPED && mr->p_origindex &&
mr->p_origindex[f] == ORIGINDEX_NONE)) {
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
nor[f] = GPU_normal_convert_i10_v3(invalid_normal);
nor[f].w = NOR_AND_FLAG_HIDDEN;
}
else {
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
nor[f] = GPU_normal_convert_i10_v3(bm_face_no_get(mr, efa));
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Select / Active Flag. */
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
nor[f].w = (BM_elem_flag_test(efa, BM_ELEM_SELECT) ?
((efa == mr->efa_act) ? NOR_AND_FLAG_ACTIVE : NOR_AND_FLAG_SELECT) :
NOR_AND_FLAG_DEFAULT);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
}
}
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdots_nor = {
extract_fdots_nor_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
extract_fdots_nor_finish,
MR_DATA_POLY_NOR,
false,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Facedots Normal and edit flag
* \{ */
typedef struct MeshExtract_FdotUV_Data {
float (*vbo_data)[2];
MLoopUV *uv_data;
Fix T71194: UV Face centers wrong location with sub-surface mesh
2019-11-08 12:16:25 +01:00
int cd_ofs;
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
} MeshExtract_FdotUV_Data;
static void *extract_fdots_uv_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
GPU_vertformat_alias_add(&format, "au");
GPU_vertformat_alias_add(&format, "pos");
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->poly_len);
if (!mr->use_subsurf_fdots) {
/* Clear so we can accumulate on it. */
memset(vbo->data, 0x0, mr->poly_len * vbo->format.stride);
}
MeshExtract_FdotUV_Data *data = MEM_callocN(sizeof(*data), __func__);
data->vbo_data = (float(*)[2])vbo->data;
Fix T71194: UV Face centers wrong location with sub-surface mesh
2019-11-08 12:16:25 +01:00
if (mr->extract_type == MR_EXTRACT_BMESH) {
data->cd_ofs = CustomData_get_offset(&mr->bm->ldata, CD_MLOOPUV);
}
else {
data->uv_data = CustomData_get_layer(&mr->me->ldata, CD_MLOOPUV);
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
return data;
}
static void extract_fdots_uv_loop_bmesh(const MeshRenderData *UNUSED(mr),
Fix T71194: UV Face centers wrong location with sub-surface mesh
2019-11-08 12:16:25 +01:00
int UNUSED(l),
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
BMLoop *loop,
void *_data)
{
MeshExtract_FdotUV_Data *data = (MeshExtract_FdotUV_Data *)_data;
float w = 1.0f / (float)loop->f->len;
Fix T71194: UV Face centers wrong location with sub-surface mesh
2019-11-08 12:16:25 +01:00
const MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, data->cd_ofs);
madd_v2_v2fl(data->vbo_data[BM_elem_index_get(loop->f)], luv->uv, w);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_fdots_uv_loop_mesh(
const MeshRenderData *mr, int l, const MLoop *mloop, int p, const MPoly *mpoly, void *_data)
{
MeshExtract_FdotUV_Data *data = (MeshExtract_FdotUV_Data *)_data;
if (mr->use_subsurf_fdots) {
const MVert *mvert = &mr->mvert[mloop->v];
if (mvert->flag & ME_VERT_FACEDOT) {
copy_v2_v2(data->vbo_data[p], data->uv_data[l].uv);
}
}
else {
float w = 1.0f / (float)mpoly->totloop;
madd_v2_v2fl(data->vbo_data[p], data->uv_data[l].uv, w);
}
}
static void extract_fdots_uv_finish(const MeshRenderData *UNUSED(mr),
void *UNUSED(buf),
void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdots_uv = {
extract_fdots_uv_init,
NULL,
NULL,
extract_fdots_uv_loop_bmesh,
extract_fdots_uv_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_fdots_uv_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Facedots Edit UV flag
* \{ */
typedef struct MeshExtract_EditUVFdotData_Data {
EditLoopData *vbo_data;
int cd_ofs;
} MeshExtract_EditUVFdotData_Data;
static void *extract_fdots_edituv_data_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "flag", GPU_COMP_U8, 4, GPU_FETCH_INT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->poly_len);
MeshExtract_EditUVFdotData_Data *data = MEM_callocN(sizeof(*data), __func__);
data->vbo_data = (EditLoopData *)vbo->data;
data->cd_ofs = CustomData_get_offset(&mr->bm->ldata, CD_MLOOPUV);
return data;
}
static void extract_fdots_edituv_data_loop_bmesh(const MeshRenderData *mr,
int UNUSED(l),
BMLoop *loop,
void *_data)
{
MeshExtract_EditUVFdotData_Data *data = (MeshExtract_EditUVFdotData_Data *)_data;
EditLoopData *eldata = data->vbo_data + BM_elem_index_get(loop->f);
memset(eldata, 0x0, sizeof(*eldata));
mesh_render_data_face_flag(mr, loop->f, data->cd_ofs, eldata);
}
static void extract_fdots_edituv_data_loop_mesh(const MeshRenderData *mr,
int UNUSED(l),
const MLoop *UNUSED(mloop),
int p,
const MPoly *UNUSED(mpoly),
void *_data)
{
MeshExtract_EditUVFdotData_Data *data = (MeshExtract_EditUVFdotData_Data *)_data;
EditLoopData *eldata = data->vbo_data + p;
memset(eldata, 0x0, sizeof(*eldata));
BMFace *efa = bm_original_face_get(mr, p);
if (efa) {
mesh_render_data_face_flag(mr, efa, data->cd_ofs, eldata);
}
}
static void extract_fdots_edituv_data_finish(const MeshRenderData *UNUSED(mr),
void *UNUSED(buf),
void *data)
{
MEM_freeN(data);
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdots_edituv_data = {
extract_fdots_edituv_data_init,
NULL,
NULL,
extract_fdots_edituv_data_loop_bmesh,
extract_fdots_edituv_data_loop_mesh,
NULL,
NULL,
NULL,
NULL,
extract_fdots_edituv_data_finish,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
Fix T68380 Skin modifier root not displayed
2019-10-15 01:49:53 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract Skin Modifier Roots
* \{ */
typedef struct SkinRootData {
float size;
float local_pos[3];
} SkinRootData;
static void *extract_skin_roots_init(const MeshRenderData *mr, void *buf)
{
/* Exclusively for edit mode. */
BLI_assert(mr->bm);
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
GPU_vertformat_attr_add(&format, "size", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
GPU_vertformat_attr_add(&format, "local_pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->bm->totvert);
SkinRootData *vbo_data = (SkinRootData *)vbo->data;
int root_len = 0;
int cd_ofs = CustomData_get_offset(&mr->bm->vdata, CD_MVERT_SKIN);
BMIter iter;
BMVert *eve;
BM_ITER_MESH (eve, &iter, mr->bm, BM_VERTS_OF_MESH) {
const MVertSkin *vs = BM_ELEM_CD_GET_VOID_P(eve, cd_ofs);
if (vs->flag & MVERT_SKIN_ROOT) {
vbo_data->size = (vs->radius[0] + vs->radius[1]) * 0.5f;
Mesh: skip conversion from edit-mesh to mesh in edit-mode This resolves a performance regression in 2.8x where every edit-mode update performed an edit-mesh to mesh conversion. Now the conversion will be lazily initialized if/when it's required. New BKE_mesh_wrapper_* functions abstract over mesh data access. Currently only edit-mesh and regular meshes are supported. In the future sub-surface meshes may be supported too.
2020-05-25 12:16:42 +02:00
copy_v3_v3(vbo_data->local_pos, bm_vert_co_get(mr, eve));
Fix T68380 Skin modifier root not displayed
2019-10-15 01:49:53 +02:00
vbo_data++;
root_len++;
}
}
/* It's really unlikely that all verts will be roots. Resize to avoid loosing VRAM. */
GPU_vertbuf_data_len_set(vbo, root_len);
return NULL;
}
static const MeshExtract extract_skin_roots = {
extract_skin_roots_init,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
false,
};
/** \} */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* ---------------------------------------------------------------------- */
/** \name Extract Selection Index
* \{ */
static void *extract_select_idx_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* TODO rename "color" to something more descriptive. */
GPU_vertformat_attr_add(&format, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->loop_len + mr->loop_loose_len);
return vbo->data;
}
Cleanup: spelling
2019-08-17 20:11:50 +02:00
/* TODO Use glVertexID to get loop index and use the data structure on the CPU to retrieve the
Fix T73518: Normal Overlay This change will not render the normals for faces that are hidden. Before we had instance drawing the hidden faces were registered in the index buffer. During the overlay refactoring the rendering was migrated to instance rendering. Instance rendering does not use the index buffer so the data was ignored. This patch stored the normal visibility in the .w part of the normal or for face normals it will set the normal to zero. The shader looks at this and renders the normals fully transparent when detected. Reviewed By: Clément Foucault Differential Revision: https://developer.blender.org/D6798
2020-02-10 15:29:16 +01:00
* select element associated with this loop ID. This would remove the need for this separate
* index VBOs. We could upload the p/e/v_origindex as a buffer texture and sample it inside the
* shader to output original index. */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
static void extract_poly_idx_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
((uint32_t *)data)[l] = BM_elem_index_get(loop->f);
}
static void extract_edge_idx_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
((uint32_t *)data)[l] = BM_elem_index_get(loop->e);
}
static void extract_vert_idx_loop_bmesh(const MeshRenderData *UNUSED(mr),
int l,
BMLoop *loop,
void *data)
{
((uint32_t *)data)[l] = BM_elem_index_get(loop->v);
}
static void extract_edge_idx_ledge_bmesh(const MeshRenderData *mr, int e, BMEdge *eed, void *data)
{
((uint32_t *)data)[mr->loop_len + e * 2 + 0] = BM_elem_index_get(eed);
((uint32_t *)data)[mr->loop_len + e * 2 + 1] = BM_elem_index_get(eed);
}
static void extract_vert_idx_ledge_bmesh(const MeshRenderData *mr, int e, BMEdge *eed, void *data)
{
((uint32_t *)data)[mr->loop_len + e * 2 + 0] = BM_elem_index_get(eed->v1);
((uint32_t *)data)[mr->loop_len + e * 2 + 1] = BM_elem_index_get(eed->v2);
}
static void extract_vert_idx_lvert_bmesh(const MeshRenderData *mr, int v, BMVert *eve, void *data)
{
((uint32_t *)data)[mr->loop_len + mr->edge_loose_len * 2 + v] = BM_elem_index_get(eve);
}
static void extract_poly_idx_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *UNUSED(mloop),
int p,
const MPoly *UNUSED(mpoly),
void *data)
{
((uint32_t *)data)[l] = (mr->p_origindex) ? mr->p_origindex[p] : p;
}
static void extract_edge_idx_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *UNUSED(mpoly),
void *data)
{
((uint32_t *)data)[l] = (mr->e_origindex) ? mr->e_origindex[mloop->e] : mloop->e;
}
static void extract_vert_idx_loop_mesh(const MeshRenderData *mr,
int l,
const MLoop *mloop,
int UNUSED(p),
const MPoly *UNUSED(mpoly),
void *data)
{
((uint32_t *)data)[l] = (mr->v_origindex) ? mr->v_origindex[mloop->v] : mloop->v;
}
static void extract_edge_idx_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *UNUSED(medge),
void *data)
{
int e_idx = mr->ledges[e];
int e_orig = (mr->e_origindex) ? mr->e_origindex[e_idx] : e_idx;
((uint32_t *)data)[mr->loop_len + e * 2 + 0] = e_orig;
((uint32_t *)data)[mr->loop_len + e * 2 + 1] = e_orig;
}
static void extract_vert_idx_ledge_mesh(const MeshRenderData *mr,
int e,
const MEdge *medge,
void *data)
{
int v1_orig = (mr->v_origindex) ? mr->v_origindex[medge->v1] : medge->v1;
int v2_orig = (mr->v_origindex) ? mr->v_origindex[medge->v2] : medge->v2;
((uint32_t *)data)[mr->loop_len + e * 2 + 0] = v1_orig;
((uint32_t *)data)[mr->loop_len + e * 2 + 1] = v2_orig;
}
static void extract_vert_idx_lvert_mesh(const MeshRenderData *mr,
int v,
const MVert *UNUSED(mvert),
void *data)
{
int v_idx = mr->lverts[v];
int v_orig = (mr->v_origindex) ? mr->v_origindex[v_idx] : v_idx;
((uint32_t *)data)[mr->loop_len + mr->edge_loose_len * 2 + v] = v_orig;
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_poly_idx = {
extract_select_idx_init,
NULL,
NULL,
extract_poly_idx_loop_bmesh,
extract_poly_idx_loop_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
true,
};
static const MeshExtract extract_edge_idx = {
extract_select_idx_init,
NULL,
NULL,
extract_edge_idx_loop_bmesh,
extract_edge_idx_loop_mesh,
extract_edge_idx_ledge_bmesh,
extract_edge_idx_ledge_mesh,
NULL,
NULL,
NULL,
0,
true,
};
static const MeshExtract extract_vert_idx = {
extract_select_idx_init,
NULL,
NULL,
extract_vert_idx_loop_bmesh,
extract_vert_idx_loop_mesh,
extract_vert_idx_ledge_bmesh,
extract_vert_idx_ledge_mesh,
extract_vert_idx_lvert_bmesh,
extract_vert_idx_lvert_mesh,
NULL,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
static void *extract_select_fdot_idx_init(const MeshRenderData *mr, void *buf)
{
static GPUVertFormat format = {0};
if (format.attr_len == 0) {
/* TODO rename "color" to something more descriptive. */
GPU_vertformat_attr_add(&format, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
}
GPUVertBuf *vbo = buf;
GPU_vertbuf_init_with_format(vbo, &format);
GPU_vertbuf_data_alloc(vbo, mr->poly_len);
return vbo->data;
}
static void extract_fdot_idx_loop_bmesh(const MeshRenderData *UNUSED(mr),
int UNUSED(l),
BMLoop *loop,
void *data)
{
((uint32_t *)data)[BM_elem_index_get(loop->f)] = BM_elem_index_get(loop->f);
}
static void extract_fdot_idx_loop_mesh(const MeshRenderData *mr,
int UNUSED(l),
const MLoop *UNUSED(mloop),
int p,
const MPoly *UNUSED(mpoly),
void *data)
{
((uint32_t *)data)[p] = (mr->p_origindex) ? mr->p_origindex[p] : p;
}
Cleanup: undeclared variable warnings Forward declare variables, or make them static.
2019-08-22 18:22:23 +02:00
static const MeshExtract extract_fdot_idx = {
extract_select_fdot_idx_init,
NULL,
NULL,
extract_fdot_idx_loop_bmesh,
extract_fdot_idx_loop_mesh,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
true,
};
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Extract Loop
* \{ */
typedef struct ExtractTaskData {
const MeshRenderData *mr;
const MeshExtract *extract;
eMRIterType iter_type;
int start, end;
/** Decremented each time a task is finished. */
int32_t *task_counter;
void *buf;
void *user_data;
} ExtractTaskData;
BLI_INLINE void mesh_extract_iter(const MeshRenderData *mr,
const eMRIterType iter_type,
int start,
int end,
const MeshExtract *extract,
void *user_data)
{
switch (mr->extract_type) {
case MR_EXTRACT_BMESH:
if (iter_type & MR_ITER_LOOPTRI) {
int t_end = min_ii(mr->tri_len, end);
for (int t = start; t < t_end; t++) {
Revert "COW: Edit Mesh: Do not copy the looptris pointer" The looptri is repeated in the linked Meshes but the pointer is only referenced in the evaluated ones. This reverts commit 64982e213f014123d1b0406cf9ae893910a6a3d3.
2020-03-23 18:18:36 +01:00
BMLoop **elt = &mr->edit_bmesh->looptris[t][0];
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
extract->iter_looptri_bm(mr, t, elt, user_data);
}
}
if (iter_type & MR_ITER_LOOP) {
int l_end = min_ii(mr->poly_len, end);
for (int f = start; f < l_end; f++) {
BMFace *efa = BM_face_at_index(mr->bm, f);
BMLoop *loop;
BMIter l_iter;
BM_ITER_ELEM (loop, &l_iter, efa, BM_LOOPS_OF_FACE) {
extract->iter_loop_bm(mr, BM_elem_index_get(loop), loop, user_data);
}
}
}
if (iter_type & MR_ITER_LEDGE) {
int le_end = min_ii(mr->edge_loose_len, end);
for (int e = start; e < le_end; e++) {
BMEdge *eed = BM_edge_at_index(mr->bm, mr->ledges[e]);
extract->iter_ledge_bm(mr, e, eed, user_data);
}
}
if (iter_type & MR_ITER_LVERT) {
int lv_end = min_ii(mr->vert_loose_len, end);
for (int v = start; v < lv_end; v++) {
BMVert *eve = BM_vert_at_index(mr->bm, mr->lverts[v]);
extract->iter_lvert_bm(mr, v, eve, user_data);
}
}
break;
case MR_EXTRACT_MAPPED:
case MR_EXTRACT_MESH:
if (iter_type & MR_ITER_LOOPTRI) {
int t_end = min_ii(mr->tri_len, end);
for (int t = start; t < t_end; t++) {
extract->iter_looptri(mr, t, &mr->mlooptri[t], user_data);
}
}
if (iter_type & MR_ITER_LOOP) {
int l_end = min_ii(mr->poly_len, end);
for (int p = start; p < l_end; p++) {
const MPoly *mpoly = &mr->mpoly[p];
int l = mpoly->loopstart;
for (int i = 0; i < mpoly->totloop; i++, l++) {
extract->iter_loop(mr, l, &mr->mloop[l], p, mpoly, user_data);
}
}
}
if (iter_type & MR_ITER_LEDGE) {
int le_end = min_ii(mr->edge_loose_len, end);
for (int e = start; e < le_end; e++) {
extract->iter_ledge(mr, e, &mr->medge[mr->ledges[e]], user_data);
}
}
if (iter_type & MR_ITER_LVERT) {
int lv_end = min_ii(mr->vert_loose_len, end);
for (int v = start; v < lv_end; v++) {
extract->iter_lvert(mr, v, &mr->mvert[mr->lverts[v]], user_data);
}
}
break;
}
}
Task: Use TBB as Task Scheduler This patch enables TBB as the default task scheduler. TBB stands for Threading Building Blocks and is developed by Intel. The library contains several threading patters. This patch maps blenders BLI_task_* function to their counterpart. After this patch we can add more patterns. A promising one is TBB:graph that can be used for depsgraph, draw manager and compositor. Performance changes depends on the actual hardware. It was tested on different hardwares from laptops to workstations and we didn't detected any downgrade of the performance. * Linux Xeon E5-2699 v4 got FPS boost from 12 to 17 using Spring's 04_010_A.anim.blend. * AMD Ryzen Threadripper 2990WX 32-Core Animation playback goes from 9.5-10.5 FPS to 13.0-14.0 FPS on Agent 327 , 10_03_B.anim.blend. Reviewed By: brecht, sergey Differential Revision: https://developer.blender.org/D7475
2020-04-30 07:59:23 +02:00
static void extract_run(TaskPool *__restrict UNUSED(pool), void *taskdata)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
{
ExtractTaskData *data = taskdata;
mesh_extract_iter(
data->mr, data->iter_type, data->start, data->end, data->extract, data->user_data);
/* If this is the last task, we do the finish function. */
int remainin_tasks = atomic_sub_and_fetch_int32(data->task_counter, 1);
if (remainin_tasks == 0 && data->extract->finish != NULL) {
data->extract->finish(data->mr, data->buf, data->user_data);
}
}
static void extract_range_task_create(
TaskPool *task_pool, ExtractTaskData *taskdata, const eMRIterType type, int start, int length)
{
taskdata = MEM_dupallocN(taskdata);
atomic_add_and_fetch_int32(taskdata->task_counter, 1);
taskdata->iter_type = type;
taskdata->start = start;
taskdata->end = start + length;
TaskScheduler: Minor Preparations for TBB Tasks: move priority from task to task pool {rBf7c18df4f599fe39ffc914e645e504fcdbee8636} Tasks: split task.c into task_pool.cc and task_iterator.c {rB4ada1d267749931ca934a74b14a82479bcaa92e0} Differential Revision: https://developer.blender.org/D7385
2020-04-09 15:51:44 +02:00
BLI_task_pool_push(task_pool, extract_run, taskdata, true, NULL);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
static void extract_task_create(TaskPool *task_pool,
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
const Scene *scene,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const MeshRenderData *mr,
const MeshExtract *extract,
void *buf,
int32_t *task_counter)
{
Fix T76131: Crash combing Hair using Python Caused by rBe82827bf6ed5. DRW_draw_depth_object calls DRW_mesh_batch_cache_create_requested with NULL scene, but that is accessed later on... Scene is actually available, so pass that around. Maniphest Tasks: T76131 Differential Revision: https://developer.blender.org/D7540
2020-04-27 11:37:20 +02:00
BLI_assert(scene != NULL);
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
const bool do_hq_normals = (scene->r.perf_flag & SCE_PERF_HQ_NORMALS) != 0;
if (do_hq_normals && (extract == &extract_lnor)) {
extract = &extract_lnor_hq;
}
if (do_hq_normals && (extract == &extract_tan)) {
extract = &extract_tan_hq;
}
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
/* Divide extraction of the VBO/IBO into sensible chunks of works. */
ExtractTaskData *taskdata = MEM_mallocN(sizeof(*taskdata), "ExtractTaskData");
taskdata->mr = mr;
taskdata->extract = extract;
taskdata->buf = buf;
taskdata->user_data = extract->init(mr, buf);
taskdata->iter_type = mesh_extract_iter_type(extract);
taskdata->task_counter = task_counter;
taskdata->start = 0;
taskdata->end = INT_MAX;
/* Simple heuristic. */
const bool use_thread = (mr->loop_len + mr->loop_loose_len) > 8192;
if (use_thread && extract->use_threading) {
/* Divide task into sensible chunks. */
const int chunk_size = 8192;
if (taskdata->iter_type & MR_ITER_LOOPTRI) {
for (int i = 0; i < mr->tri_len; i += chunk_size) {
extract_range_task_create(task_pool, taskdata, MR_ITER_LOOPTRI, i, chunk_size);
}
}
if (taskdata->iter_type & MR_ITER_LOOP) {
for (int i = 0; i < mr->poly_len; i += chunk_size) {
extract_range_task_create(task_pool, taskdata, MR_ITER_LOOP, i, chunk_size);
}
}
if (taskdata->iter_type & MR_ITER_LEDGE) {
for (int i = 0; i < mr->edge_loose_len; i += chunk_size) {
extract_range_task_create(task_pool, taskdata, MR_ITER_LEDGE, i, chunk_size);
}
}
if (taskdata->iter_type & MR_ITER_LVERT) {
for (int i = 0; i < mr->vert_loose_len; i += chunk_size) {
extract_range_task_create(task_pool, taskdata, MR_ITER_LVERT, i, chunk_size);
}
}
MEM_freeN(taskdata);
}
else if (use_thread) {
/* One task for the whole VBO. */
(*task_counter)++;
TaskScheduler: Minor Preparations for TBB Tasks: move priority from task to task pool {rBf7c18df4f599fe39ffc914e645e504fcdbee8636} Tasks: split task.c into task_pool.cc and task_iterator.c {rB4ada1d267749931ca934a74b14a82479bcaa92e0} Differential Revision: https://developer.blender.org/D7385
2020-04-09 15:51:44 +02:00
BLI_task_pool_push(task_pool, extract_run, taskdata, true, NULL);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
}
else {
/* Single threaded extraction. */
(*task_counter)++;
Task: Use TBB as Task Scheduler This patch enables TBB as the default task scheduler. TBB stands for Threading Building Blocks and is developed by Intel. The library contains several threading patters. This patch maps blenders BLI_task_* function to their counterpart. After this patch we can add more patterns. A promising one is TBB:graph that can be used for depsgraph, draw manager and compositor. Performance changes depends on the actual hardware. It was tested on different hardwares from laptops to workstations and we didn't detected any downgrade of the performance. * Linux Xeon E5-2699 v4 got FPS boost from 12 to 17 using Spring's 04_010_A.anim.blend. * AMD Ryzen Threadripper 2990WX 32-Core Animation playback goes from 9.5-10.5 FPS to 13.0-14.0 FPS on Agent 327 , 10_03_B.anim.blend. Reviewed By: brecht, sergey Differential Revision: https://developer.blender.org/D7475
2020-04-30 07:59:23 +02:00
extract_run(NULL, taskdata);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
MEM_freeN(taskdata);
}
}
void mesh_buffer_cache_create_requested(MeshBatchCache *cache,
MeshBufferCache mbc,
Mesh *me,
Fix T72667: Collection delete hierarchy in edit-mode crashes Also resolves T72848, although updating multiple windows doesn't work, this matches 2.7x behavior.
2020-01-08 12:20:45 +01:00
const bool is_editmode,
Fix T75343: Wireframe overylay is not working properly with multiple modifiers Since rBcf258b02f449, only wires and edges that are mapped to the original mesh were drawn if the mesh was modified by modifiers. Above commit was only meant for showing orig wires for paint mask overlays [where final wireframe is not desired], so now only use MR_EXTRACT_MAPPED when we are in a paint mode. Maniphest Tasks: T75343 Differential Revision: https://developer.blender.org/D7333
2020-04-04 11:14:45 +02:00
const bool is_paint_mode,
BMesh: remove BMEditMesh.ob use for draw manager
2020-01-07 04:06:33 +01:00
const float obmat[4][4],
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const bool do_final,
const bool do_uvedit,
const bool use_subsurf_fdots,
const DRW_MeshCDMask *cd_layer_used,
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
const Scene *scene,
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
const ToolSettings *ts,
const bool use_hide)
{
eMRIterType iter_flag = 0;
eMRDataType data_flag = 0;
#define TEST_ASSIGN(type, type_lowercase, name) \
do { \
if (DRW_TEST_ASSIGN_##type(mbc.type_lowercase.name)) { \
iter_flag |= mesh_extract_iter_type(&extract_##name); \
data_flag |= extract_##name.data_flag; \
} \
} while (0)
TEST_ASSIGN(VBO, vbo, pos_nor);
TEST_ASSIGN(VBO, vbo, lnor);
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
TEST_ASSIGN(VBO, vbo, uv);
TEST_ASSIGN(VBO, vbo, tan);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
TEST_ASSIGN(VBO, vbo, vcol);
TEST_ASSIGN(VBO, vbo, orco);
TEST_ASSIGN(VBO, vbo, edge_fac);
TEST_ASSIGN(VBO, vbo, weights);
TEST_ASSIGN(VBO, vbo, edit_data);
TEST_ASSIGN(VBO, vbo, edituv_data);
TEST_ASSIGN(VBO, vbo, stretch_area);
TEST_ASSIGN(VBO, vbo, stretch_angle);
TEST_ASSIGN(VBO, vbo, mesh_analysis);
TEST_ASSIGN(VBO, vbo, fdots_pos);
TEST_ASSIGN(VBO, vbo, fdots_nor);
TEST_ASSIGN(VBO, vbo, fdots_uv);
TEST_ASSIGN(VBO, vbo, fdots_edituv_data);
TEST_ASSIGN(VBO, vbo, poly_idx);
TEST_ASSIGN(VBO, vbo, edge_idx);
TEST_ASSIGN(VBO, vbo, vert_idx);
TEST_ASSIGN(VBO, vbo, fdot_idx);
Fix assert and memleak in recent Skin Root Display patch Caused by 4ddf3215a7df
2019-10-16 19:28:10 +02:00
TEST_ASSIGN(VBO, vbo, skin_roots);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
TEST_ASSIGN(IBO, ibo, tris);
TEST_ASSIGN(IBO, ibo, lines);
TEST_ASSIGN(IBO, ibo, points);
TEST_ASSIGN(IBO, ibo, fdots);
TEST_ASSIGN(IBO, ibo, lines_paint_mask);
TEST_ASSIGN(IBO, ibo, lines_adjacency);
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
TEST_ASSIGN(IBO, ibo, lines_loose);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
TEST_ASSIGN(IBO, ibo, edituv_tris);
TEST_ASSIGN(IBO, ibo, edituv_lines);
TEST_ASSIGN(IBO, ibo, edituv_points);
TEST_ASSIGN(IBO, ibo, edituv_fdots);
#undef TEST_ASSIGN
#ifdef DEBUG_TIME
double rdata_start = PIL_check_seconds_timer();
#endif
Fix T75343: Wireframe overylay is not working properly with multiple modifiers Since rBcf258b02f449, only wires and edges that are mapped to the original mesh were drawn if the mesh was modified by modifiers. Above commit was only meant for showing orig wires for paint mask overlays [where final wireframe is not desired], so now only use MR_EXTRACT_MAPPED when we are in a paint mode. Maniphest Tasks: T75343 Differential Revision: https://developer.blender.org/D7333
2020-04-04 11:14:45 +02:00
MeshRenderData *mr = mesh_render_data_create(me,
is_editmode,
is_paint_mode,
obmat,
do_final,
do_uvedit,
iter_flag,
data_flag,
cd_layer_used,
ts);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
mr->cache = cache; /* HACK */
mr->use_hide = use_hide;
mr->use_subsurf_fdots = use_subsurf_fdots;
mr->use_final_mesh = do_final;
#ifdef DEBUG_TIME
double rdata_end = PIL_check_seconds_timer();
#endif
TaskPool *task_pool;
Task: Use TBB as Task Scheduler This patch enables TBB as the default task scheduler. TBB stands for Threading Building Blocks and is developed by Intel. The library contains several threading patters. This patch maps blenders BLI_task_* function to their counterpart. After this patch we can add more patterns. A promising one is TBB:graph that can be used for depsgraph, draw manager and compositor. Performance changes depends on the actual hardware. It was tested on different hardwares from laptops to workstations and we didn't detected any downgrade of the performance. * Linux Xeon E5-2699 v4 got FPS boost from 12 to 17 using Spring's 04_010_A.anim.blend. * AMD Ryzen Threadripper 2990WX 32-Core Animation playback goes from 9.5-10.5 FPS to 13.0-14.0 FPS on Agent 327 , 10_03_B.anim.blend. Reviewed By: brecht, sergey Differential Revision: https://developer.blender.org/D7475
2020-04-30 07:59:23 +02:00
/* Create a suspended pool as the finalize method could be called too early.
* See `extract_run`. */
task_pool = BLI_task_pool_create_suspended(NULL, TASK_PRIORITY_HIGH);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
size_t counters_size = (sizeof(mbc) / sizeof(void *)) * sizeof(int32_t);
int32_t *task_counters = MEM_callocN(counters_size, __func__);
int counter_used = 0;
#define EXTRACT(buf, name) \
if (mbc.buf.name) { \
extract_task_create( \
DRW: New High Quality Normal & Tangent extract This patch adds a dedicated path to extract 16bit normals instead of packing them into 10bits/comp. The tangents are also packed to 10bits/comp if not using the new High Quality Normal option. Fix T61024 Degraded texture shading on dense meshes Reviewed By: brecht Differential Revision: https://developer.blender.org/D6614
2020-02-19 01:44:52 +01:00
task_pool, scene, mr, &extract_##name, mbc.buf.name, &task_counters[counter_used++]); \
Cleanup: extra semicolon, comma warnings
2019-09-21 03:34:39 +02:00
} \
((void)0)
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
EXTRACT(vbo, pos_nor);
EXTRACT(vbo, lnor);
Mesh Batch Cache: Split UV an tangent into 2 distinct VBOs This is done because they don't have the same update frequency. UV can be persistent even on geometry update (ex: skinned object) but tangents can change if the normals change. Also the name buffer per vbo was too small to contain all names.
2019-08-14 22:43:44 +02:00
EXTRACT(vbo, uv);
EXTRACT(vbo, tan);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
EXTRACT(vbo, vcol);
EXTRACT(vbo, orco);
EXTRACT(vbo, edge_fac);
EXTRACT(vbo, weights);
EXTRACT(vbo, edit_data);
EXTRACT(vbo, edituv_data);
EXTRACT(vbo, stretch_area);
EXTRACT(vbo, stretch_angle);
EXTRACT(vbo, mesh_analysis);
EXTRACT(vbo, fdots_pos);
EXTRACT(vbo, fdots_nor);
EXTRACT(vbo, fdots_uv);
EXTRACT(vbo, fdots_edituv_data);
EXTRACT(vbo, poly_idx);
EXTRACT(vbo, edge_idx);
EXTRACT(vbo, vert_idx);
EXTRACT(vbo, fdot_idx);
Fix T68380 Skin modifier root not displayed
2019-10-15 01:49:53 +02:00
EXTRACT(vbo, skin_roots);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
EXTRACT(ibo, tris);
EXTRACT(ibo, lines);
EXTRACT(ibo, points);
EXTRACT(ibo, fdots);
EXTRACT(ibo, lines_paint_mask);
EXTRACT(ibo, lines_adjacency);
EXTRACT(ibo, edituv_tris);
EXTRACT(ibo, edituv_lines);
EXTRACT(ibo, edituv_points);
EXTRACT(ibo, edituv_fdots);
/* TODO(fclem) Ideally, we should have one global pool for all
* objects and wait for finish only before drawing when buffers
* need to be ready. */
BLI_task_pool_work_and_wait(task_pool);
Fix T72175: DrawManager Crash Large Objects Introduced by 9c337fcfe2a4 mistaken that `MeshExtract.use_threading` set to false means that no threading is used at all. This is not the case it will still perform threading for large objects, it will only run the different subtasks in serial. Fixed by scheduling the `lines_loose` in the task_pool after the rest have been executed. This is cleaner than the previous implementation as it sticks more to the actual design.
2019-12-05 08:14:32 +01:00
/* The next task(s) rely on the result of the tasks above. */
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
/* The `lines_loose` is a sub buffer from `ibo.lines`.
Fix T72175: DrawManager Crash Large Objects Introduced by 9c337fcfe2a4 mistaken that `MeshExtract.use_threading` set to false means that no threading is used at all. This is not the case it will still perform threading for large objects, it will only run the different subtasks in serial. Fixed by scheduling the `lines_loose` in the task_pool after the rest have been executed. This is cleaner than the previous implementation as it sticks more to the actual design.
2019-12-05 08:14:32 +01:00
* We schedule it here due to potential synchronization issues.*/
EXTRACT(ibo, lines_loose);
Fix T72130: Wireframe Visible After Disabling The lines index buffer can contain all edges (edit mode) or only loose edges (object mode). When switching between these modes the wrong content of the index buffer can be used. This patch will clear the lines index buffer when a `loose_edges` is requested. Making sure it is always up to date. Note that this is supporting an exising hack where the IBO is truncated during the creation. We should find a different way how to solve these kind of issues. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6349
2019-12-03 08:27:55 +01:00
Fix T72175: DrawManager Crash Large Objects Introduced by 9c337fcfe2a4 mistaken that `MeshExtract.use_threading` set to false means that no threading is used at all. This is not the case it will still perform threading for large objects, it will only run the different subtasks in serial. Fixed by scheduling the `lines_loose` in the task_pool after the rest have been executed. This is cleaner than the previous implementation as it sticks more to the actual design.
2019-12-05 08:14:32 +01:00
BLI_task_pool_work_and_wait(task_pool);
#undef EXTRACT
BLI_task_pool_free(task_pool);
Mesh Batch Cache: Refactor + Multithread For clarity sake, the batch cache now uses exclusively per Loop attributes. While this is a bit of a waste of VRAM (for the few case where per vert attribs are enough) it reduces the complexity and amount of overall VBO to update in general situations. This patch also makes the VertexBuffers filling multithreaded. This make the update of dense meshes a bit faster. The main bottleneck is the IndexBuffers update which cannot be multithreaded efficiently (have to increment a counter and/or do a final sorting pass). We introduce the concept of "extract" functions/step. All extract functions are executed in one thread each and if possible, using multiple thread for looping over all elements. Reviewed By: brecht Differential Revision: http://developer.blender.org/D5424
2019-07-14 16:49:44 +02:00
MEM_freeN(task_counters);
mesh_render_data_free(mr);
#ifdef DEBUG_TIME
double end = PIL_check_seconds_timer();
static double avg = 0;
static double avg_fps = 0;
static double avg_rdata = 0;
static double end_prev = 0;
if (end_prev == 0) {
end_prev = end;
}
avg = avg * 0.95 + (end - rdata_end) * 0.05;
avg_fps = avg_fps * 0.95 + (end - end_prev) * 0.05;
avg_rdata = avg_rdata * 0.95 + (rdata_end - rdata_start) * 0.05;
printf(
"rdata %.0fms iter %.0fms (frame %.0fms)\n", avg_rdata * 1000, avg * 1000, avg_fps * 1000);
end_prev = end;
#endif
}
/** \} */