GPencil: Cleanup - Remove storage Grid matrix and replace with local variable
[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 alignment_mode;
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 alignment_mode;
186
187   float mix_stroke_factor;
188
189   /* Render Matrices and data */
190   DRWView *view;
191   float view_vecs[2][4]; /* vec4[2] */
192
193   int shade_render[2];
194
195   Object *camera; /* camera pointer for render mode */
196 } GPENCIL_Storage;
197
198 typedef enum eGpencilFramebuffer_Flag {
199   GP_FRAMEBUFFER_MULTISAMPLE = (1 << 0),
200   GP_FRAMEBUFFER_BASIC = (1 << 1),
201   GP_FRAMEBUFFER_DRAW = (1 << 2),
202 } eGpencilFramebuffer_Flag;
203
204 typedef struct GPENCIL_StorageList {
205   struct GPENCIL_Storage *storage;
206   struct g_data *g_data;
207   struct GPENCIL_shgroup *shgroups;
208 } GPENCIL_StorageList;
209
210 typedef struct GPENCIL_PassList {
211   struct DRWPass *stroke_pass_2d;
212   struct DRWPass *stroke_pass_3d;
213   struct DRWPass *edit_pass;
214   struct DRWPass *drawing_pass;
215   struct DRWPass *mix_pass;
216   struct DRWPass *mix_pass_noblend;
217   struct DRWPass *background_pass;
218   struct DRWPass *paper_pass;
219   struct DRWPass *grid_pass;
220   struct DRWPass *blend_pass;
221
222   /* effects */
223   struct DRWPass *fx_shader_pass;
224   struct DRWPass *fx_shader_pass_blend;
225
226 } GPENCIL_PassList;
227
228 typedef struct GPENCIL_FramebufferList {
229   struct GPUFrameBuffer *main;
230   struct GPUFrameBuffer *temp_fb_a;
231   struct GPUFrameBuffer *temp_fb_b;
232   struct GPUFrameBuffer *temp_fb_fx;
233   struct GPUFrameBuffer *background_fb;
234
235   struct GPUFrameBuffer *multisample_fb;
236 } GPENCIL_FramebufferList;
237
238 typedef struct GPENCIL_TextureList {
239   struct GPUTexture *texture;
240
241   /* multisample textures */
242   struct GPUTexture *multisample_color;
243   struct GPUTexture *multisample_depth;
244
245 } GPENCIL_TextureList;
246
247 typedef struct GPENCIL_Data {
248   void *engine_type; /* Required */
249   struct GPENCIL_FramebufferList *fbl;
250   struct GPENCIL_TextureList *txl;
251   struct GPENCIL_PassList *psl;
252   struct GPENCIL_StorageList *stl;
253
254   /* render textures */
255   struct GPUTexture *render_depth_tx;
256   struct GPUTexture *render_color_tx;
257
258 } GPENCIL_Data;
259
260 /* *********** STATIC *********** */
261 typedef struct g_data {
262   struct DRWShadingGroup *shgrps_edit_point;
263   struct DRWShadingGroup *shgrps_edit_line;
264   struct DRWShadingGroup *shgrps_drawing_stroke;
265   struct DRWShadingGroup *shgrps_drawing_fill;
266   struct DRWShadingGroup *shgrps_grid;
267
268   int gp_cache_used; /* total objects in cache */
269   int gp_cache_size; /* size of the cache */
270   struct tGPencilObjectCache *gp_object_cache;
271
272   int session_flag;
273   bool do_instances;
274
275 } g_data; /* Transient data */
276
277 /* flags for fast drawing support */
278 typedef enum eGPsession_Flag {
279   GP_DRW_PAINT_HOLD = (1 << 0),
280   GP_DRW_PAINT_IDLE = (1 << 1),
281   GP_DRW_PAINT_FILLING = (1 << 2),
282   GP_DRW_PAINT_READY = (1 << 3),
283   GP_DRW_PAINT_PAINTING = (1 << 4),
284 } eGPsession_Flag;
285
286 typedef struct GPENCIL_e_data {
287   /* general drawing shaders */
288   struct GPUShader *gpencil_fill_sh;
289   struct GPUShader *gpencil_stroke_sh;
290   struct GPUShader *gpencil_point_sh;
291   struct GPUShader *gpencil_edit_point_sh;
292   struct GPUShader *gpencil_line_sh;
293   struct GPUShader *gpencil_drawing_fill_sh;
294   struct GPUShader *gpencil_fullscreen_sh;
295   struct GPUShader *gpencil_simple_fullscreen_sh;
296   struct GPUShader *gpencil_blend_fullscreen_sh;
297   struct GPUShader *gpencil_background_sh;
298   struct GPUShader *gpencil_paper_sh;
299
300   /* effects */
301   struct GPUShader *gpencil_fx_blur_sh;
302   struct GPUShader *gpencil_fx_colorize_sh;
303   struct GPUShader *gpencil_fx_flip_sh;
304   struct GPUShader *gpencil_fx_glow_prepare_sh;
305   struct GPUShader *gpencil_fx_glow_resolve_sh;
306   struct GPUShader *gpencil_fx_light_sh;
307   struct GPUShader *gpencil_fx_pixel_sh;
308   struct GPUShader *gpencil_fx_rim_prepare_sh;
309   struct GPUShader *gpencil_fx_rim_resolve_sh;
310   struct GPUShader *gpencil_fx_shadow_prepare_sh;
311   struct GPUShader *gpencil_fx_shadow_resolve_sh;
312   struct GPUShader *gpencil_fx_swirl_sh;
313   struct GPUShader *gpencil_fx_wave_sh;
314
315   /* textures */
316   struct GPUTexture *background_depth_tx;
317   struct GPUTexture *background_color_tx;
318
319   struct GPUTexture *gpencil_blank_texture;
320
321   /* runtime pointers texture */
322   struct GPUTexture *input_depth_tx;
323   struct GPUTexture *input_color_tx;
324
325   /* working textures */
326   struct GPUTexture *temp_color_tx_a;
327   struct GPUTexture *temp_depth_tx_a;
328
329   struct GPUTexture *temp_color_tx_b;
330   struct GPUTexture *temp_depth_tx_b;
331
332   struct GPUTexture *temp_color_tx_fx;
333   struct GPUTexture *temp_depth_tx_fx;
334
335   /* for buffer only one batch is nedeed because the drawing is only of one stroke */
336   GPUBatch *batch_buffer_stroke;
337   GPUBatch *batch_buffer_fill;
338   GPUBatch *batch_buffer_ctrlpoint;
339
340   /* grid geometry */
341   GPUBatch *batch_grid;
342
343 } GPENCIL_e_data; /* Engine data */
344
345 /* GPUBatch Cache */
346 typedef struct GpencilBatchCacheElem {
347   GPUBatch *batch;
348   GPUVertBuf *vbo;
349   int vbo_len;
350   /* attr ids */
351   GPUVertFormat format;
352   uint pos_id;
353   uint color_id;
354   uint thickness_id;
355   uint uvdata_id;
356   uint prev_pos_id;
357
358   /* size for VBO alloc */
359   int tot_vertex;
360 } GpencilBatchCacheElem;
361
362 typedef struct GpencilBatchGroup {
363   bGPDlayer *gpl;  /* reference to original layer */
364   bGPDframe *gpf;  /* reference to original frame */
365   bGPDstroke *gps; /* reference to original stroke */
366   short type;      /* type of element */
367   bool onion;      /* the group is part of onion skin */
368   int vertex_idx;  /* index of vertex data */
369 } GpencilBatchGroup;
370
371 typedef enum GpencilBatchGroup_Type {
372   eGpencilBatchGroupType_Stroke = 1,
373   eGpencilBatchGroupType_Point = 2,
374   eGpencilBatchGroupType_Fill = 3,
375   eGpencilBatchGroupType_Edit = 4,
376   eGpencilBatchGroupType_Edlin = 5,
377 } GpencilBatchGroup_Type;
378
379 typedef struct GpencilBatchCache {
380   GpencilBatchCacheElem b_stroke;
381   GpencilBatchCacheElem b_point;
382   GpencilBatchCacheElem b_fill;
383   GpencilBatchCacheElem b_edit;
384   GpencilBatchCacheElem b_edlin;
385
386   /* settings to determine if cache is invalid */
387   bool is_dirty;
388   bool is_editmode;
389   int cache_frame;
390
391   /* data with the shading groups */
392   int grp_used;                        /* total groups in arrays */
393   int grp_size;                        /* max size of the array */
394   struct GpencilBatchGroup *grp_cache; /* array of elements */
395
396   int tot_layers;
397   struct bGPDframe *derived_array; /* runtime data created by modifiers */
398 } GpencilBatchCache;
399
400 /* general drawing functions */
401 struct DRWShadingGroup *DRW_gpencil_shgroup_stroke_create(struct GPENCIL_e_data *e_data,
402                                                           struct GPENCIL_Data *vedata,
403                                                           struct DRWPass *pass,
404                                                           struct GPUShader *shader,
405                                                           struct Object *ob,
406                                                           struct bGPdata *gpd,
407                                                           struct bGPDlayer *gpl,
408                                                           struct bGPDstroke *gps,
409                                                           struct MaterialGPencilStyle *gp_style,
410                                                           int id,
411                                                           bool onion,
412                                                           const float scale,
413                                                           const int shading_type[2]);
414 void DRW_gpencil_populate_datablock(struct GPENCIL_e_data *e_data,
415                                     void *vedata,
416                                     struct Object *ob,
417                                     struct tGPencilObjectCache *cache_ob);
418 void DRW_gpencil_populate_buffer_strokes(struct GPENCIL_e_data *e_data,
419                                          void *vedata,
420                                          struct ToolSettings *ts,
421                                          struct Object *ob);
422 void DRW_gpencil_populate_multiedit(struct GPENCIL_e_data *e_data,
423                                     void *vedata,
424                                     struct Object *ob,
425                                     struct tGPencilObjectCache *cache_ob);
426 void DRW_gpencil_triangulate_stroke_fill(struct Object *ob, struct bGPDstroke *gps);
427 void DRW_gpencil_populate_particles(struct GPENCIL_e_data *e_data,
428                                     struct GHash *gh_objects,
429                                     void *vedata);
430
431 void DRW_gpencil_multisample_ensure(struct GPENCIL_Data *vedata, int rect_w, int rect_h);
432
433 /* create geometry functions */
434 void DRW_gpencil_get_point_geom(struct GpencilBatchCacheElem *be,
435                                 struct bGPDstroke *gps,
436                                 short thickness,
437                                 const float ink[4],
438                                 const int follow_mode);
439 void DRW_gpencil_get_stroke_geom(struct GpencilBatchCacheElem *be,
440                                  struct bGPDstroke *gps,
441                                  short thickness,
442                                  const float ink[4]);
443 void DRW_gpencil_get_fill_geom(struct GpencilBatchCacheElem *be,
444                                struct Object *ob,
445                                struct bGPDstroke *gps,
446                                const float color[4]);
447 void DRW_gpencil_get_edit_geom(struct GpencilBatchCacheElem *be,
448                                struct bGPDstroke *gps,
449                                float alpha,
450                                short dflag);
451 void DRW_gpencil_get_edlin_geom(struct GpencilBatchCacheElem *be,
452                                 struct bGPDstroke *gps,
453                                 float alpha,
454                                 short dflag);
455
456 struct GPUBatch *DRW_gpencil_get_buffer_stroke_geom(struct bGPdata *gpd, short thickness);
457 struct GPUBatch *DRW_gpencil_get_buffer_fill_geom(struct bGPdata *gpd);
458 struct GPUBatch *DRW_gpencil_get_buffer_point_geom(struct bGPdata *gpd, short thickness);
459 struct GPUBatch *DRW_gpencil_get_buffer_ctrlpoint_geom(struct bGPdata *gpd);
460 struct GPUBatch *DRW_gpencil_get_grid(Object *ob);
461
462 /* object cache functions */
463 struct tGPencilObjectCache *gpencil_object_cache_add(struct tGPencilObjectCache *cache_array,
464                                                      struct Object *ob,
465                                                      int *gp_cache_size,
466                                                      int *gp_cache_used);
467
468 bool DRW_gpencil_onion_active(struct bGPdata *gpd);
469
470 /* shading groups cache functions */
471 struct GpencilBatchGroup *gpencil_group_cache_add(struct GpencilBatchGroup *cache_array,
472                                                   struct bGPDlayer *gpl,
473                                                   struct bGPDframe *gpf,
474                                                   struct bGPDstroke *gps,
475                                                   const short type,
476                                                   const bool onion,
477                                                   const int vertex_idx,
478                                                   int *grp_size,
479                                                   int *grp_used);
480
481 /* geometry batch cache functions */
482 struct GpencilBatchCache *gpencil_batch_cache_get(struct Object *ob, int cfra);
483
484 /* effects */
485 void GPENCIL_create_fx_shaders(struct GPENCIL_e_data *e_data);
486 void GPENCIL_delete_fx_shaders(struct GPENCIL_e_data *e_data);
487 void GPENCIL_create_fx_passes(struct GPENCIL_PassList *psl);
488
489 void DRW_gpencil_fx_prepare(struct GPENCIL_e_data *e_data,
490                             struct GPENCIL_Data *vedata,
491                             struct tGPencilObjectCache *cache_ob);
492 void DRW_gpencil_fx_draw(struct GPENCIL_e_data *e_data,
493                          struct GPENCIL_Data *vedata,
494                          struct tGPencilObjectCache *cache_ob);
495
496 /* main functions */
497 void GPENCIL_engine_init(void *vedata);
498 void GPENCIL_cache_init(void *vedata);
499 void GPENCIL_cache_populate(void *vedata, struct Object *ob);
500 void GPENCIL_cache_finish(void *vedata);
501 void GPENCIL_draw_scene(void *vedata);
502
503 /* render */
504 void GPENCIL_render_init(struct GPENCIL_Data *ved,
505                          struct RenderEngine *engine,
506                          struct Depsgraph *depsgraph);
507 void GPENCIL_render_to_image(void *vedata,
508                              struct RenderEngine *engine,
509                              struct RenderLayer *render_layer,
510                              const rcti *rect);
511
512 /* Use of multisample framebuffers. */
513 #define MULTISAMPLE_GP_SYNC_ENABLE(lvl, fbl) \
514   { \
515     if ((lvl > 0) && (fbl->multisample_fb != NULL) && (DRW_state_is_fbo())) { \
516       DRW_stats_query_start("GP Multisample Blit"); \
517       GPU_framebuffer_bind(fbl->multisample_fb); \
518       GPU_framebuffer_clear_color_depth(fbl->multisample_fb, (const float[4]){0.0f}, 1.0f); \
519       DRW_stats_query_end(); \
520     } \
521   } \
522   ((void)0)
523
524 #define MULTISAMPLE_GP_SYNC_DISABLE(lvl, fbl, fb, txl) \
525   { \
526     if ((lvl > 0) && (fbl->multisample_fb != NULL) && (DRW_state_is_fbo())) { \
527       DRW_stats_query_start("GP Multisample Resolve"); \
528       GPU_framebuffer_bind(fb); \
529       DRW_multisamples_resolve(txl->multisample_depth, txl->multisample_color, true); \
530       DRW_stats_query_end(); \
531     } \
532   } \
533   ((void)0)
534
535 #define GPENCIL_3D_DRAWMODE(ob, gpd) \
536   ((gpd) && (gpd->draw_mode == GP_DRAWMODE_3D) && ((ob->dtx & OB_DRAWXRAY) == 0))
537
538 #define GPENCIL_USE_SOLID(stl) \
539   ((stl) && ((stl->storage->is_render) || (stl->storage->is_mat_preview)))
540
541 #endif /* __GPENCIL_ENGINE_H__ */