Merge branch 'master' into greasepencil-object
[blender.git] / source / blender / draw / engines / gpencil / gpencil_cache_utils.c
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 #include "DRW_engine.h"
24 #include "DRW_render.h"
25
26 #include "ED_gpencil.h"
27 #include "ED_view3d.h"
28
29 #include "DNA_gpencil_types.h"
30 #include "DNA_view3d_types.h"
31
32 #include "BKE_library.h"
33 #include "BKE_gpencil.h"
34 #include "BKE_object.h"
35
36 #include "gpencil_engine.h"
37
38 #include "draw_cache_impl.h"
39
40 #include "DEG_depsgraph.h"
41
42 /* verify if exist a non instanced version of the object */
43 static bool gpencil_has_noninstanced_object(Object *ob_instance)
44 {
45   const DRWContextState *draw_ctx = DRW_context_state_get();
46   const ViewLayer *view_layer = draw_ctx->view_layer;
47   Object *ob = NULL;
48   for (Base *base = view_layer->object_bases.first; base; base = base->next) {
49     ob = base->object;
50     if (ob->type != OB_GPENCIL) {
51       continue;
52     }
53     /* object must be visible (invisible objects don't create VBO data) */
54     if (!(DRW_object_visibility_in_active_context(ob) & OB_VISIBLE_SELF)) {
55       continue;
56     }
57     /* is not duplicated and the name is equals */
58     if ((ob->base_flag & BASE_FROM_DUPLI) == 0) {
59       if (STREQ(ob->id.name, ob_instance->id.name)) {
60         return true;
61       }
62     }
63   }
64
65   return false;
66 }
67
68 /* add a gpencil object to cache to defer drawing */
69 tGPencilObjectCache *gpencil_object_cache_add(tGPencilObjectCache *cache_array,
70                                               Object *ob,
71                                               int *gp_cache_size,
72                                               int *gp_cache_used)
73 {
74   const DRWContextState *draw_ctx = DRW_context_state_get();
75   tGPencilObjectCache *cache_elem = NULL;
76   RegionView3D *rv3d = draw_ctx->rv3d;
77   View3D *v3d = draw_ctx->v3d;
78   tGPencilObjectCache *p = NULL;
79
80   /* By default a cache is created with one block with a predefined number of free slots,
81    * if the size is not enough, the cache is reallocated adding a new block of free slots.
82    * This is done in order to keep cache small. */
83   if (*gp_cache_used + 1 > *gp_cache_size) {
84     if ((*gp_cache_size == 0) || (cache_array == NULL)) {
85       p = MEM_callocN(sizeof(struct tGPencilObjectCache) * GP_CACHE_BLOCK_SIZE,
86                       "tGPencilObjectCache");
87       *gp_cache_size = GP_CACHE_BLOCK_SIZE;
88     }
89     else {
90       *gp_cache_size += GP_CACHE_BLOCK_SIZE;
91       p = MEM_recallocN(cache_array, sizeof(struct tGPencilObjectCache) * *gp_cache_size);
92     }
93     cache_array = p;
94   }
95   /* zero out all pointers */
96   cache_elem = &cache_array[*gp_cache_used];
97   memset(cache_elem, 0, sizeof(*cache_elem));
98
99   cache_elem->ob = ob;
100   cache_elem->gpd = (bGPdata *)ob->data;
101   cache_elem->name = BKE_id_to_unique_string_key(&ob->id);
102
103   copy_v3_v3(cache_elem->loc, ob->obmat[3]);
104   copy_m4_m4(cache_elem->obmat, ob->obmat);
105   cache_elem->idx = *gp_cache_used;
106
107   /* object is duplicated (particle) */
108   if (ob->base_flag & BASE_FROM_DUPLI) {
109     /* Check if the original object is not in the viewlayer
110      * and cannot be managed as dupli. This is slower, but required to keep
111      * the particle drawing FPS and display instanced objects in scene
112      * without the original object */
113     bool has_original = gpencil_has_noninstanced_object(ob);
114     cache_elem->is_dup_ob = (has_original) ? ob->base_flag & BASE_FROM_DUPLI : false;
115   }
116   else {
117     cache_elem->is_dup_ob = false;
118   }
119
120   cache_elem->scale = mat4_to_scale(ob->obmat);
121
122   /* save FXs */
123   cache_elem->pixfactor = cache_elem->gpd->pixfactor;
124   cache_elem->shader_fx = ob->shader_fx;
125
126   /* save wire mode (object mode is always primary option) */
127   if (ob->dt == OB_WIRE) {
128     cache_elem->shading_type[0] = (int)OB_WIRE;
129   }
130   else {
131     if (v3d) {
132       cache_elem->shading_type[0] = (int)v3d->shading.type;
133     }
134   }
135
136   /* shgrp array */
137   cache_elem->tot_layers = 0;
138   int totgpl = BLI_listbase_count(&cache_elem->gpd->layers);
139   if (totgpl > 0) {
140     cache_elem->shgrp_array = MEM_callocN(sizeof(tGPencilObjectCache_shgrp) * totgpl, __func__);
141   }
142
143   /* calculate zdepth from point of view */
144   float zdepth = 0.0;
145   if (rv3d) {
146     if (rv3d->is_persp) {
147       zdepth = ED_view3d_calc_zfac(rv3d, ob->obmat[3], NULL);
148     }
149     else {
150       zdepth = -dot_v3v3(rv3d->viewinv[2], ob->obmat[3]);
151     }
152   }
153   else {
154     /* In render mode, rv3d is not available, so use the distance to camera.
155      * The real distance is not important, but the relative distance to the camera plane
156      * in order to sort by z_depth of the objects
157      */
158     float vn[3] = {0.0f, 0.0f, -1.0f}; /* always face down */
159     float plane_cam[4];
160     struct Object *camera = draw_ctx->scene->camera;
161     if (camera) {
162       mul_m4_v3(camera->obmat, vn);
163       normalize_v3(vn);
164       plane_from_point_normal_v3(plane_cam, camera->loc, vn);
165       zdepth = dist_squared_to_plane_v3(ob->obmat[3], plane_cam);
166     }
167   }
168   cache_elem->zdepth = zdepth;
169   /* increase slots used in cache */
170   (*gp_cache_used)++;
171
172   return cache_array;
173 }
174
175 /* add a shading group to the cache to create later */
176 GpencilBatchGroup *gpencil_group_cache_add(GpencilBatchGroup *cache_array,
177                                            bGPDlayer *gpl,
178                                            bGPDframe *gpf,
179                                            bGPDstroke *gps,
180                                            const short type,
181                                            const bool onion,
182                                            const int vertex_idx,
183                                            int *grp_size,
184                                            int *grp_used)
185 {
186   GpencilBatchGroup *cache_elem = NULL;
187   GpencilBatchGroup *p = NULL;
188
189   /* By default a cache is created with one block with a predefined number of free slots,
190    * if the size is not enough, the cache is reallocated adding a new block of free slots.
191    * This is done in order to keep cache small. */
192   if (*grp_used + 1 > *grp_size) {
193     if ((*grp_size == 0) || (cache_array == NULL)) {
194       p = MEM_callocN(sizeof(struct GpencilBatchGroup) * GPENCIL_GROUPS_BLOCK_SIZE,
195                       "GpencilBatchGroup");
196       *grp_size = GPENCIL_GROUPS_BLOCK_SIZE;
197     }
198     else {
199       *grp_size += GPENCIL_GROUPS_BLOCK_SIZE;
200       p = MEM_recallocN(cache_array, sizeof(struct GpencilBatchGroup) * *grp_size);
201     }
202     cache_array = p;
203   }
204   /* zero out all data */
205   cache_elem = &cache_array[*grp_used];
206   memset(cache_elem, 0, sizeof(*cache_elem));
207
208   cache_elem->gpl = gpl;
209   cache_elem->gpf = gpf;
210   cache_elem->gps = gps;
211   cache_elem->type = type;
212   cache_elem->onion = onion;
213   cache_elem->vertex_idx = vertex_idx;
214
215   /* increase slots used in cache */
216   (*grp_used)++;
217
218   return cache_array;
219 }
220
221 /* get current cache data */
222 static GpencilBatchCache *gpencil_batch_get_element(Object *ob)
223 {
224   return ob->runtime.gpencil_cache;
225 }
226
227 /* verify if cache is valid */
228 static bool gpencil_batch_cache_valid(GpencilBatchCache *cache, bGPdata *gpd, int cfra)
229 {
230   bool valid = true;
231   if (cache == NULL) {
232     return false;
233   }
234
235   cache->is_editmode = GPENCIL_ANY_EDIT_MODE(gpd);
236   if (cfra != cache->cache_frame) {
237     valid = false;
238   }
239   else if (gpd->flag & GP_DATA_CACHE_IS_DIRTY) {
240     valid = false;
241   }
242   else if (gpd->flag & GP_DATA_PYTHON_UPDATED) {
243     gpd->flag &= ~GP_DATA_PYTHON_UPDATED;
244     valid = false;
245   }
246   else if (cache->is_editmode) {
247     valid = false;
248   }
249   else if (cache->is_dirty) {
250     valid = false;
251   }
252
253   return valid;
254 }
255
256 /* cache init */
257 static GpencilBatchCache *gpencil_batch_cache_init(Object *ob, int cfra)
258 {
259   bGPdata *gpd = (bGPdata *)ob->data;
260
261   GpencilBatchCache *cache = gpencil_batch_get_element(ob);
262
263   if (!cache) {
264     cache = MEM_callocN(sizeof(*cache), __func__);
265     ob->runtime.gpencil_cache = cache;
266   }
267   else {
268     memset(cache, 0, sizeof(*cache));
269   }
270
271   cache->is_editmode = GPENCIL_ANY_EDIT_MODE(gpd);
272
273   cache->is_dirty = true;
274
275   cache->cache_frame = cfra;
276
277   return cache;
278 }
279
280 /* clear cache */
281 static void gpencil_batch_cache_clear(GpencilBatchCache *cache)
282 {
283   if (!cache) {
284     return;
285   }
286
287   GPU_BATCH_DISCARD_SAFE(cache->b_stroke.batch);
288   GPU_BATCH_DISCARD_SAFE(cache->b_point.batch);
289   GPU_BATCH_DISCARD_SAFE(cache->b_fill.batch);
290   GPU_BATCH_DISCARD_SAFE(cache->b_edit.batch);
291   GPU_BATCH_DISCARD_SAFE(cache->b_edlin.batch);
292
293   MEM_SAFE_FREE(cache->b_stroke.batch);
294   MEM_SAFE_FREE(cache->b_point.batch);
295   MEM_SAFE_FREE(cache->b_fill.batch);
296   MEM_SAFE_FREE(cache->b_edit.batch);
297   MEM_SAFE_FREE(cache->b_edlin.batch);
298
299   /* internal format data */
300   MEM_SAFE_FREE(cache->b_stroke.format);
301   MEM_SAFE_FREE(cache->b_point.format);
302   MEM_SAFE_FREE(cache->b_fill.format);
303   MEM_SAFE_FREE(cache->b_edit.format);
304   MEM_SAFE_FREE(cache->b_edlin.format);
305
306   MEM_SAFE_FREE(cache->grp_cache);
307   cache->grp_size = 0;
308   cache->grp_used = 0;
309 }
310
311 /* get cache */
312 GpencilBatchCache *gpencil_batch_cache_get(Object *ob, int cfra)
313 {
314   bGPdata *gpd = (bGPdata *)ob->data;
315
316   GpencilBatchCache *cache = gpencil_batch_get_element(ob);
317   if (!gpencil_batch_cache_valid(cache, gpd, cfra)) {
318     if (cache) {
319       gpencil_batch_cache_clear(cache);
320     }
321     return gpencil_batch_cache_init(ob, cfra);
322   }
323   else {
324     return cache;
325   }
326 }
327
328 /* set cache as dirty */
329 void DRW_gpencil_batch_cache_dirty_tag(bGPdata *gpd)
330 {
331   gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
332 }
333
334 /* free batch cache */
335 void DRW_gpencil_batch_cache_free(bGPdata *UNUSED(gpd))
336 {
337   return;
338 }
339
340 /* wrapper to clear cache */
341 void DRW_gpencil_freecache(struct Object *ob)
342 {
343   if ((ob) && (ob->type == OB_GPENCIL)) {
344     gpencil_batch_cache_clear(ob->runtime.gpencil_cache);
345     MEM_SAFE_FREE(ob->runtime.gpencil_cache);
346     bGPdata *gpd = (bGPdata *)ob->data;
347     if (gpd) {
348       gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
349     }
350   }
351
352   /* clear all frames derived data */
353   for (int i = 0; i < ob->runtime.tot_layers; i++) {
354     bGPDframe *derived_gpf = &ob->runtime.derived_frames[i];
355     BKE_gpencil_free_frame_runtime_data(derived_gpf);
356     derived_gpf = NULL;
357   }
358
359   ob->runtime.tot_layers = 0;
360   MEM_SAFE_FREE(ob->runtime.derived_frames);
361 }