[Bf-blender-cvs] [55f38e453c9] greasepencil-refactor: GPencil: Refactor: Edit Mode: Add support for minor features

Clément Foucault noreply at git.blender.org
Tue Jan 7 15:31:49 CET 2020


Commit: 55f38e453c93a6722f5c509150a07dbe4052271f
Author: Clément Foucault
Date:   Tue Jan 7 15:18:40 2020 +0100
Branches: greasepencil-refactor
https://developer.blender.org/rB55f38e453c93a6722f5c509150a07dbe4052271f

GPencil: Refactor: Edit Mode: Add support for minor features

Add support for stroke color, vertex opacity and show stroke endpoints.

===================================================================

M	source/blender/draw/engines/overlay/overlay_gpencil.c
M	source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
M	source/blender/draw/intern/draw_cache_impl_gpencil.c

===================================================================

diff --git a/source/blender/draw/engines/overlay/overlay_gpencil.c b/source/blender/draw/engines/overlay/overlay_gpencil.c
index 27ab937dd7f..2c56d3ba7dd 100644
--- a/source/blender/draw/engines/overlay/overlay_gpencil.c
+++ b/source/blender/draw/engines/overlay/overlay_gpencil.c
@@ -79,6 +79,7 @@ void OVERLAY_edit_gpencil_cache_init(OVERLAY_Data *vedata)
   const bool show_multi_edit_lines = do_multiedit &&
                                      (v3d->gp_flag & V3D_GP_SHOW_MULTIEDIT_LINES) != 0;
 
+  const bool show_lines = (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES);
   const bool hide_lines = GPENCIL_VERTEX_MODE(gpd) && use_vertex_mask && !show_multi_edit_lines;
 
   const bool is_weight_paint = (gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE);
@@ -104,21 +105,24 @@ void OVERLAY_edit_gpencil_cache_init(OVERLAY_Data *vedata)
   }
 
   {
-    DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
+    DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL |
+                     DRW_STATE_BLEND_ALPHA;
     DRW_PASS_CREATE(psl->edit_gpencil_ps, state | pd->clipping_state);
 
+    if (show_lines && !hide_lines) {
+      sh = OVERLAY_shader_edit_gpencil_wire();
+      pd->edit_gpencil_wires_grp = grp = DRW_shgroup_create(sh, psl->edit_gpencil_ps);
+      DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
+      DRW_shgroup_uniform_bool_copy(grp, "doMultiframe", show_multi_edit_lines);
+      DRW_shgroup_uniform_float_copy(grp, "gpEditOpacity", v3d->vertex_opacity);
+    }
+
     if (show_points) {
       sh = OVERLAY_shader_edit_gpencil_point();
       pd->edit_gpencil_points_grp = grp = DRW_shgroup_create(sh, psl->edit_gpencil_ps);
       DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
       DRW_shgroup_uniform_bool_copy(grp, "doMultiframe", do_multiedit);
-    }
-
-    if (!hide_lines) {
-      sh = OVERLAY_shader_edit_gpencil_wire();
-      pd->edit_gpencil_wires_grp = grp = DRW_shgroup_create(sh, psl->edit_gpencil_ps);
-      DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
-      DRW_shgroup_uniform_bool_copy(grp, "doMultiframe", show_multi_edit_lines);
+      DRW_shgroup_uniform_float_copy(grp, "gpEditOpacity", v3d->vertex_opacity);
     }
   }
 }
@@ -126,15 +130,27 @@ void OVERLAY_edit_gpencil_cache_init(OVERLAY_Data *vedata)
 static void OVERLAY_edit_gpencil_cache_populate(OVERLAY_Data *vedata, Object *ob)
 {
   OVERLAY_PrivateData *pd = vedata->stl->pd;
+  bGPdata *gpd = (bGPdata *)ob->data;
+  if (gpd == NULL) {
+    return;
+  }
 
   if (pd->edit_gpencil_wires_grp) {
+    DRWShadingGroup *grp = DRW_shgroup_create_sub(pd->edit_gpencil_wires_grp);
+    DRW_shgroup_uniform_vec4_copy(grp, "gpEditColor", gpd->line_color);
+
     struct GPUBatch *geom = DRW_cache_gpencil_edit_lines_get(ob, pd->cfra);
     DRW_shgroup_call_no_cull(pd->edit_gpencil_wires_grp, geom, ob);
   }
 
   if (pd->edit_gpencil_points_grp) {
+    const bool show_direction = (gpd->flag & GP_DATA_SHOW_DIRECTION) != 0;
+
+    DRWShadingGroup *grp = DRW_shgroup_create_sub(pd->edit_gpencil_points_grp);
+    DRW_shgroup_uniform_float_copy(grp, "doStrokeEndpoints", show_direction);
+
     struct GPUBatch *geom = DRW_cache_gpencil_edit_points_get(ob, pd->cfra);
-    DRW_shgroup_call_no_cull(pd->edit_gpencil_points_grp, geom, ob);
+    DRW_shgroup_call_no_cull(grp, geom, ob);
   }
 }
 
diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
index 9b690090fd0..542db778e46 100644
--- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
+++ b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
@@ -1,6 +1,9 @@
 
 uniform float normalSize;
 uniform bool doMultiframe;
+uniform bool doStrokeEndpoints;
+uniform float gpEditOpacity;
+uniform vec4 gpEditColor;
 
 in vec3 pos;
 in float ma;
@@ -17,6 +20,14 @@ void discard_vert()
 #define GP_EDIT_POINT_SELECTED (1u << 0u)
 #define GP_EDIT_STROKE_SELECTED (1u << 1u)
 #define GP_EDIT_MULTIFRAME (1u << 2u)
+#define GP_EDIT_STROKE_START (1u << 3u)
+#define GP_EDIT_STROKE_END (1u << 4u)
+
+#ifdef USE_POINTS
+#  define colorUnselect colorGpencilVertex
+#else
+#  define colorUnselect gpEditColor
+#endif
 
 void main()
 {
@@ -28,11 +39,27 @@ void main()
   bool is_multiframe = (vflag & GP_EDIT_MULTIFRAME) != 0u;
   bool is_stroke_sel = (vflag & GP_EDIT_STROKE_SELECTED) != 0u;
   bool is_point_sel = (vflag & GP_EDIT_POINT_SELECTED) != 0u;
-  finalColor = ((vflag & GP_EDIT_POINT_SELECTED) != 0u) ? colorGpencilVertexSelect :
-                                                          colorGpencilVertex;
+  finalColor = (is_point_sel) ? colorGpencilVertexSelect : colorUnselect;
+  finalColor.a *= gpEditOpacity;
 
 #ifdef USE_POINTS
-  if ((!doMultiframe || !is_stroke_sel) && is_multiframe) {
+  gl_PointSize = sizeVertex * 2.0;
+
+  if (doStrokeEndpoints) {
+    bool is_stroke_start = (vflag & GP_EDIT_STROKE_START) != 0u;
+    bool is_stroke_end = (vflag & GP_EDIT_STROKE_END) != 0u;
+
+    if (is_stroke_start) {
+      gl_PointSize *= 2.0;
+      finalColor.rgb = vec3(0.0, 1.0, 0.0);
+    }
+    else if (is_stroke_end) {
+      gl_PointSize *= 1.5;
+      finalColor.rgb = vec3(1.0, 0.0, 0.0);
+    }
+  }
+
+  if (!is_stroke_sel || (!doMultiframe && is_multiframe)) {
     discard_vert();
   }
 #endif
@@ -41,8 +68,6 @@ void main()
     discard_vert();
   }
 
-  gl_PointSize = sizeVertex * 2.0;
-
 #ifdef USE_WORLD_CLIP_PLANES
   world_clip_planes_calc_clip_distance(world_pos);
 #endif
diff --git a/source/blender/draw/intern/draw_cache_impl_gpencil.c b/source/blender/draw/intern/draw_cache_impl_gpencil.c
index 66fdaaf93a7..09a61ffe509 100644
--- a/source/blender/draw/intern/draw_cache_impl_gpencil.c
+++ b/source/blender/draw/intern/draw_cache_impl_gpencil.c
@@ -24,8 +24,10 @@
 #include "BLI_polyfill_2d.h"
 
 #include "DNA_gpencil_types.h"
+#include "DNA_meshdata_types.h"
 #include "DNA_screen_types.h"
 
+#include "BKE_deform.h"
 #include "BKE_gpencil.h"
 
 #include "DRW_engine.h"
@@ -239,17 +241,24 @@ static GPUVertFormat *gpencil_stroke_format(void)
     GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
     GPU_vertformat_attr_add(&format, "col", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
     GPU_vertformat_attr_add(&format, "uv", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
-    /* IMPORTANT: This means having only 4 attributes to fit into opengl limit of 16 attrib. */
+    /* IMPORTANT: This means having only 4 attributes to fit into GPU module limit of 16 attrib. */
     GPU_vertformat_multiload_enable(&format, 4);
   }
   return &format;
 }
 
+/* MUST match the format below. */
+typedef struct gpEditVert {
+  int vflag;
+  float weight;
+} gpEditVert;
+
 static GPUVertFormat *gpencil_edit_stroke_format(void)
 {
   static GPUVertFormat format = {0};
   if (format.attr_len == 0) {
     GPU_vertformat_attr_add(&format, "vflag", GPU_COMP_U32, 1, GPU_FETCH_INT);
+    GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
   }
   return &format;
 }
@@ -527,10 +536,26 @@ bool DRW_cache_gpencil_sbuffer_get(Object *ob,
 #define GP_EDIT_POINT_SELECTED (1 << 0)
 #define GP_EDIT_STROKE_SELECTED (1 << 1)
 #define GP_EDIT_MULTIFRAME (1 << 2)
+#define GP_EDIT_STROKE_START (1 << 3)
+#define GP_EDIT_STROKE_END (1 << 4)
+
+typedef struct gpEditIterData {
+  gpEditVert *verts;
+  int vgindex;
+} gpEditIterData;
 
-static uint32_t gpencil_point_edit_flag(const bGPDspoint *pt)
+static uint32_t gpencil_point_edit_flag(const bGPDspoint *pt, int v, int v_len)
 {
-  return (pt->flag & GP_SPOINT_SELECT) ? GP_EDIT_POINT_SELECTED : 0;
+  uint32_t sflag = 0;
+  SET_FLAG_FROM_TEST(sflag, pt->flag & GP_SPOINT_SELECT, GP_EDIT_POINT_SELECTED);
+  SET_FLAG_FROM_TEST(sflag, v == 0, GP_EDIT_STROKE_START);
+  SET_FLAG_FROM_TEST(sflag, v == (v_len - 1), GP_EDIT_STROKE_END);
+  return sflag;
+}
+
+static float gpencil_point_edit_weight(const MDeformVert *dvert, int v, int vgindex)
+{
+  return (dvert && dvert->dw) ? defvert_find_weight(&dvert[v], vgindex) : 0.0f;
 }
 
 static void gpencil_edit_stroke_iter_cb(bGPDlayer *UNUSED(gpl),
@@ -538,19 +563,24 @@ static void gpencil_edit_stroke_iter_cb(bGPDlayer *UNUSED(gpl),
                                         bGPDstroke *gps,
                                         void *thunk)
 {
-  uint32_t *vflag_ptr = (uint32_t *)thunk;
+  gpEditIterData *iter = (gpEditIterData *)thunk;
   const int v_len = gps->totpoints;
   const int v = gps->runtime.stroke_start + 1;
+  MDeformVert *dvert = ((iter->vgindex > -1) && gps->dvert) ? gps->dvert : NULL;
+  gpEditVert *vert_ptr = iter->verts + v;
 
   uint32_t sflag = 0;
   SET_FLAG_FROM_TEST(sflag, gps->flag & GP_STROKE_SELECT, GP_EDIT_STROKE_SELECTED);
   SET_FLAG_FROM_TEST(sflag, gpf->runtime.onion_id != 0.0f, GP_EDIT_MULTIFRAME);
 
   for (int i = 0; i < v_len; i++) {
-    vflag_ptr[v + i] = sflag | gpencil_point_edit_flag(&gps->points[i]);
+    vert_ptr->vflag = sflag | gpencil_point_edit_flag(&gps->points[i], i, v_len);
+    vert_ptr->weight = gpencil_point_edit_weight(dvert, i, iter->vgindex);
+    vert_ptr++;
   }
   /* Draw line to first point to complete the loop for cyclic strokes. */
-  vflag_ptr[v + v_len] = sflag | gpencil_point_edit_flag(&gps->points[0]);
+  vert_ptr->vflag = sflag | gpencil_point_edit_flag(&gps->points[0], 0, v_len);
+  vert_ptr->weight = gpencil_point_edit_weight(dvert, 0, iter->vgindex);
 }
 
 static void gpencil_edit_batches_ensure(Object *ob, GpencilBatchCache *cache, int cfra)
@@ -569,16 +599,21 @@ static void gpencil_edit_batches_ensure(Object *ob, GpencilBatchCache *cache, in
     BLI_assert(cache->vbo);
     int vert_len = cache->vbo->vertex_len;
 
+    gpEditIterData iter;
+    iter.vgindex = ob->actdef - 1;
+    if (!BLI_findlink(&ob->defbase, iter.vgindex)) {
+      iter.vgindex = -1;
+    }
+
     /* Create VBO. */
     GPUVertFormat *format = gpencil_edit_stroke_format();
     cache->edit_vbo = GPU_vertbuf_create_with_format(format);
     /* Add extra space at the end of the buffer because of quad load. */
     GPU_vertbuf_data_alloc(cache->edit_vbo, vert_len);
-    uint32_t *vflag_ptr = (uint3

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list