a719cc8c94a4f62887a92e6788ad8cbd489282f2
[blender.git] / source / blender / blenkernel / intern / screen.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/screen.c
29  *  \ingroup bke
30  */
31
32 #ifdef WIN32
33 #  include "BLI_winstuff.h"
34 #endif
35
36 #include <string.h>
37 #include <stdio.h>
38 #include <math.h>
39
40 #include "MEM_guardedalloc.h"
41
42 #include "GPU_compositing.h"
43
44 #include "DNA_scene_types.h"
45 #include "DNA_screen_types.h"
46 #include "DNA_space_types.h"
47 #include "DNA_view3d_types.h"
48
49 #include "BLI_listbase.h"
50 #include "BLI_utildefines.h"
51 #include "BLI_rect.h"
52
53 #include "BKE_idprop.h"
54 #include "BKE_screen.h"
55
56 /* ************ Spacetype/regiontype handling ************** */
57
58 /* keep global; this has to be accessible outside of windowmanager */
59 static ListBase spacetypes = {NULL, NULL};
60
61 /* not SpaceType itself */
62 static void spacetype_free(SpaceType *st)
63 {
64         ARegionType *art;
65         PanelType *pt;
66         HeaderType *ht;
67         
68         for (art = st->regiontypes.first; art; art = art->next) {
69                 BLI_freelistN(&art->drawcalls);
70
71                 for (pt = art->paneltypes.first; pt; pt = pt->next)
72                         if (pt->ext.free)
73                                 pt->ext.free(pt->ext.data);
74
75                 for (ht = art->headertypes.first; ht; ht = ht->next)
76                         if (ht->ext.free)
77                                 ht->ext.free(ht->ext.data);
78
79                 BLI_freelistN(&art->paneltypes);
80                 BLI_freelistN(&art->headertypes);
81         }
82         
83         BLI_freelistN(&st->regiontypes);
84         BLI_freelistN(&st->toolshelf);
85
86 }
87
88 void BKE_spacetypes_free(void)
89 {
90         SpaceType *st;
91         
92         for (st = spacetypes.first; st; st = st->next) {
93                 spacetype_free(st);
94         }
95         
96         BLI_freelistN(&spacetypes);
97 }
98
99 SpaceType *BKE_spacetype_from_id(int spaceid)
100 {
101         SpaceType *st;
102         
103         for (st = spacetypes.first; st; st = st->next) {
104                 if (st->spaceid == spaceid)
105                         return st;
106         }
107         return NULL;
108 }
109
110 ARegionType *BKE_regiontype_from_id_or_first(SpaceType *st, int regionid)
111 {
112         ARegionType *art;
113         
114         for (art = st->regiontypes.first; art; art = art->next)
115                 if (art->regionid == regionid)
116                         return art;
117         
118         printf("Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
119         return st->regiontypes.first;
120 }
121
122 ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
123 {
124         ARegionType *art;
125         
126         for (art = st->regiontypes.first; art; art = art->next) {
127                 if (art->regionid == regionid) {
128                         return art;
129                 }
130         }
131         return NULL;
132 }
133
134
135 const ListBase *BKE_spacetypes_list(void)
136 {
137         return &spacetypes;
138 }
139
140 void BKE_spacetype_register(SpaceType *st)
141 {
142         SpaceType *stype;
143         
144         /* sanity check */
145         stype = BKE_spacetype_from_id(st->spaceid);
146         if (stype) {
147                 printf("error: redefinition of spacetype %s\n", stype->name);
148                 spacetype_free(stype);
149                 MEM_freeN(stype);
150         }
151         
152         BLI_addtail(&spacetypes, st);
153 }
154
155 bool BKE_spacetype_exists(int spaceid)
156 {
157         return BKE_spacetype_from_id(spaceid) != NULL;
158 }
159
160 /* ***************** Space handling ********************** */
161
162 void BKE_spacedata_freelist(ListBase *lb)
163 {
164         SpaceLink *sl;
165         ARegion *ar;
166         
167         for (sl = lb->first; sl; sl = sl->next) {
168                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
169                 
170                 /* free regions for pushed spaces */
171                 for (ar = sl->regionbase.first; ar; ar = ar->next)
172                         BKE_area_region_free(st, ar);
173
174                 BLI_freelistN(&sl->regionbase);
175                 
176                 if (st && st->free) 
177                         st->free(sl);
178         }
179         
180         BLI_freelistN(lb);
181 }
182
183 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
184 {
185         ARegion *newar = MEM_dupallocN(ar);
186         Panel *pa, *newpa, *patab;
187         
188         newar->prev = newar->next = NULL;
189         BLI_listbase_clear(&newar->handlers);
190         BLI_listbase_clear(&newar->uiblocks);
191         BLI_listbase_clear(&newar->panels_category);
192         BLI_listbase_clear(&newar->panels_category_active);
193         BLI_listbase_clear(&newar->ui_lists);
194         newar->swinid = 0;
195         newar->regiontimer = NULL;
196         newar->headerstr = NULL;
197         
198         /* use optional regiondata callback */
199         if (ar->regiondata) {
200                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
201
202                 if (art && art->duplicate)
203                         newar->regiondata = art->duplicate(ar->regiondata);
204                 else
205                         newar->regiondata = MEM_dupallocN(ar->regiondata);
206         }
207
208         if (ar->v2d.tab_offset)
209                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
210         
211         BLI_listbase_clear(&newar->panels);
212         BLI_duplicatelist(&newar->panels, &ar->panels);
213
214         BLI_listbase_clear(&newar->ui_previews);
215         BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
216
217         /* copy panel pointers */
218         for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
219                 patab = newar->panels.first;
220                 pa = ar->panels.first;
221                 while (patab) {
222                         if (newpa->paneltab == pa) {
223                                 newpa->paneltab = patab;
224                                 break;
225                         }
226                         patab = patab->next;
227                         pa = pa->next;
228                 }
229         }
230         
231         return newar;
232 }
233
234
235 /* from lb2 to lb1, lb1 is supposed to be freed */
236 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
237 {
238         ARegion *ar;
239         
240         /* to be sure */
241         BLI_listbase_clear(lb1);
242         
243         for (ar = lb2->first; ar; ar = ar->next) {
244                 ARegion *arnew = BKE_area_region_copy(st, ar);
245                 BLI_addtail(lb1, arnew);
246         }
247 }
248
249
250 /* lb1 should be empty */
251 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
252 {
253         SpaceLink *sl;
254         
255         BLI_listbase_clear(lb1);  /* to be sure */
256         
257         for (sl = lb2->first; sl; sl = sl->next) {
258                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
259                 
260                 if (st && st->duplicate) {
261                         SpaceLink *slnew = st->duplicate(sl);
262                         
263                         BLI_addtail(lb1, slnew);
264                         
265                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
266                 }
267         }
268 }
269
270 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
271 /* lock can become bitflag too */
272 /* should be replaced in future by better local data handling for threads */
273 void BKE_spacedata_draw_locks(int set)
274 {
275         SpaceType *st;
276         
277         for (st = spacetypes.first; st; st = st->next) {
278                 ARegionType *art;
279         
280                 for (art = st->regiontypes.first; art; art = art->next) {
281                         if (set) 
282                                 art->do_lock = art->lock;
283                         else 
284                                 art->do_lock = false;
285                 }
286         }
287 }
288
289 static void (*spacedata_id_remap_cb)(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, ID *new_id) = NULL;
290
291 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
292 {
293         spacedata_id_remap_cb = func;
294 }
295
296 /* UNUSED!!! */
297 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
298 {
299         if (spacedata_id_remap_cb) {
300                 spacedata_id_remap_cb(sa, sl, id, NULL);
301         }
302 }
303
304 /* not region itself */
305 void BKE_area_region_free(SpaceType *st, ARegion *ar)
306 {
307         uiList *uilst;
308
309         if (st) {
310                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
311                 
312                 if (art && art->free)
313                         art->free(ar);
314                 
315                 if (ar->regiondata)
316                         printf("regiondata free error\n");
317         }
318         else if (ar->type && ar->type->free)
319                 ar->type->free(ar);
320         
321         if (ar->v2d.tab_offset) {
322                 MEM_freeN(ar->v2d.tab_offset);
323                 ar->v2d.tab_offset = NULL;
324         }
325
326         if (!BLI_listbase_is_empty(&ar->panels)) {
327                 Panel *pa, *pa_next;
328                 for (pa = ar->panels.first; pa; pa = pa_next) {
329                         pa_next = pa->next;
330                         if (pa->activedata) {
331                                 MEM_freeN(pa->activedata);
332                         }
333                         MEM_freeN(pa);
334                 }
335         }
336
337         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
338                 if (uilst->dyn_data) {
339                         uiListDyn *dyn_data = uilst->dyn_data;
340                         if (dyn_data->items_filter_flags) {
341                                 MEM_freeN(dyn_data->items_filter_flags);
342                         }
343                         if (dyn_data->items_filter_neworder) {
344                                 MEM_freeN(dyn_data->items_filter_neworder);
345                         }
346                         MEM_freeN(dyn_data);
347                 }
348                 if (uilst->properties) {
349                         IDP_FreeProperty(uilst->properties);
350                         MEM_freeN(uilst->properties);
351                 }
352         }
353         BLI_freelistN(&ar->ui_lists);
354         BLI_freelistN(&ar->ui_previews);
355         BLI_freelistN(&ar->panels_category);
356         BLI_freelistN(&ar->panels_category_active);
357 }
358
359 /* not area itself */
360 void BKE_screen_area_free(ScrArea *sa)
361 {
362         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
363         ARegion *ar;
364         
365         for (ar = sa->regionbase.first; ar; ar = ar->next)
366                 BKE_area_region_free(st, ar);
367
368         BLI_freelistN(&sa->regionbase);
369         
370         BKE_spacedata_freelist(&sa->spacedata);
371         
372         BLI_freelistN(&sa->actionzones);
373 }
374
375 /** Free (or release) any data used by this screen (does not free the screen itself). */
376 void BKE_screen_free(bScreen *sc)
377 {
378         ScrArea *sa, *san;
379         ARegion *ar;
380
381         /* No animdata here. */
382         
383         for (ar = sc->regionbase.first; ar; ar = ar->next)
384                 BKE_area_region_free(NULL, ar);
385
386         BLI_freelistN(&sc->regionbase);
387         
388         for (sa = sc->areabase.first; sa; sa = san) {
389                 san = sa->next;
390                 BKE_screen_area_free(sa);
391         }
392         
393         BLI_freelistN(&sc->vertbase);
394         BLI_freelistN(&sc->edgebase);
395         BLI_freelistN(&sc->areabase);
396
397         /* Region and timer are freed by the window manager. */
398         MEM_SAFE_FREE(sc->tool_tip);
399 }
400
401 /* for depsgraph */
402 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
403 {
404         ScrArea *sa;
405         unsigned int layer = 0;
406
407         if (screen) {
408                 /* get all used view3d layers */
409                 for (sa = screen->areabase.first; sa; sa = sa->next)
410                         if (sa->spacetype == SPACE_VIEW3D)
411                                 layer |= ((View3D *)sa->spacedata.first)->lay;
412         }
413
414         if (!layer)
415                 return scene->lay;
416
417         return layer;
418 }
419
420 /* ***************** Utilities ********************** */
421
422 /* Find a region of the specified type from the given area */
423 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
424 {
425         if (sa) {
426                 ARegion *ar;
427                 
428                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
429                         if (ar->regiontype == type)
430                                 return ar;
431                 }
432         }
433         return NULL;
434 }
435
436 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
437 {
438         if (sa) {
439                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
440                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
441                         return ar;
442                 }
443
444                 /* fallback to any */
445                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
446         }
447         return NULL;
448 }
449
450 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
451 {
452         ARegion *ar_found = NULL;
453         if (sa) {
454                 ARegion *ar;
455                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
456                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
457                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
458                                         ar_found = ar;
459                                         break;
460                                 }
461                         }
462                 }
463         }
464         return ar_found;
465 }
466
467 /**
468  * \note, ideally we can get the area from the context,
469  * there are a few places however where this isn't practical.
470  */
471 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
472 {
473         ScrArea *sa;
474
475         for (sa = sc->areabase.first; sa; sa = sa->next) {
476                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
477                         break;
478                 }
479         }
480
481         return sa;
482 }
483
484 /**
485  * \note Using this function is generally a last resort, you really want to be
486  * using the context when you can - campbell
487  */
488 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
489 {
490         ScrArea *sa, *big = NULL;
491         int size, maxsize = 0;
492
493         for (sa = sc->areabase.first; sa; sa = sa->next) {
494                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
495                         if (min <= sa->winx && min <= sa->winy) {
496                                 size = sa->winx * sa->winy;
497                                 if (size > maxsize) {
498                                         maxsize = size;
499                                         big = sa;
500                                 }
501                         }
502                 }
503         }
504
505         return big;
506 }
507
508 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
509 {
510         ScrArea *sa, *sa_found = NULL;
511
512         for (sa = sc->areabase.first; sa; sa = sa->next) {
513                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
514                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
515                                 sa_found = sa;
516                         }
517                         break;
518                 }
519         }
520         return sa_found;
521 }
522
523
524 /**
525  * Utility function to get the active layer to use when adding new objects.
526  */
527 unsigned int BKE_screen_view3d_layer_active_ex(const View3D *v3d, const Scene *scene, bool use_localvd)
528 {
529         unsigned int lay;
530         if ((v3d == NULL) || (v3d->scenelock && !v3d->localvd)) {
531                 lay = scene->layact;
532         }
533         else {
534                 lay = v3d->layact;
535         }
536
537         if (use_localvd) {
538                 if (v3d && v3d->localvd) {
539                         lay |= v3d->lay;
540                 }
541         }
542
543         return lay;
544 }
545 unsigned int BKE_screen_view3d_layer_active(const struct View3D *v3d, const struct Scene *scene)
546 {
547         return BKE_screen_view3d_layer_active_ex(v3d, scene, true);
548 }
549
550 /**
551  * Accumulate all visible layers on this screen.
552  */
553 unsigned int BKE_screen_view3d_layer_all(const bScreen *sc)
554 {
555         const ScrArea *sa;
556         unsigned int lay = 0;
557         for (sa = sc->areabase.first; sa; sa = sa->next) {
558                 if (sa->spacetype == SPACE_VIEW3D) {
559                         View3D *v3d = sa->spacedata.first;
560                         lay |= v3d->lay;
561                 }
562         }
563
564         return lay;
565 }
566
567 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
568 {
569         int bit;
570
571         if (v3d->scenelock && v3d->localvd == NULL) {
572                 v3d->lay = scene->lay;
573                 v3d->camera = scene->camera;
574
575                 if (v3d->camera == NULL) {
576                         ARegion *ar;
577
578                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
579                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
580                                         RegionView3D *rv3d = ar->regiondata;
581                                         if (rv3d->persp == RV3D_CAMOB)
582                                                 rv3d->persp = RV3D_PERSP;
583                                 }
584                         }
585                 }
586
587                 if ((v3d->lay & v3d->layact) == 0) {
588                         for (bit = 0; bit < 32; bit++) {
589                                 if (v3d->lay & (1u << bit)) {
590                                         v3d->layact = (1u << bit);
591                                         break;
592                                 }
593                         }
594                 }
595         }
596 }
597
598 void BKE_screen_view3d_scene_sync(bScreen *sc)
599 {
600         /* are there cameras in the views that are not in the scene? */
601         ScrArea *sa;
602         for (sa = sc->areabase.first; sa; sa = sa->next) {
603                 SpaceLink *sl;
604                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
605                         if (sl->spacetype == SPACE_VIEW3D) {
606                                 View3D *v3d = (View3D *) sl;
607                                 BKE_screen_view3d_sync(v3d, sc->scene);
608                         }
609                 }
610         }
611 }
612
613 void BKE_screen_view3d_main_sync(ListBase *screen_lb, Scene *scene)
614 {
615         bScreen *sc;
616         ScrArea *sa;
617         SpaceLink *sl;
618
619         /* from scene copy to the other views */
620         for (sc = screen_lb->first; sc; sc = sc->id.next) {
621                 if (sc->scene != scene)
622                         continue;
623
624                 for (sa = sc->areabase.first; sa; sa = sa->next)
625                         for (sl = sa->spacedata.first; sl; sl = sl->next)
626                                 if (sl->spacetype == SPACE_VIEW3D)
627                                         BKE_screen_view3d_sync((View3D *)sl, scene);
628         }
629 }
630
631 void BKE_screen_view3d_twmode_remove(View3D *v3d, const int i)
632 {
633         const int selected_index = (v3d->twmode - V3D_MANIP_CUSTOM);
634         if (selected_index == i) {
635                 v3d->twmode = V3D_MANIP_GLOBAL; /* fallback to global */
636         }
637         else if (selected_index > i) {
638                 v3d->twmode--;
639         }
640 }
641
642 void BKE_screen_view3d_main_twmode_remove(ListBase *screen_lb, Scene *scene, const int i)
643 {
644         bScreen *sc;
645
646         for (sc = screen_lb->first; sc; sc = sc->id.next) {
647                 if (sc->scene == scene) {
648                         ScrArea *sa;
649                         for (sa = sc->areabase.first; sa; sa = sa->next) {
650                                 SpaceLink *sl;
651                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
652                                         if (sl->spacetype == SPACE_VIEW3D) {
653                                                 View3D *v3d = (View3D *)sl;
654                                                 BKE_screen_view3d_twmode_remove(v3d, i);
655                                         }
656                                 }
657                         }
658                 }
659         }
660 }
661
662 /* magic zoom calculation, no idea what
663  * it signifies, if you find out, tell me! -zr
664  */
665
666 /* simple, its magic dude!
667  * well, to be honest, this gives a natural feeling zooming
668  * with multiple keypad presses (ton)
669  */
670 float BKE_screen_view3d_zoom_to_fac(float camzoom)
671 {
672         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
673 }
674
675 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
676 {
677         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
678 }
679
680 void BKE_screen_gpu_fx_validate(GPUFXSettings *fx_settings)
681 {
682         /* currently we use DOF from the camera _only_,
683          * so we never allocate this, only copy from the Camera */
684 #if 0
685         if ((fx_settings->dof == NULL) &&
686             (fx_settings->fx_flag & GPU_FX_FLAG_DOF))
687         {
688                 GPUDOFSettings *fx_dof;
689                 fx_dof = fx_settings->dof = MEM_callocN(sizeof(GPUDOFSettings), __func__);
690         }
691 #endif
692
693         if ((fx_settings->ssao == NULL) &&
694             (fx_settings->fx_flag & GPU_FX_FLAG_SSAO))
695         {
696                 GPUSSAOSettings *fx_ssao;
697                 fx_ssao = fx_settings->ssao = MEM_callocN(sizeof(GPUSSAOSettings), __func__);
698
699                 GPU_fx_compositor_init_ssao_settings(fx_ssao);
700         }
701 }