Viewport: implement hiding faces in paint modes.
authorAlexander Gavrilov <angavrilov@gmail.com>
Sun, 25 Nov 2018 15:34:28 +0000 (18:34 +0300)
committerAlexander Gavrilov <angavrilov@gmail.com>
Mon, 26 Nov 2018 17:26:29 +0000 (20:26 +0300)
In 2.79 hiding works in paint modes with selection enabled,
so it is a missing feature. This implements it in texture
paint overlays and in workbench base shading.

Reviewers: fclem

Differential Revision: https://developer.blender.org/D3989

source/blender/draw/engines/eevee/eevee_materials.c
source/blender/draw/engines/workbench/workbench_deferred.c
source/blender/draw/engines/workbench/workbench_forward.c
source/blender/draw/intern/DRW_render.h
source/blender/draw/intern/draw_cache.c
source/blender/draw/intern/draw_cache.h
source/blender/draw/intern/draw_cache_impl.h
source/blender/draw/intern/draw_cache_impl_mesh.c
source/blender/draw/intern/draw_manager.c
source/blender/draw/modes/edit_mesh_mode.c
source/blender/draw/modes/paint_texture_mode.c

index a87b46266282f0276082ded88e12b8060bbce97b..6736d4c4110a546c8f1571a8c74f7b36aad01f1f 100644 (file)
@@ -1450,6 +1450,7 @@ void EEVEE_materials_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sld
                is_sculpt_mode &&
                ((ob->sculpt && ob->sculpt->pbvh) && (BKE_pbvh_type(ob->sculpt->pbvh) != PBVH_FACES));
 #endif
+       const bool use_hide = is_active && DRW_object_use_hide_faces(ob);
        const bool is_default_mode_shader = is_sculpt_mode;
 
        /* First get materials for this mesh. */
@@ -1526,7 +1527,7 @@ void EEVEE_materials_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sld
                        int *auto_layer_is_srgb;
                        int auto_layer_count;
                        struct GPUBatch **mat_geom = DRW_cache_object_surface_material_get(
-                               ob, gpumat_array, materials_len,
+                               ob, gpumat_array, materials_len, use_hide,
                                &auto_layer_names,
                                &auto_layer_is_srgb,
                                &auto_layer_count);
index ce14ee66ab22c92291cb50acafc698941c98dfe3..91dffe352aebf9a3b584bb1a14e52f31dea057e5 100644 (file)
@@ -715,13 +715,14 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
        if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) {
                const bool is_active = (ob == draw_ctx->obact);
                const bool is_sculpt_mode = is_active && (draw_ctx->object_mode & OB_MODE_SCULPT) != 0;
+               const bool use_hide = is_active && DRW_object_use_hide_faces(ob);
                bool is_drawn = false;
                if (!is_sculpt_mode && TEXTURE_DRAWING_ENABLED(wpd) && ELEM(ob->type, OB_MESH)) {
                        const Mesh *me = ob->data;
                        if (me->mloopuv) {
                                const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol));
                                struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len);
-                               struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob) : NULL;
+                               struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob, use_hide) : NULL;
                                if (materials_len > 0 && geom_array) {
                                        for (int i = 0; i < materials_len; i++) {
                                                if (geom_array[i] == NULL) {
@@ -744,7 +745,7 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                if (!is_drawn) {
                        if (ELEM(wpd->shading.color_type, V3D_SHADING_SINGLE_COLOR, V3D_SHADING_RANDOM_COLOR)) {
                                /* No material split needed */
-                               struct GPUBatch *geom = DRW_cache_object_surface_get(ob);
+                               struct GPUBatch *geom = DRW_cache_object_surface_get_ex(ob, use_hide);
                                if (geom) {
                                        material = get_or_create_material_data(vedata, ob, NULL, NULL, wpd->shading.color_type);
                                        if (is_sculpt_mode) {
@@ -763,7 +764,7 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                                }
 
                                struct GPUBatch **mat_geom = DRW_cache_object_surface_material_get(
-                                       ob, gpumat_array, materials_len, NULL, NULL, NULL);
+                                       ob, gpumat_array, materials_len, use_hide, NULL, NULL, NULL);
                                if (mat_geom) {
                                        for (int i = 0; i < materials_len; ++i) {
                                                if (mat_geom[i] == NULL) {
@@ -787,7 +788,7 @@ void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                        bool is_manifold;
                        struct GPUBatch *geom_shadow = DRW_cache_object_edge_detection_get(ob, &is_manifold);
                        if (geom_shadow) {
-                               if (is_sculpt_mode) {
+                               if (is_sculpt_mode || use_hide) {
                                        /* Currently unsupported in sculpt mode. We could revert to the slow
                                         * method in this case but I'm not sure if it's a good idea given that
                                         * sculpted meshes are heavy to begin with. */
index 7a03984b196a6c991b76f2f13f043e3809a410f6..b169f6c165e362df9aca74a94f149860579a5b45 100644 (file)
@@ -505,6 +505,7 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
        if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) {
                const bool is_active = (ob == draw_ctx->obact);
                const bool is_sculpt_mode = is_active && (draw_ctx->object_mode & OB_MODE_SCULPT) != 0;
+               const bool use_hide = is_active && DRW_object_use_hide_faces(ob);
                bool is_drawn = false;
 
                if (!is_sculpt_mode && TEXTURE_DRAWING_ENABLED(wpd) && ELEM(ob->type, OB_MESH)) {
@@ -512,7 +513,7 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                        if (me->mloopuv) {
                                const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol));
                                struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len);
-                               struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob) : NULL;
+                               struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob, use_hide) : NULL;
                                if (materials_len > 0 && geom_array) {
                                        for (int i = 0; i < materials_len; i++) {
                                                if (geom_array[i] == NULL) {
@@ -545,7 +546,7 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                if (!is_drawn) {
                        if (ELEM(wpd->shading.color_type, V3D_SHADING_SINGLE_COLOR, V3D_SHADING_RANDOM_COLOR)) {
                                /* No material split needed */
-                               struct GPUBatch *geom = DRW_cache_object_surface_get(ob);
+                               struct GPUBatch *geom = DRW_cache_object_surface_get_ex(ob, use_hide);
                                if (geom) {
                                        material = get_or_create_material_data(vedata, ob, NULL, NULL, wpd->shading.color_type);
                                        if (is_sculpt_mode) {
@@ -570,7 +571,7 @@ void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob)
                                }
 
                                struct GPUBatch **mat_geom = DRW_cache_object_surface_material_get(
-                                       ob, gpumat_array, materials_len, NULL, NULL, NULL);
+                                       ob, gpumat_array, materials_len, use_hide, NULL, NULL, NULL);
                                if (mat_geom) {
                                        for (int i = 0; i < materials_len; ++i) {
                                                if (mat_geom[i] == NULL) {
index faba85c9b467dd17d86264b6ab89a6dbbb87ede5..a5e08b4411c774b2b9f553a54dc6d6e0de041e0a 100644 (file)
@@ -512,6 +512,7 @@ DrawData *DRW_drawdata_ensure(
 bool DRW_object_is_renderable(const struct Object *ob);
 bool DRW_object_is_visible_in_active_context(const struct Object *ob);
 bool DRW_object_is_flat_normal(const struct Object *ob);
+bool DRW_object_use_hide_faces(const struct Object *ob);
 
 bool DRW_object_is_visible_psys_in_active_context(const struct Object *object, const struct ParticleSystem *psys);
 
index 325f607da2eb5c6c927719efcdf98daec73287a3..8fe3ba5e5b391456061bf4951e685dbb0959f1ed 100644 (file)
@@ -728,10 +728,15 @@ GPUBatch *DRW_cache_object_loose_edges_get(struct Object *ob)
 }
 
 GPUBatch *DRW_cache_object_surface_get(Object *ob)
+{
+       return DRW_cache_object_surface_get_ex(ob, false);
+}
+
+GPUBatch *DRW_cache_object_surface_get_ex(Object *ob, bool use_hide)
 {
        switch (ob->type) {
                case OB_MESH:
-                       return DRW_cache_mesh_surface_get(ob);
+                       return DRW_cache_mesh_surface_get(ob, use_hide);
                case OB_CURVE:
                        return DRW_cache_curve_surface_get(ob);
                case OB_SURF:
@@ -746,7 +751,7 @@ GPUBatch *DRW_cache_object_surface_get(Object *ob)
 }
 
 GPUBatch **DRW_cache_object_surface_material_get(
-        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count)
 {
        if (auto_layer_names != NULL) {
@@ -757,7 +762,7 @@ GPUBatch **DRW_cache_object_surface_material_get(
 
        switch (ob->type) {
                case OB_MESH:
-                       return DRW_cache_mesh_surface_shaded_get(ob, gpumat_array, gpumat_array_len,
+                       return DRW_cache_mesh_surface_shaded_get(ob, gpumat_array, gpumat_array_len, use_hide,
                                                                 auto_layer_names, auto_layer_is_srgb, auto_layer_count);
                case OB_CURVE:
                        return DRW_cache_curve_surface_shaded_get(ob, gpumat_array, gpumat_array_len);
@@ -3049,12 +3054,12 @@ GPUBatch *DRW_cache_mesh_edge_detection_get(Object *ob, bool *r_is_manifold)
        return DRW_mesh_batch_cache_get_edge_detection(me, r_is_manifold);
 }
 
-GPUBatch *DRW_cache_mesh_surface_get(Object *ob)
+GPUBatch *DRW_cache_mesh_surface_get(Object *ob, bool use_hide)
 {
        BLI_assert(ob->type == OB_MESH);
 
        Mesh *me = ob->data;
-       return DRW_mesh_batch_cache_get_triangles_with_normals(me);
+       return DRW_mesh_batch_cache_get_triangles_with_normals(me, use_hide);
 }
 
 void DRW_cache_mesh_face_wireframe_get(
@@ -3127,23 +3132,23 @@ GPUBatch *DRW_cache_mesh_surface_vert_colors_get(Object *ob)
 
 /* Return list of batches */
 GPUBatch **DRW_cache_mesh_surface_shaded_get(
-        Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count)
 {
        BLI_assert(ob->type == OB_MESH);
 
        Mesh *me = ob->data;
-       return DRW_mesh_batch_cache_get_surface_shaded(me, gpumat_array, gpumat_array_len,
+       return DRW_mesh_batch_cache_get_surface_shaded(me, gpumat_array, gpumat_array_len, use_hide,
                                                       auto_layer_names, auto_layer_is_srgb, auto_layer_count);
 }
 
 /* Return list of batches */
-GPUBatch **DRW_cache_mesh_surface_texpaint_get(Object *ob)
+GPUBatch **DRW_cache_mesh_surface_texpaint_get(Object *ob, bool use_hide)
 {
        BLI_assert(ob->type == OB_MESH);
 
        Mesh *me = ob->data;
-       return DRW_mesh_batch_cache_get_surface_texpaint(me);
+       return DRW_mesh_batch_cache_get_surface_texpaint(me, use_hide);
 }
 
 GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(Object *ob)
@@ -3183,7 +3188,7 @@ GPUBatch *DRW_cache_mesh_edges_paint_overlay_get(Object *ob, bool use_wire, bool
        BLI_assert(ob->type == OB_MESH);
 
        Mesh *me = ob->data;
-       return DRW_mesh_batch_cache_get_weight_overlay_edges(me, use_wire, use_sel);
+       return DRW_mesh_batch_cache_get_weight_overlay_edges(me, use_wire, use_sel, use_sel);
 }
 
 GPUBatch *DRW_cache_mesh_faces_weight_overlay_get(Object *ob)
index d2aa26222464dc959a2a9ac00175b2f9897151ca..207bc6ec5de332bf51f84dca5b72678e4db4e929 100644 (file)
@@ -53,9 +53,10 @@ struct GPUBatch *DRW_cache_screenspace_circle_get(void);
 struct GPUBatch *DRW_cache_object_wire_outline_get(struct Object *ob);
 struct GPUBatch *DRW_cache_object_edge_detection_get(struct Object *ob, bool *r_is_manifold);
 struct GPUBatch *DRW_cache_object_surface_get(struct Object *ob);
+struct GPUBatch *DRW_cache_object_surface_get_ex(struct Object *ob, bool use_hide);
 struct GPUBatch *DRW_cache_object_loose_edges_get(struct Object *ob);
 struct GPUBatch **DRW_cache_object_surface_material_get(
-        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count);
 void DRW_cache_object_face_wireframe_get(
         Object *ob, struct GPUTexture **r_vert_tx, struct GPUTexture **r_faceid_tx, int *r_tri_count);
@@ -137,7 +138,7 @@ void DRW_cache_mesh_normals_overlay_get(
 struct GPUBatch *DRW_cache_face_centers_get(struct Object *ob);
 struct GPUBatch *DRW_cache_mesh_wire_outline_get(struct Object *ob);
 struct GPUBatch *DRW_cache_mesh_edge_detection_get(struct Object *ob, bool *r_is_manifold);
-struct GPUBatch *DRW_cache_mesh_surface_get(struct Object *ob);
+struct GPUBatch *DRW_cache_mesh_surface_get(struct Object *ob, bool use_hide);
 struct GPUBatch *DRW_cache_mesh_loose_edges_get(struct Object *ob);
 struct GPUBatch *DRW_cache_mesh_surface_weights_get(struct Object *ob, struct ToolSettings *ts, bool paint_mode);
 struct GPUBatch *DRW_cache_mesh_surface_vert_colors_get(struct Object *ob);
@@ -148,9 +149,9 @@ struct GPUBatch *DRW_cache_mesh_edges_paint_overlay_get(struct Object *ob, bool
 struct GPUBatch *DRW_cache_mesh_faces_weight_overlay_get(struct Object *ob);
 struct GPUBatch *DRW_cache_mesh_verts_weight_overlay_get(struct Object *ob);
 struct GPUBatch **DRW_cache_mesh_surface_shaded_get(
-        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        struct Object *ob, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count);
-struct GPUBatch **DRW_cache_mesh_surface_texpaint_get(struct Object *ob);
+struct GPUBatch **DRW_cache_mesh_surface_texpaint_get(struct Object *ob, bool use_hide);
 struct GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(struct Object *ob);
 void DRW_cache_mesh_face_wireframe_get(
         Object *ob, struct GPUTexture **r_vert_tx, struct GPUTexture **r_faceid_tx, int *r_tri_count);
index 9dc735807c077405f6809396ef56953f8ddbc469..a9a6093529ecf9bb11de9b8a29e93994f15c5cc3 100644 (file)
@@ -128,16 +128,16 @@ bool DRW_mesh_weight_state_compare(const struct DRW_MeshWeightState *a, const st
 
 /* Mesh */
 struct GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(
-        struct Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        struct Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count);
-struct GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(struct Mesh *me);
+struct GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(struct Mesh *me, bool use_hide);
 struct GPUBatch *DRW_mesh_batch_cache_get_surface_texpaint_single(struct Mesh *me);
-struct GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(struct Mesh *me, bool use_wire, bool use_sel);
+struct GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(struct Mesh *me, bool use_wire, bool use_sel, bool use_hide);
 struct GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_faces(struct Mesh *me);
 struct GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_verts(struct Mesh *me);
 struct GPUBatch *DRW_mesh_batch_cache_get_all_edges(struct Mesh *me);
 struct GPUBatch *DRW_mesh_batch_cache_get_all_triangles(struct Mesh *me);
-struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(struct Mesh *me);
+struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(struct Mesh *me, bool use_hide);
 struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_weights(struct Mesh *me, const struct DRW_MeshWeightState *wstate);
 struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_vert_colors(struct Mesh *me);
 struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_id(struct Mesh *me, bool use_hide, uint select_id_offset);
index a24702368de366e5b0b83b9484e068eee87c8660..fbd2420b7a4dd21c060fdf8e2e4b900b4df15bbc 100644 (file)
@@ -247,6 +247,7 @@ typedef struct MeshRenderData {
        GPUPackedNormal *poly_normals_pack;
        GPUPackedNormal *vert_normals_pack;
        bool *edge_select_bool;
+       bool *edge_visible_bool;
 } MeshRenderData;
 
 enum {
@@ -967,6 +968,7 @@ static void mesh_render_data_free(MeshRenderData *rdata)
        MEM_SAFE_FREE(rdata->vert_normals_pack);
        MEM_SAFE_FREE(rdata->vert_weight);
        MEM_SAFE_FREE(rdata->edge_select_bool);
+       MEM_SAFE_FREE(rdata->edge_visible_bool);
        MEM_SAFE_FREE(rdata->vert_color);
 
        MEM_SAFE_FREE(rdata->mapped.loose_verts);
@@ -1350,6 +1352,27 @@ static void mesh_render_data_ensure_edge_select_bool(MeshRenderData *rdata, bool
        }
 }
 
+/** Ensure #MeshRenderData.edge_visible_bool */
+static void mesh_render_data_ensure_edge_visible_bool(MeshRenderData *rdata)
+{
+       bool *edge_visible_bool = rdata->edge_visible_bool;
+       if (edge_visible_bool == NULL) {
+               edge_visible_bool = rdata->edge_visible_bool =
+                       MEM_callocN(sizeof(*edge_visible_bool) * rdata->edge_len, __func__);
+
+               for (int i = 0; i < rdata->poly_len; i++) {
+                       const MPoly *poly = &rdata->mpoly[i];
+
+                       if (!(poly->flag & ME_HIDE)) {
+                               for (int j = 0; j < poly->totloop; j++) {
+                                       const MLoop *loop = &rdata->mloop[poly->loopstart + j];
+                                       edge_visible_bool[loop->e] = true;
+                               }
+                       }
+               }
+       }
+}
+
 /** \} */
 
 /* ---------------------------------------------------------------------- */
@@ -1949,6 +1972,7 @@ typedef struct MeshBatchCache {
        GPUBatch *all_triangles;
 
        GPUVertBuf *pos_with_normals;
+       GPUVertBuf *pos_with_normals_visible_only;
        GPUVertBuf *tri_aligned_uv;  /* Active UV layer (mloopuv) */
 
        /**
@@ -2298,7 +2322,7 @@ static void mesh_batch_cache_clear_selective(Mesh *me, GPUVertBuf *vert)
 
        BLI_assert(vert != NULL);
 
-       if (cache->pos_with_normals == vert) {
+       if (ELEM(vert, cache->pos_with_normals, cache->pos_with_normals_visible_only)) {
                GPU_BATCH_DISCARD_SAFE(cache->triangles_with_normals);
                GPU_BATCH_DISCARD_SAFE(cache->triangles_with_weights);
                GPU_BATCH_DISCARD_SAFE(cache->triangles_with_vert_colors);
@@ -2371,6 +2395,7 @@ static void mesh_batch_cache_clear(Mesh *me)
        GPU_BATCH_DISCARD_SAFE(cache->points_with_normals);
        GPU_BATCH_DISCARD_SAFE(cache->ledges_with_normals);
        GPU_VERTBUF_DISCARD_SAFE(cache->pos_with_normals);
+       GPU_VERTBUF_DISCARD_SAFE(cache->pos_with_normals_visible_only);
        GPU_BATCH_DISCARD_SAFE(cache->triangles_with_weights);
        GPU_BATCH_DISCARD_SAFE(cache->triangles_with_vert_colors);
        GPU_VERTBUF_DISCARD_SAFE(cache->tri_aligned_uv);
@@ -2923,19 +2948,11 @@ static GPUVertBuf *mesh_batch_cache_get_tri_pos_and_normals_ex(
 }
 
 static GPUVertBuf *mesh_batch_cache_get_tri_pos_and_normals(
-        MeshRenderData *rdata, MeshBatchCache *cache)
-{
-       return mesh_batch_cache_get_tri_pos_and_normals_ex(
-               rdata, false,
-               &cache->pos_with_normals);
-}
-static GPUVertBuf *mesh_create_tri_pos_and_normals_visible_only(
-        MeshRenderData *rdata)
+        MeshRenderData *rdata, MeshBatchCache *cache, bool use_hide)
 {
-       GPUVertBuf *vbo_dummy = NULL;
        return mesh_batch_cache_get_tri_pos_and_normals_ex(
-               rdata, true,
-               &vbo_dummy);
+               rdata, use_hide,
+               use_hide ? &cache->pos_with_normals_visible_only : &cache->pos_with_normals);
 }
 
 static GPUVertBuf *mesh_batch_cache_get_facedot_pos_with_normals_and_flag(
@@ -4402,7 +4419,7 @@ static GPUIndexBuf *mesh_batch_cache_get_loose_edges(MeshRenderData *rdata, Mesh
 static GPUIndexBuf **mesh_batch_cache_get_triangles_in_order_split_by_material(
         MeshRenderData *rdata, MeshBatchCache *cache,
         /* Special case when drawing final evaluated mesh in editmode, so hidden faces are ignored. */
-        BMesh *bm_mapped, const int *p_origindex_mapped)
+        BMesh *bm_mapped, const int *p_origindex_mapped, bool use_hide)
 {
        BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_POLY));
 
@@ -4431,9 +4448,11 @@ static GPUIndexBuf **mesh_batch_cache_get_triangles_in_order_split_by_material(
                }
                else if (bm_mapped == NULL) {
                        for (uint i = 0; i < poly_len; i++) {
-                               const MPoly *mp = &rdata->mpoly[i]; ;
-                               const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
-                               mat_tri_len[ma_id] += (mp->totloop - 2);
+                               const MPoly *mp = &rdata->mpoly[i];
+                               if (!use_hide || !(mp->flag & ME_HIDE)) {
+                                       const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
+                                       mat_tri_len[ma_id] += (mp->totloop - 2);
+                               }
                        }
                }
                else {
@@ -4475,11 +4494,16 @@ static GPUIndexBuf **mesh_batch_cache_get_triangles_in_order_split_by_material(
                }
                else if (bm_mapped == NULL) {
                        for (uint i = 0; i < poly_len; i++) {
-                               const MPoly *mp = &rdata->mpoly[i]; ;
-                               const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
-                               for (int j = 2; j < mp->totloop; j++) {
-                                       GPU_indexbuf_add_tri_verts(&elb[ma_id], nidx + 0, nidx + 1, nidx + 2);
-                                       nidx += 3;
+                               const MPoly *mp = &rdata->mpoly[i];
+                               if (!use_hide || !(mp->flag & ME_HIDE)) {
+                                       const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
+                                       for (int j = 2; j < mp->totloop; j++) {
+                                               GPU_indexbuf_add_tri_verts(&elb[ma_id], nidx + 0, nidx + 1, nidx + 2);
+                                               nidx += 3;
+                                       }
+                               }
+                               else {
+                                       nidx += 3 * (mp->totloop - 2);
                                }
                        }
                }
@@ -4515,7 +4539,7 @@ static GPUIndexBuf **mesh_batch_cache_get_triangles_in_order_split_by_material(
 }
 
 static GPUVertBuf *mesh_create_edge_pos_with_sel(
-        MeshRenderData *rdata, bool use_wire, bool use_select_bool)
+        MeshRenderData *rdata, bool use_wire, bool use_select_bool, bool use_visible_bool)
 {
        BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP));
        BLI_assert(rdata->edit_bmesh == NULL);
@@ -4543,10 +4567,18 @@ static GPUVertBuf *mesh_create_edge_pos_with_sel(
                        mesh_render_data_ensure_edge_select_bool(rdata, use_wire);
                }
                bool *edge_select_bool = use_select_bool ? rdata->edge_select_bool : NULL;
+               if (use_visible_bool) {
+                       mesh_render_data_ensure_edge_visible_bool(rdata);
+               }
+               bool *edge_visible_bool = use_visible_bool ? rdata->edge_visible_bool : NULL;
 
                for (int i = 0; i < edge_len; i++) {
                        const MEdge *ed = &rdata->medge[i];
 
+                       if (use_visible_bool && !edge_visible_bool[i]) {
+                               continue;
+                       }
+
                        uchar edge_vert_sel;
                        if (use_select_bool && edge_select_bool[i]) {
                                edge_vert_sel = true;
@@ -4685,7 +4717,7 @@ GPUBatch *DRW_mesh_batch_cache_get_all_triangles(Mesh *me)
        return cache->all_triangles;
 }
 
-GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(Mesh *me)
+GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(Mesh *me, bool use_hide)
 {
        MeshBatchCache *cache = mesh_batch_cache_get(me);
 
@@ -4694,7 +4726,7 @@ GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(Mesh *me)
                MeshRenderData *rdata = mesh_render_data_create(me, datatype);
 
                cache->triangles_with_normals = GPU_batch_create(
-                       GPU_PRIM_TRIS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache), NULL);
+                       GPU_PRIM_TRIS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, use_hide), NULL);
 
                mesh_render_data_free(rdata);
        }
@@ -4741,11 +4773,9 @@ GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_weights(
 
                DRW_mesh_weight_state_copy(&cache->weight_state, wstate);
 
-               GPUVertBuf *vbo_tris = use_hide ?
-                       mesh_create_tri_pos_and_normals_visible_only(rdata) :
-                       mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
+               GPUVertBuf *vbo_tris = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, use_hide);
 
-               GPU_batch_vertbuf_add_ex(cache->triangles_with_weights, vbo_tris, use_hide);
+               GPU_batch_vertbuf_add(cache->triangles_with_weights, vbo_tris);
 
                mesh_render_data_free(rdata);
        }
@@ -4766,10 +4796,8 @@ GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_vert_colors(Mesh *
                cache->triangles_with_vert_colors = GPU_batch_create_ex(
                        GPU_PRIM_TRIS, mesh_create_tri_vert_colors(rdata, use_hide), NULL, GPU_BATCH_OWNS_VBO);
 
-               GPUVertBuf *vbo_tris = use_hide ?
-                       mesh_create_tri_pos_and_normals_visible_only(rdata) :
-                       mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
-               GPU_batch_vertbuf_add_ex(cache->triangles_with_vert_colors, vbo_tris, use_hide);
+               GPUVertBuf *vbo_tris = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, use_hide);
+               GPU_batch_vertbuf_add(cache->triangles_with_vert_colors, vbo_tris);
 
                mesh_render_data_free(rdata);
        }
@@ -4799,10 +4827,8 @@ struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_id(
                cache->triangles_with_select_id = GPU_batch_create_ex(
                        GPU_PRIM_TRIS, mesh_create_tri_select_id(rdata, use_hide, select_id_offset), NULL, GPU_BATCH_OWNS_VBO);
 
-               GPUVertBuf *vbo_tris = use_hide ?
-                       mesh_create_tri_pos_and_normals_visible_only(rdata) :
-                       mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
-               GPU_batch_vertbuf_add_ex(cache->triangles_with_select_id, vbo_tris, use_hide);
+               GPUVertBuf *vbo_tris = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, use_hide);
+               GPU_batch_vertbuf_add(cache->triangles_with_select_id, vbo_tris);
 
                mesh_render_data_free(rdata);
        }
@@ -4825,12 +4851,10 @@ struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_mask(struct Mesh
                        rdata->mapped.use = true;
                }
 
-               GPUVertBuf *vbo_tris = use_hide ?
-                       mesh_create_tri_pos_and_normals_visible_only(rdata) :
-                       mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
+               GPUVertBuf *vbo_tris = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, use_hide);
 
-               cache->triangles_with_select_mask = GPU_batch_create_ex(
-                       GPU_PRIM_TRIS, vbo_tris, NULL, use_hide ? GPU_BATCH_OWNS_VBO : 0);
+               cache->triangles_with_select_mask = GPU_batch_create(
+                       GPU_PRIM_TRIS, vbo_tris, NULL);
 
                mesh_render_data_free(rdata);
        }
@@ -4847,7 +4871,7 @@ GPUBatch *DRW_mesh_batch_cache_get_points_with_normals(Mesh *me)
                MeshRenderData *rdata = mesh_render_data_create(me, datatype);
 
                cache->points_with_normals = GPU_batch_create(
-                       GPU_PRIM_POINTS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache), NULL);
+                       GPU_PRIM_POINTS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, false), NULL);
 
                mesh_render_data_free(rdata);
        }
@@ -5221,7 +5245,7 @@ GPUBatch *DRW_mesh_batch_cache_get_verts_with_select_id(Mesh *me, uint select_id
 }
 
 GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(
-        Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
+        Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len, bool use_hide,
         char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count)
 {
        MeshBatchCache *cache = mesh_batch_cache_get(me);
@@ -5262,9 +5286,9 @@ GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(
 
                GPUIndexBuf **el = mesh_batch_cache_get_triangles_in_order_split_by_material(
                        rdata, cache,
-                       bm_mapped, p_origindex);
+                       bm_mapped, p_origindex, use_hide);
 
-               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
+               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, false);
                GPUVertBuf *vbo_shading = mesh_batch_cache_get_tri_shading_data(rdata, cache);
 
                for (int i = 0; i < mat_len; i++) {
@@ -5287,7 +5311,7 @@ GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(
        return cache->shaded_triangles;
 }
 
-GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(Mesh *me)
+GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(Mesh *me, bool use_hide)
 {
        MeshBatchCache *cache = mesh_batch_cache_get(me);
 
@@ -5301,9 +5325,10 @@ GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(Mesh *me)
 
                cache->texpaint_triangles = MEM_callocN(sizeof(*cache->texpaint_triangles) * mat_len, __func__);
 
-               GPUIndexBuf **el = mesh_batch_cache_get_triangles_in_order_split_by_material(rdata, cache, NULL, NULL);
+               GPUIndexBuf **el = mesh_batch_cache_get_triangles_in_order_split_by_material(rdata, cache, NULL, NULL, use_hide);
+
+               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, false);
 
-               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
                for (int i = 0; i < mat_len; i++) {
                        cache->texpaint_triangles[i] = GPU_batch_create(
                                GPU_PRIM_TRIS, vbo, el[i]);
@@ -5328,7 +5353,7 @@ GPUBatch *DRW_mesh_batch_cache_get_surface_texpaint_single(Mesh *me)
                        MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOPUV;
                MeshRenderData *rdata = mesh_render_data_create(me, datatype);
 
-               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
+               GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache, false);
 
                cache->texpaint_triangles_single = GPU_batch_create(
                        GPU_PRIM_TRIS, vbo, NULL);
@@ -5392,7 +5417,7 @@ GPUBatch *DRW_mesh_batch_cache_get_texpaint_loop_wire(Mesh *me)
        return cache->texpaint_uv_loops;
 }
 
-GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(Mesh *me, bool use_wire, bool use_sel)
+GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(Mesh *me, bool use_wire, bool use_sel, bool use_hide)
 {
        MeshBatchCache *cache = mesh_batch_cache_get(me);
 
@@ -5402,7 +5427,7 @@ GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(Mesh *me, bool use_wire,
                MeshRenderData *rdata = mesh_render_data_create(me, datatype);
 
                cache->overlay_paint_edges = GPU_batch_create_ex(
-                       GPU_PRIM_LINES, mesh_create_edge_pos_with_sel(rdata, use_wire, use_sel), NULL, GPU_BATCH_OWNS_VBO);
+                       GPU_PRIM_LINES, mesh_create_edge_pos_with_sel(rdata, use_wire, use_sel, use_hide), NULL, GPU_BATCH_OWNS_VBO);
 
                mesh_render_data_free(rdata);
        }
index bc3e8c9f71608150263d6d0409440786fd8748c0..71365cac470c154b9a80676c3992cfbf989d03c1 100644 (file)
@@ -189,6 +189,24 @@ bool DRW_object_is_flat_normal(const Object *ob)
        return true;
 }
 
+bool DRW_object_use_hide_faces(const struct Object *ob)
+{
+       if (ob->type == OB_MESH) {
+               const Mesh *me = ob->data;
+
+               switch (ob->mode) {
+                       case OB_MODE_TEXTURE_PAINT:
+                       case OB_MODE_VERTEX_PAINT:
+                               return (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
+
+                       case OB_MODE_WEIGHT_PAINT:
+                               return (me->editflag & (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
+               }
+       }
+
+       return false;
+}
+
 bool DRW_object_is_visible_psys_in_active_context(
         const Object *object,
         const ParticleSystem *psys)
index fabff950c60ab22e6c9244ea7d27b139d0211ee3..834a0c0be0b6dedab1b989fce8d417bb348a20c6 100644 (file)
@@ -645,7 +645,7 @@ static void EDIT_MESH_cache_populate(void *vedata, Object *ob)
                        }
 
                        if (do_occlude_wire) {
-                               geom = DRW_cache_mesh_surface_get(ob);
+                               geom = DRW_cache_mesh_surface_get(ob, false);
                                DRW_shgroup_call_add(stl->g_data->depth_shgrp_hidden_wire, geom, ob->obmat);
                        }
 
index 2792c59b8058965a013231c70bafce2a047243f5..10b42c76b14af1617e64199634a284b389923f36 100644 (file)
@@ -291,21 +291,23 @@ static void PAINT_TEXTURE_cache_populate(void *vedata, Object *ob)
                Scene *scene = draw_ctx->scene;
                const bool use_surface = draw_ctx->v3d->overlay.texture_paint_mode_opacity != 0.0; //DRW_object_is_mode_shade(ob) == true;
                const bool use_material_slots = (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_MATERIAL);
+               const bool use_face_sel = (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
                bool ok = false;
 
                if (use_surface) {
                        if (me->mloopuv != NULL) {
-                               if (use_material_slots) {
-                                       struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob) : NULL;
+                               if (use_material_slots || use_face_sel) {
+                                       struct GPUBatch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob, use_face_sel) : NULL;
                                        if ((me->totcol == 0) || (geom_array == NULL)) {
-                                               struct GPUBatch *geom = DRW_cache_mesh_surface_get(ob);
+                                               struct GPUBatch *geom = DRW_cache_mesh_surface_get(ob, use_face_sel);
                                                DRW_shgroup_call_add(stl->g_data->shgroup_fallback, geom, ob->obmat);
                                                ok = true;
                                        }
                                        else {
                                                for (int i = 0; i < me->totcol; i++) {
-                                                       if (stl->g_data->shgroup_image_array[i]) {
-                                                               DRW_shgroup_call_add(stl->g_data->shgroup_image_array[i], geom_array[i], ob->obmat);
+                                                       const int index = use_material_slots ? i : 0;
+                                                       if (stl->g_data->shgroup_image_array[index]) {
+                                                               DRW_shgroup_call_add(stl->g_data->shgroup_image_array[index], geom_array[i], ob->obmat);
                                                        }
                                                        else {
                                                                DRW_shgroup_call_add(stl->g_data->shgroup_fallback, geom_array[i], ob->obmat);
@@ -324,13 +326,12 @@ static void PAINT_TEXTURE_cache_populate(void *vedata, Object *ob)
                        }
 
                        if (!ok) {
-                               struct GPUBatch *geom = DRW_cache_mesh_surface_get(ob);
+                               struct GPUBatch *geom = DRW_cache_mesh_surface_get(ob, use_face_sel);
                                DRW_shgroup_call_add(stl->g_data->shgroup_fallback, geom, ob->obmat);
                        }
                }
 
                /* Face Mask */
-               const bool use_face_sel = (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
                if (use_face_sel) {
                        struct GPUBatch *geom;
                        /* Note: ideally selected faces wouldn't show interior wire. */