DepsGraph: Multi ViewLayer Selection
[blender.git] / source / blender / draw / engines / gpencil / gpencil_engine.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * Copyright 2017, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw
21  */
22
23 #ifndef __GPENCIL_ENGINE_H__
24 #define __GPENCIL_ENGINE_H__
25
26 #include "GPU_batch.h"
27
28 struct GPENCIL_Data;
29 struct GPENCIL_StorageList;
30 struct MaterialGPencilStyle;
31 struct ModifierData;
32 struct Object;
33 struct RenderEngine;
34 struct RenderLayer;
35 struct bGPDstroke;
36 struct tGPspoint;
37
38 #define GPENCIL_CACHE_BLOCK_SIZE 8
39 #define GPENCIL_MAX_SHGROUPS 65536
40 #define GPENCIL_GROUPS_BLOCK_SIZE 1024
41
42 /* used to expand VBOs. Size has a big impact in the speed */
43 #define GPENCIL_VBO_BLOCK_SIZE 128
44
45 #define GPENCIL_COLOR_SOLID 0
46 #define GPENCIL_COLOR_TEXTURE 1
47 #define GPENCIL_COLOR_PATTERN 2
48
49 #define GP_SIMPLIFY(scene) ((scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_ENABLE))
50 #define GP_SIMPLIFY_ONPLAY(playing) \
51   (((playing == true) && (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_ON_PLAY)) || \
52    ((scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_ON_PLAY) == 0))
53 #define GP_SIMPLIFY_FILL(scene, playing) \
54   ((GP_SIMPLIFY_ONPLAY(playing) && (GP_SIMPLIFY(scene)) && \
55     (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_FILL)))
56 #define GP_SIMPLIFY_MODIF(scene, playing) \
57   ((GP_SIMPLIFY_ONPLAY(playing) && (GP_SIMPLIFY(scene)) && \
58     (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_MODIFIER)))
59 #define GP_SIMPLIFY_FX(scene, playing) \
60   ((GP_SIMPLIFY_ONPLAY(playing) && (GP_SIMPLIFY(scene)) && \
61     (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_FX)))
62 #define GP_SIMPLIFY_BLEND(scene, playing) \
63   ((GP_SIMPLIFY_ONPLAY(playing) && (GP_SIMPLIFY(scene)) && \
64     (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_BLEND)))
65
66 #define GP_IS_CAMERAVIEW ((rv3d != NULL) && (rv3d->persp == RV3D_CAMOB && v3d->camera))
67
68 /* *********** OBJECTS CACHE *********** */
69 typedef struct tGPencilObjectCache_shgrp {
70   int mode;
71   bool clamp_layer;
72   float blend_opacity;
73   DRWShadingGroup *init_shgrp;
74   DRWShadingGroup *end_shgrp;
75 } tGPencilObjectCache_shgrp;
76
77 /* used to save gpencil object data for drawing */
78 typedef struct tGPencilObjectCache {
79   struct Object *ob;
80   struct bGPdata *gpd;
81   int idx; /*original index, can change after sort */
82   char *name;
83
84   /* effects */
85   bool has_fx;
86   ListBase shader_fx;
87   float pixfactor;
88   DRWShadingGroup *fx_wave_sh;
89   DRWShadingGroup *fx_blur_sh;
90   DRWShadingGroup *fx_colorize_sh;
91   DRWShadingGroup *fx_pixel_sh;
92   DRWShadingGroup *fx_rim_sh;
93   DRWShadingGroup *fx_shadow_sh;
94   DRWShadingGroup *fx_glow_sh;
95   DRWShadingGroup *fx_swirl_sh;
96   DRWShadingGroup *fx_flip_sh;
97   DRWShadingGroup *fx_light_sh;
98
99   float loc[3];
100   float obmat[4][4];
101   float zdepth;   /* z-depth value to sort gp object */
102   bool is_dup_ob; /* flag to tag duplicate objects */
103   float scale;
104
105   /* shading type */
106   int shading_type[2];
107
108   /* GPU data size */
109   int tot_vertex;
110   int tot_triangles;
111
112   /* Save shader groups by layer */
113   int tot_layers;
114   tGPencilObjectCache_shgrp *shgrp_array;
115
116 } tGPencilObjectCache;
117
118 /* *********** LISTS *********** */
119 typedef struct GPENCIL_shgroup {
120   int s_clamp;
121   int stroke_style;
122   int color_type;
123   int mode;
124   int texture_mix;
125   int texture_flip;
126   int texture_clamp;
127   int fill_style;
128   int keep_size;
129   int caps_mode[2];
130   float obj_scale;
131   int xray_mode;
132   int use_follow_path;
133
134   float gradient_f;
135   float gradient_s[2];
136
137   float mix_stroke_factor;
138
139   /* color of the wireframe */
140   float wire_color[4];
141   /* shading type and mode */
142   int shading_type[2];
143   int is_xray;
144 } GPENCIL_shgroup;
145
146 typedef struct GPENCIL_Storage {
147   int shgroup_id; /* total elements */
148   float unit_matrix[4][4];
149   int stroke_style;
150   int color_type;
151   int mode;
152   int xray;
153   int keep_size;
154   float obj_scale;
155   float pixfactor;
156   bool is_playing;
157   bool is_render;
158   bool is_mat_preview;
159   int is_xray;
160   bool reset_cache;
161   bool buffer_stroke;
162   bool buffer_fill;
163   bool buffer_ctrlpoint;
164   const float *pixsize;
165   float render_pixsize;
166   int tonemapping;
167   int do_select_outline;
168   float select_color[4];
169   short multisamples;
170
171   short framebuffer_flag; /* flag what framebuffer need to create */
172
173   int blend_mode;
174   int clamp_layer;
175   float blend_opacity;
176
177   /* simplify settings*/
178   bool simplify_fill;
179   bool simplify_modif;
180   bool simplify_fx;
181   bool simplify_blend;
182
183   float gradient_f;
184   float gradient_s[2];
185   int use_follow_path;
186
187   float mix_stroke_factor;
188
189   /* Render Matrices and data */
190   float persmat[4][4], persinv[4][4];
191   float viewmat[4][4], viewinv[4][4];
192   float winmat[4][4], wininv[4][4];
193   float view_vecs[2][4]; /* vec4[2] */
194
195   float grid_matrix[4][4];
196   int shade_render[2];
197
198   Object *camera; /* camera pointer for render mode */
199 } GPENCIL_Storage;
200
201 typedef enum eGpencilFramebuffer_Flag {
202   GP_FRAMEBUFFER_MULTISAMPLE = (1 << 0),
203   GP_FRAMEBUFFER_BASIC = (1 << 1),
204   GP_FRAMEBUFFER_DRAW = (1 << 2),
205 } eGpencilFramebuffer_Flag;
206
207 typedef struct GPENCIL_StorageList {
208   struct GPENCIL_Storage *storage;
209   struct g_data *g_data;
210   struct GPENCIL_shgroup *shgroups;
211 } GPENCIL_StorageList;
212
213 typedef struct GPENCIL_PassList {
214   struct DRWPass *stroke_pass_2d;
215   struct DRWPass *stroke_pass_3d;
216   struct DRWPass *edit_pass;
217   struct DRWPass *drawing_pass;
218   struct DRWPass *mix_pass;
219   struct DRWPass *mix_pass_noblend;
220   struct DRWPass *background_pass;
221   struct DRWPass *paper_pass;
222   struct DRWPass *grid_pass;
223   struct DRWPass *blend_pass;
224
225   /* effects */
226   struct DRWPass *fx_shader_pass;
227   struct DRWPass *fx_shader_pass_blend;
228
229 } GPENCIL_PassList;
230
231 typedef struct GPENCIL_FramebufferList {
232   struct GPUFrameBuffer *main;
233   struct GPUFrameBuffer *temp_fb_a;
234   struct GPUFrameBuffer *temp_fb_b;
235   struct GPUFrameBuffer *temp_fb_fx;
236   struct GPUFrameBuffer *background_fb;
237
238   struct GPUFrameBuffer *multisample_fb;
239 } GPENCIL_FramebufferList;
240
241 typedef struct GPENCIL_TextureList {
242   struct GPUTexture *texture;
243
244   /* multisample textures */
245   struct GPUTexture *multisample_color;
246   struct GPUTexture *multisample_depth;
247
248 } GPENCIL_TextureList;
249
250 typedef struct GPENCIL_Data {
251   void *engine_type; /* Required */
252   struct GPENCIL_FramebufferList *fbl;
253   struct GPENCIL_TextureList *txl;
254   struct GPENCIL_PassList *psl;
255   struct GPENCIL_StorageList *stl;
256
257   /* render textures */
258   struct GPUTexture *render_depth_tx;
259   struct GPUTexture *render_color_tx;
260
261 } GPENCIL_Data;
262
263 /* *********** STATIC *********** */
264 typedef struct g_data {
265   struct DRWShadingGroup *shgrps_edit_point;
266   struct DRWShadingGroup *shgrps_edit_line;
267   struct DRWShadingGroup *shgrps_drawing_stroke;
268   struct DRWShadingGroup *shgrps_drawing_fill;
269   struct DRWShadingGroup *shgrps_grid;
270
271   int gp_cache_used; /* total objects in cache */
272   int gp_cache_size; /* size of the cache */
273   struct tGPencilObjectCache *gp_object_cache;
274
275   int session_flag;
276   bool do_instances;
277
278 } g_data; /* Transient data */
279
280 /* flags for fast drawing support */
281 typedef enum eGPsession_Flag {
282   GP_DRW_PAINT_HOLD = (1 << 0),
283   GP_DRW_PAINT_IDLE = (1 << 1),
284   GP_DRW_PAINT_FILLING = (1 << 2),
285   GP_DRW_PAINT_READY = (1 << 3),
286   GP_DRW_PAINT_PAINTING = (1 << 4),
287 } eGPsession_Flag;
288
289 typedef struct GPENCIL_e_data {
290   /* general drawing shaders */
291   struct GPUShader *gpencil_fill_sh;
292   struct GPUShader *gpencil_stroke_sh;
293   struct GPUShader *gpencil_point_sh;
294   struct GPUShader *gpencil_edit_point_sh;
295   struct GPUShader *gpencil_line_sh;
296   struct GPUShader *gpencil_drawing_fill_sh;
297   struct GPUShader *gpencil_fullscreen_sh;
298   struct GPUShader *gpencil_simple_fullscreen_sh;
299   struct GPUShader *gpencil_blend_fullscreen_sh;
300   struct GPUShader *gpencil_background_sh;
301   struct GPUShader *gpencil_paper_sh;
302
303   /* effects */
304   struct GPUShader *gpencil_fx_blur_sh;
305   struct GPUShader *gpencil_fx_colorize_sh;
306   struct GPUShader *gpencil_fx_flip_sh;
307   struct GPUShader *gpencil_fx_glow_prepare_sh;
308   struct GPUShader *gpencil_fx_glow_resolve_sh;
309   struct GPUShader *gpencil_fx_light_sh;
310   struct GPUShader *gpencil_fx_pixel_sh;
311   struct GPUShader *gpencil_fx_rim_prepare_sh;
312   struct GPUShader *gpencil_fx_rim_resolve_sh;
313   struct GPUShader *gpencil_fx_shadow_prepare_sh;
314   struct GPUShader *gpencil_fx_shadow_resolve_sh;
315   struct GPUShader *gpencil_fx_swirl_sh;
316   struct GPUShader *gpencil_fx_wave_sh;
317
318   /* textures */
319   struct GPUTexture *background_depth_tx;
320   struct GPUTexture *background_color_tx;
321
322   struct GPUTexture *gpencil_blank_texture;
323
324   /* runtime pointers texture */
325   struct GPUTexture *input_depth_tx;
326   struct GPUTexture *input_color_tx;
327
328   /* working textures */
329   struct GPUTexture *temp_color_tx_a;
330   struct GPUTexture *temp_depth_tx_a;
331
332   struct GPUTexture *temp_color_tx_b;
333   struct GPUTexture *temp_depth_tx_b;
334
335   struct GPUTexture *temp_color_tx_fx;
336   struct GPUTexture *temp_depth_tx_fx;
337
338   /* for buffer only one batch is nedeed because the drawing is only of one stroke */
339   GPUBatch *batch_buffer_stroke;
340   GPUBatch *batch_buffer_fill;
341   GPUBatch *batch_buffer_ctrlpoint;
342
343   /* grid geometry */
344   GPUBatch *batch_grid;
345
346 } GPENCIL_e_data; /* Engine data */
347
348 /* GPUBatch Cache */
349 typedef struct GpencilBatchCacheElem {
350   GPUBatch *batch;
351   GPUVertBuf *vbo;
352   int vbo_len;
353   /* attr ids */
354   GPUVertFormat format;
355   uint pos_id;
356   uint color_id;
357   uint thickness_id;
358   uint uvdata_id;
359   uint prev_pos_id;
360
361   /* size for VBO alloc */
362   int tot_vertex;
363 } GpencilBatchCacheElem;
364
365 typedef struct GpencilBatchGroup {
366   bGPDlayer *gpl;  /* reference to original layer */
367   bGPDframe *gpf;  /* reference to original frame */
368   bGPDstroke *gps; /* reference to original stroke */
369   short type;      /* type of element */
370   bool onion;      /* the group is part of onion skin */
371   int vertex_idx;  /* index of vertex data */
372 } GpencilBatchGroup;
373
374 typedef enum GpencilBatchGroup_Type {
375   eGpencilBatchGroupType_Stroke = 1,
376   eGpencilBatchGroupType_Point = 2,
377   eGpencilBatchGroupType_Fill = 3,
378   eGpencilBatchGroupType_Edit = 4,
379   eGpencilBatchGroupType_Edlin = 5,
380 } GpencilBatchGroup_Type;
381
382 typedef struct GpencilBatchCache {
383   GpencilBatchCacheElem b_stroke;
384   GpencilBatchCacheElem b_point;
385   GpencilBatchCacheElem b_fill;
386   GpencilBatchCacheElem b_edit;
387   GpencilBatchCacheElem b_edlin;
388
389   /* settings to determine if cache is invalid */
390   bool is_dirty;
391   bool is_editmode;
392   int cache_frame;
393
394   /* data with the shading groups */
395   int grp_used;                        /* total groups in arrays */
396   int grp_size;                        /* max size of the array */
397   struct GpencilBatchGroup *grp_cache; /* array of elements */
398
399   int tot_layers;
400   struct bGPDframe *derived_array; /* runtime data created by modifiers */
401 } GpencilBatchCache;
402
403 /* general drawing functions */
404 struct DRWShadingGroup *DRW_gpencil_shgroup_stroke_create(struct GPENCIL_e_data *e_data,
405                                                           struct GPENCIL_Data *vedata,
406                                                           struct DRWPass *pass,
407                                                           struct GPUShader *shader,
408                                                           struct Object *ob,
409                                                           struct bGPdata *gpd,
410                                                           struct bGPDlayer *gpl,
411                                                           struct bGPDstroke *gps,
412                                                           struct MaterialGPencilStyle *gp_style,
413                                                           int id,
414                                                           bool onion,
415                                                           const float scale,
416                                                           const int shading_type[2]);
417 void DRW_gpencil_populate_datablock(struct GPENCIL_e_data *e_data,
418                                     void *vedata,
419                                     struct Object *ob,
420                                     struct tGPencilObjectCache *cache_ob);
421 void DRW_gpencil_populate_buffer_strokes(struct GPENCIL_e_data *e_data,
422                                          void *vedata,
423                                          struct ToolSettings *ts,
424                                          struct Object *ob);
425 void DRW_gpencil_populate_multiedit(struct GPENCIL_e_data *e_data,
426                                     void *vedata,
427                                     struct Object *ob,
428                                     struct tGPencilObjectCache *cache_ob);
429 void DRW_gpencil_triangulate_stroke_fill(struct Object *ob, struct bGPDstroke *gps);
430 void DRW_gpencil_populate_particles(struct GPENCIL_e_data *e_data,
431                                     struct GHash *gh_objects,
432                                     void *vedata);
433
434 void DRW_gpencil_multisample_ensure(struct GPENCIL_Data *vedata, int rect_w, int rect_h);
435
436 /* create geometry functions */
437 void DRW_gpencil_get_point_geom(struct GpencilBatchCacheElem *be,
438                                 struct bGPDstroke *gps,
439                                 short thickness,
440                                 const float ink[4]);
441 void DRW_gpencil_get_stroke_geom(struct GpencilBatchCacheElem *be,
442                                  struct bGPDstroke *gps,
443                                  short thickness,
444                                  const float ink[4]);
445 void DRW_gpencil_get_fill_geom(struct GpencilBatchCacheElem *be,
446                                struct Object *ob,
447                                struct bGPDstroke *gps,
448                                const float color[4]);
449 void DRW_gpencil_get_edit_geom(struct GpencilBatchCacheElem *be,
450                                struct bGPDstroke *gps,
451                                float alpha,
452                                short dflag);
453 void DRW_gpencil_get_edlin_geom(struct GpencilBatchCacheElem *be,
454                                 struct bGPDstroke *gps,
455                                 float alpha,
456                                 short dflag);
457
458 struct GPUBatch *DRW_gpencil_get_buffer_stroke_geom(struct bGPdata *gpd, short thickness);
459 struct GPUBatch *DRW_gpencil_get_buffer_fill_geom(struct bGPdata *gpd);
460 struct GPUBatch *DRW_gpencil_get_buffer_point_geom(struct bGPdata *gpd, short thickness);
461 struct GPUBatch *DRW_gpencil_get_buffer_ctrlpoint_geom(struct bGPdata *gpd);
462 struct GPUBatch *DRW_gpencil_get_grid(Object *ob);
463
464 /* object cache functions */
465 struct tGPencilObjectCache *gpencil_object_cache_add(struct tGPencilObjectCache *cache_array,
466                                                      struct Object *ob,
467                                                      int *gp_cache_size,
468                                                      int *gp_cache_used);
469
470 bool DRW_gpencil_onion_active(struct bGPdata *gpd);
471
472 /* shading groups cache functions */
473 struct GpencilBatchGroup *gpencil_group_cache_add(struct GpencilBatchGroup *cache_array,
474                                                   struct bGPDlayer *gpl,
475                                                   struct bGPDframe *gpf,
476                                                   struct bGPDstroke *gps,
477                                                   const short type,
478                                                   const bool onion,
479                                                   const int vertex_idx,
480                                                   int *grp_size,
481                                                   int *grp_used);
482
483 /* geometry batch cache functions */
484 struct GpencilBatchCache *gpencil_batch_cache_get(struct Object *ob, int cfra);
485
486 /* effects */
487 void GPENCIL_create_fx_shaders(struct GPENCIL_e_data *e_data);
488 void GPENCIL_delete_fx_shaders(struct GPENCIL_e_data *e_data);
489 void GPENCIL_create_fx_passes(struct GPENCIL_PassList *psl);
490
491 void DRW_gpencil_fx_prepare(struct GPENCIL_e_data *e_data,
492                             struct GPENCIL_Data *vedata,
493                             struct tGPencilObjectCache *cache_ob);
494 void DRW_gpencil_fx_draw(struct GPENCIL_e_data *e_data,
495                          struct GPENCIL_Data *vedata,
496                          struct tGPencilObjectCache *cache_ob);
497
498 /* main functions */
499 void GPENCIL_engine_init(void *vedata);
500 void GPENCIL_cache_init(void *vedata);
501 void GPENCIL_cache_populate(void *vedata, struct Object *ob);
502 void GPENCIL_cache_finish(void *vedata);
503 void GPENCIL_draw_scene(void *vedata);
504
505 /* render */
506 void GPENCIL_render_init(struct GPENCIL_Data *ved,
507                          struct RenderEngine *engine,
508                          struct Depsgraph *depsgraph);
509 void GPENCIL_render_to_image(void *vedata,
510                              struct RenderEngine *engine,
511                              struct RenderLayer *render_layer,
512                              const rcti *rect);
513
514 /* Use of multisample framebuffers. */
515 #define MULTISAMPLE_GP_SYNC_ENABLE(lvl, fbl) \
516   { \
517     if ((lvl > 0) && (fbl->multisample_fb != NULL)) { \
518       DRW_stats_query_start("GP Multisample Blit"); \
519       GPU_framebuffer_bind(fbl->multisample_fb); \
520       GPU_framebuffer_clear_color_depth(fbl->multisample_fb, (const float[4]){0.0f}, 1.0f); \
521       DRW_stats_query_end(); \
522     } \
523   } \
524   ((void)0)
525
526 #define MULTISAMPLE_GP_SYNC_DISABLE(lvl, fbl, fb, txl) \
527   { \
528     if ((lvl > 0) && (fbl->multisample_fb != NULL)) { \
529       DRW_stats_query_start("GP Multisample Resolve"); \
530       GPU_framebuffer_bind(fb); \
531       DRW_multisamples_resolve(txl->multisample_depth, txl->multisample_color, true); \
532       DRW_stats_query_end(); \
533     } \
534   } \
535   ((void)0)
536
537 #define GPENCIL_3D_DRAWMODE(ob, gpd) \
538   ((gpd) && (gpd->draw_mode == GP_DRAWMODE_3D) && ((ob->dtx & OB_DRAWXRAY) == 0))
539
540 #define GPENCIL_USE_SOLID(stl) \
541   ((stl) && ((stl->storage->is_render) || (stl->storage->is_mat_preview)))
542
543 #endif /* __GPENCIL_ENGINE_H__ */