Commit: 608504351df5894ba3614e4b8d0a747b7e60ebb2
Author: Antonioya
Date:   Tue Dec 11 13:02:55 2018 +0100
Branches: greasepencil-object
https://developer.blender.org/rB608504351df5894ba3614e4b8d0a747b7e60ebb2

GP: Move drawing of control points to Draw Manager

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

M       source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c
M       source/blender/draw/engines/gpencil/gpencil_draw_utils.c
M       source/blender/draw/engines/gpencil/gpencil_engine.c
M       source/blender/draw/engines/gpencil/gpencil_engine.h
M       source/blender/editors/gpencil/drawgpencil.c
M       source/blender/editors/gpencil/gpencil_intern.h
M       source/blender/editors/gpencil/gpencil_primitive.c

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

diff --git a/source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c 
b/source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c
index 0f9ea009699..82c62684e3f 100644
--- a/source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c
+++ b/source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c
@@ -384,6 +384,47 @@ GPUBatch *DRW_gpencil_get_buffer_point_geom(bGPdata *gpd, 
short thickness)
        return GPU_batch_create_ex(GPU_PRIM_POINTS, vbo, NULL, 
GPU_BATCH_OWNS_VBO);
 }
 
+/* create batch geometry data for current buffer control point shader */
+GPUBatch *DRW_gpencil_get_buffer_ctrlpoint_geom(bGPdata *gpd)
+{
+       bGPDcontrolpoint *cps = gpd->runtime.cp_points;
+       int totpoints = gpd->runtime.tot_cp_points;
+
+       static GPUVertFormat format = { 0 };
+       static uint pos_id, color_id, thickness_id, uvdata_id;
+       if (format.attr_len == 0) {
+               pos_id = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 
3, GPU_FETCH_FLOAT);
+               color_id = GPU_vertformat_attr_add(&format, "color", 
GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
+               thickness_id = GPU_vertformat_attr_add(&format, "thickness", 
GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
+               uvdata_id = GPU_vertformat_attr_add(&format, "uvdata", 
GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+       }
+
+       GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
+       GPU_vertbuf_data_alloc(vbo, totpoints);
+
+       int idx = 0;
+       for (int i = 0; i < gpd->runtime.tot_cp_points; i++) {
+               bGPDcontrolpoint *cp = &cps[i];
+               float color[4];
+               copy_v3_v3(color, cp->color);
+               color[3] = 0.8f;
+               GPU_vertbuf_attr_set(vbo, color_id, idx, color);
+
+               /* transfer both values using the same shader variable */
+               float uvdata[2] = { 0.0f, 0.0f };
+               GPU_vertbuf_attr_set(vbo, uvdata_id, idx, uvdata);
+
+               /* scale size to get more visible points */
+               float size = cp->size * 8.0f;
+               GPU_vertbuf_attr_set(vbo, thickness_id, idx, &size);
+
+               GPU_vertbuf_attr_set(vbo, pos_id, idx, &cp->x);
+               idx++;
+       }
+
+       return GPU_batch_create_ex(GPU_PRIM_POINTS, vbo, NULL, 
GPU_BATCH_OWNS_VBO);
+}
+
 /* create batch geometry data for current buffer fill shader */
 GPUBatch *DRW_gpencil_get_buffer_fill_geom(bGPdata *gpd)
 {
diff --git a/source/blender/draw/engines/gpencil/gpencil_draw_utils.c 
b/source/blender/draw/engines/gpencil/gpencil_draw_utils.c
index 590ae825371..c9b4def0124 100644
--- a/source/blender/draw/engines/gpencil/gpencil_draw_utils.c
+++ b/source/blender/draw/engines/gpencil/gpencil_draw_utils.c
@@ -560,6 +560,39 @@ static DRWShadingGroup *DRW_gpencil_shgroup_point_create(
        return grp;
 }
 
+/* create shading group for control points */
+static DRWShadingGroup *DRW_gpencil_shgroup_ctrlpoint_create(
+       GPENCIL_e_data *e_data, GPENCIL_Data *vedata, DRWPass *pass, GPUShader 
*shader, Object *ob,
+       bGPdata *gpd)
+{
+       GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
+       const float *viewport_size = DRW_viewport_size_get();
+
+       /* e_data.gpencil_stroke_sh */
+       DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
+
+       DRW_shgroup_uniform_vec2(grp, "Viewport", viewport_size, 1);
+       DRW_shgroup_uniform_float(grp, "pixsize", stl->storage->pixsize, 1);
+
+       stl->storage->obj_scale = 1.0f;
+       stl->storage->keep_size = 0;
+       stl->storage->pixfactor = GP_DEFAULT_PIX_FACTOR;
+       stl->storage->mode = GP_STYLE_STROKE_STYLE_SOLID;
+       DRW_shgroup_uniform_float(grp, "objscale", &stl->storage->obj_scale, 1);
+       const int keep = 1;
+       DRW_shgroup_uniform_int(grp, "keep_size", &keep, 1);
+       DRW_shgroup_uniform_int(grp, "color_type", &stl->storage->color_type, 
1);
+       DRW_shgroup_uniform_int(grp, "mode", &stl->storage->mode, 1);
+       DRW_shgroup_uniform_float(grp, "pixfactor", &stl->storage->pixfactor, 
1);
+
+       /* for drawing always on on predefined z-depth */
+       DRW_shgroup_uniform_int(grp, "xraymode", &stl->storage->xray, 1);
+
+       DRW_shgroup_uniform_texture(grp, "myTexture", 
e_data->gpencil_blank_texture);
+
+       return grp;
+}
+
 /* add fill vertex info  */
 static void gpencil_add_fill_vertexdata(
         GpencilBatchCache *cache,
@@ -1194,11 +1227,11 @@ void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data 
*e_data, void *vedata, T
                        if (gpd->runtime.sbuffer_size > 1) {
                                if ((gp_style) && (gp_style->mode == 
GP_STYLE_MODE_LINE)) {
                                        stl->g_data->shgrps_drawing_stroke = 
DRW_gpencil_shgroup_stroke_create(
-                                               e_data, vedata, 
psl->drawing_pass, e_data->gpencil_stroke_sh, NULL, gpd, gp_style, -1, false);
+                                               e_data, vedata, 
psl->drawing_pass, e_data->gpencil_stroke_sh, NULL, gpd, gp_style, -1, false);
                                }
                                else {
                                        stl->g_data->shgrps_drawing_stroke = 
DRW_gpencil_shgroup_point_create(
-                                               e_data, vedata, 
psl->drawing_pass, e_data->gpencil_point_sh, NULL, gpd, gp_style, -1, false);
+                                               e_data, vedata, 
psl->drawing_pass, e_data->gpencil_point_sh, NULL, gpd, gp_style, -1, false);
                                }
 
                                /* clean previous version of the batch */
@@ -1211,32 +1244,32 @@ void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data 
*e_data, void *vedata, T
                                /* use unit matrix because the buffer is in 
screen space and does not need conversion */
                                if (gpd->runtime.mode == GP_STYLE_MODE_LINE) {
                                        e_data->batch_buffer_stroke = 
DRW_gpencil_get_buffer_stroke_geom(
-                                               gpd, lthick);
+                                               gpd, lthick);
                                }
                                else {
                                        e_data->batch_buffer_stroke = 
DRW_gpencil_get_buffer_point_geom(
-                                               gpd, lthick);
+                                               gpd, lthick);
                                }
 
                                if (gp_style->flag & GP_STYLE_STROKE_SHOW) {
                                        DRW_shgroup_call_add(
-                                               
stl->g_data->shgrps_drawing_stroke,
-                                               e_data->batch_buffer_stroke,
-                                               stl->storage->unit_matrix);
+                                               
stl->g_data->shgrps_drawing_stroke,
+                                               e_data->batch_buffer_stroke,
+                                               stl->storage->unit_matrix);
                                }
 
                                if ((gpd->runtime.sbuffer_size >= 3) &&
-                                   (gpd->runtime.sfill[3] > 
GPENCIL_ALPHA_OPACITY_THRESH) &&
-                                   ((gpd->runtime.sbuffer_sflag & 
GP_STROKE_NOFILL) == 0) &&
-                                   ((brush->gpencil_settings->flag & 
GP_BRUSH_DISSABLE_LASSO) == 0) &&
-                                   (gp_style->flag & GP_STYLE_FILL_SHOW))
+                                       (gpd->runtime.sfill[3] > 
GPENCIL_ALPHA_OPACITY_THRESH) &&
+                                       ((gpd->runtime.sbuffer_sflag & 
GP_STROKE_NOFILL) == 0) &&
+                                       ((brush->gpencil_settings->flag & 
GP_BRUSH_DISSABLE_LASSO) == 0) &&
+                                       (gp_style->flag & GP_STYLE_FILL_SHOW))
                                {
                                        /* if not solid, fill is simulated with 
solid color */
                                        if (gpd->runtime.bfill_style > 0) {
                                                gpd->runtime.sfill[3] = 0.5f;
                                        }
                                        stl->g_data->shgrps_drawing_fill = 
DRW_shgroup_create(
-                                               
e_data->gpencil_drawing_fill_sh, psl->drawing_pass);
+                                               
e_data->gpencil_drawing_fill_sh, psl->drawing_pass);
 
                                        /* clean previous version of the batch 
*/
                                        if (stl->storage->buffer_fill) {
@@ -1247,15 +1280,40 @@ void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data 
*e_data, void *vedata, T
 
                                        e_data->batch_buffer_fill = 
DRW_gpencil_get_buffer_fill_geom(gpd);
                                        DRW_shgroup_call_add(
-                                               
stl->g_data->shgrps_drawing_fill,
-                                               e_data->batch_buffer_fill,
-                                               stl->storage->unit_matrix);
+                                               
stl->g_data->shgrps_drawing_fill,
+                                               e_data->batch_buffer_fill,
+                                               stl->storage->unit_matrix);
                                        stl->storage->buffer_fill = true;
                                }
                                stl->storage->buffer_stroke = true;
                        }
                }
        }
+
+       /* control points */
+       if ((gpd->runtime.tot_cp_points > 0) &&
+               ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0))
+       {
+
+               DRWShadingGroup *shgrp = DRW_gpencil_shgroup_ctrlpoint_create(
+                       e_data, vedata, psl->drawing_pass, 
e_data->gpencil_point_sh, NULL, gpd);
+
+               /* clean previous version of the batch */
+               if (stl->storage->buffer_ctrlpoint) {
+                       GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_ctrlpoint);
+                       MEM_SAFE_FREE(e_data->batch_buffer_ctrlpoint);
+                       stl->storage->buffer_ctrlpoint = false;
+               }
+
+               e_data->batch_buffer_ctrlpoint = 
DRW_gpencil_get_buffer_ctrlpoint_geom(gpd);
+
+               DRW_shgroup_call_add(
+                       shgrp,
+                       e_data->batch_buffer_ctrlpoint,
+                       stl->storage->unit_matrix);
+
+               stl->storage->buffer_ctrlpoint = true;
+       }
 }
 
 /* create all missing batches */
diff --git a/source/blender/draw/engines/gpencil/gpencil_engine.c 
b/source/blender/draw/engines/gpencil/gpencil_engine.c
index 11da8f8cffe..ad7208cd4be 100644
--- a/source/blender/draw/engines/gpencil/gpencil_engine.c
+++ b/source/blender/draw/engines/gpencil/gpencil_engine.c
@@ -284,6 +284,9 @@ static void GPENCIL_engine_free(void)
        GPU_BATCH_DISCARD_SAFE(e_data.batch_buffer_fill);
        MEM_SAFE_FREE(e_data.batch_buffer_fill);
 
+       GPU_BATCH_DISCARD_SAFE(e_data.batch_buffer_ctrlpoint);
+       MEM_SAFE_FREE(e_data.batch_buffer_ctrlpoint);
+
        GPU_BATCH_DISCARD_SAFE(e_data.batch_grid);
        MEM_SAFE_FREE(e_data.batch_grid);
 
diff --git a/source/blender/draw/engines/gpencil/gpencil_engine.h 
b/source/blender/draw/engines/gpencil/gpencil_engine.h
index 4aaf81ea5fd..0831c4268a3 100644
--- a/source/blender/draw/engines/gpencil/gpencil_engine.h
+++ b/source/blender/draw/engines/gpencil/gpencil_engine.h
@@ -133,6 +133,7 @@ typedef struct GPENCIL_Storage {
        bool reset_cache;
        bool buffer_stroke;
        bool buffer_fill;
+       bool buffer_ctrlpoint;
        const float *pixsize;
        float render_pixsize;
        int tonemapping;
@@ -291,6 +292,7 @@ typedef struct GPENCIL_e_data {
        /* for buffer only one batch is nedeed because the drawing is only of 
one stroke */
        GPUBatch *batch_buffer_stroke;
        GPUBatch *batch_buffer_fill;
+       GPUBatch *batch_buffer_ctrlpoint;
 
        /* grid geometry */
        GPUBatch *batch_grid;
@@ -378,6 +380,7 @@ void DRW_gpencil_get_edlin_geom(struct 
GpencilBatchCacheElem *be, struct bGPDstr
 struct GPUBatch *DRW_gpencil_get_buffer_stroke_geom(struct bGPdata *gpd, short 
thickness);
 struct GPUBatch *DRW_gpencil_get_buffer_fill_geom(struct bGPdata *gpd);
 struct GPUBatch *DRW_gpencil_get_buffer_point_geom(struct bGPdata *gpd, short 
thickness);
+struct GPUBatch *DRW_gpencil_get_buffer_ctrlpoint_geom(struct bGPdata *gpd);
 struct GPUBatch *DRW_gpencil_get_grid(Object *ob);
 
 /* object cache functions */
diff --git a/source/blender/editors/gpencil/drawgpencil.c 
b/source/blender/editors/gpencil/drawgpencil.c
index 9d3d5c2bd8a..3c81bbf2f7f 100644
--- a/source/blender/editors/gpencil/drawgpencil.c
+++ b/source/blender/editors/gpencil/drawgpencil.c
@@ -1430,34 +1430,6 @@ void ED_gp_draw_interpolation(const bContext

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to