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(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
 123 const ListBase *BKE_spacetypes_list(void)
 124 {
 125         return &spacetypes;
 126 }
 127
 128 void BKE_spacetype_register(SpaceType *st)
 129 {
 130         SpaceType *stype;
 131
 132         /* sanity check */
 133         stype = BKE_spacetype_from_id(st->spaceid);
 134         if (stype) {
 135                 printf("error: redefinition of spacetype %s\n", stype->name);
 136                 spacetype_free(stype);
 137                 MEM_freeN(stype);
 138         }
 139
 140         BLI_addtail(&spacetypes, st);
 141 }
 142
 143 bool BKE_spacetype_exists(int spaceid)
 144 {
 145         return BKE_spacetype_from_id(spaceid) != NULL;
 146 }
 147
 148 /* ***************** Space handling ********************** */
 149
 150 void BKE_spacedata_freelist(ListBase *lb)
 151 {
 152         SpaceLink *sl;
 153         ARegion *ar;
 154
 155         for (sl = lb->first; sl; sl = sl->next) {
 156                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
 157
 158                 /* free regions for pushed spaces */
 159                 for (ar = sl->regionbase.first; ar; ar = ar->next)
 160                         BKE_area_region_free(st, ar);
 161
 162                 BLI_freelistN(&sl->regionbase);
 163
 164                 if (st && st->free)
 165                         st->free(sl);
 166         }
 167
 168         BLI_freelistN(lb);
 169 }
 170
 171 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
 172 {
 173         ARegion *newar = MEM_dupallocN(ar);
 174         Panel *pa, *newpa, *patab;
 175
 176         newar->prev = newar->next = NULL;
 177         BLI_listbase_clear(&newar->handlers);
 178         BLI_listbase_clear(&newar->uiblocks);
 179         BLI_listbase_clear(&newar->panels_category);
 180         BLI_listbase_clear(&newar->panels_category_active);
 181         BLI_listbase_clear(&newar->ui_lists);
 182         newar->swinid = 0;
 183         newar->regiontimer = NULL;
 184         newar->headerstr = NULL;
 185
 186         /* use optional regiondata callback */
 187         if (ar->regiondata) {
 188                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
 189
 190                 if (art && art->duplicate)
 191                         newar->regiondata = art->duplicate(ar->regiondata);
 192                 else
 193                         newar->regiondata = MEM_dupallocN(ar->regiondata);
 194         }
 195
 196         if (ar->v2d.tab_offset)
 197                 newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
 198
 199         BLI_listbase_clear(&newar->panels);
 200         BLI_duplicatelist(&newar->panels, &ar->panels);
 201
 202         BLI_listbase_clear(&newar->ui_previews);
 203         BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
 204
 205         /* copy panel pointers */
 206         for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
 207                 patab = newar->panels.first;
 208                 pa = ar->panels.first;
 209                 while (patab) {
 210                         if (newpa->paneltab == pa) {
 211                                 newpa->paneltab = patab;
 212                                 break;
 213                         }
 214                         patab = patab->next;
 215                         pa = pa->next;
 216                 }
 217         }
 218
 219         return newar;
 220 }
 221
 222
 223 /* from lb2 to lb1, lb1 is supposed to be freed */
 224 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
 225 {
 226         ARegion *ar;
 227
 228         /* to be sure */
 229         BLI_listbase_clear(lb1);
 230
 231         for (ar = lb2->first; ar; ar = ar->next) {
 232                 ARegion *arnew = BKE_area_region_copy(st, ar);
 233                 BLI_addtail(lb1, arnew);
 234         }
 235 }
 236
 237
 238 /* lb1 should be empty */
 239 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
 240 {
 241         SpaceLink *sl;
 242
 243         BLI_listbase_clear(lb1);  /* to be sure */
 244
 245         for (sl = lb2->first; sl; sl = sl->next) {
 246                 SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
 247
 248                 if (st && st->duplicate) {
 249                         SpaceLink *slnew = st->duplicate(sl);
 250
 251                         BLI_addtail(lb1, slnew);
 252
 253                         region_copylist(st, &slnew->regionbase, &sl->regionbase);
 254                 }
 255         }
 256 }
 257
 258 /* facility to set locks for drawing to survive (render) threads accessing drawing data */
 259 /* lock can become bitflag too */
 260 /* should be replaced in future by better local data handling for threads */
 261 void BKE_spacedata_draw_locks(int set)
 262 {
 263         SpaceType *st;
 264
 265         for (st = spacetypes.first; st; st = st->next) {
 266                 ARegionType *art;
 267
 268                 for (art = st->regiontypes.first; art; art = art->next) {
 269                         if (set)
 270                                 art->do_lock = art->lock;
 271                         else
 272                                 art->do_lock = false;
 273                 }
 274         }
 275 }
 276
 277 static void (*spacedata_id_remap_cb)(struct ScrArea *sa, struct SpaceLink *sl, ID *old_id, ID *new_id) = NULL;
 278
 279 void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
 280 {
 281         spacedata_id_remap_cb = func;
 282 }
 283
 284 /* UNUSED!!! */
 285 void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
 286 {
 287         if (spacedata_id_remap_cb) {
 288                 spacedata_id_remap_cb(sa, sl, id, NULL);
 289         }
 290 }
 291
 292 /* not region itself */
 293 void BKE_area_region_free(SpaceType *st, ARegion *ar)
 294 {
 295         uiList *uilst;
 296
 297         if (st) {
 298                 ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
 299
 300                 if (art && art->free)
 301                         art->free(ar);
 302
 303                 if (ar->regiondata)
 304                         printf("regiondata free error\n");
 305         }
 306         else if (ar->type && ar->type->free)
 307                 ar->type->free(ar);
 308
 309         if (ar->v2d.tab_offset) {
 310                 MEM_freeN(ar->v2d.tab_offset);
 311                 ar->v2d.tab_offset = NULL;
 312         }
 313
 314         if (!BLI_listbase_is_empty(&ar->panels)) {
 315                 Panel *pa, *pa_next;
 316                 for (pa = ar->panels.first; pa; pa = pa_next) {
 317                         pa_next = pa->next;
 318                         if (pa->activedata) {
 319                                 MEM_freeN(pa->activedata);
 320                         }
 321                         MEM_freeN(pa);
 322                 }
 323         }
 324
 325         for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
 326                 if (uilst->dyn_data) {
 327                         uiListDyn *dyn_data = uilst->dyn_data;
 328                         if (dyn_data->items_filter_flags) {
 329                                 MEM_freeN(dyn_data->items_filter_flags);
 330                         }
 331                         if (dyn_data->items_filter_neworder) {
 332                                 MEM_freeN(dyn_data->items_filter_neworder);
 333                         }
 334                         MEM_freeN(dyn_data);
 335                 }
 336                 if (uilst->properties) {
 337                         IDP_FreeProperty(uilst->properties);
 338                         MEM_freeN(uilst->properties);
 339                 }
 340         }
 341         BLI_freelistN(&ar->ui_lists);
 342         BLI_freelistN(&ar->ui_previews);
 343         BLI_freelistN(&ar->panels_category);
 344         BLI_freelistN(&ar->panels_category_active);
 345 }
 346
 347 /* not area itself */
 348 void BKE_screen_area_free(ScrArea *sa)
 349 {
 350         SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
 351         ARegion *ar;
 352
 353         for (ar = sa->regionbase.first; ar; ar = ar->next)
 354                 BKE_area_region_free(st, ar);
 355
 356         BLI_freelistN(&sa->regionbase);
 357
 358         BKE_spacedata_freelist(&sa->spacedata);
 359
 360         BLI_freelistN(&sa->actionzones);
 361 }
 362
 363 /** Free (or release) any data used by this screen (does not free the screen itself). */
 364 void BKE_screen_free(bScreen *sc)
 365 {
 366         ScrArea *sa, *san;
 367         ARegion *ar;
 368
 369         /* No animdata here. */
 370
 371         for (ar = sc->regionbase.first; ar; ar = ar->next)
 372                 BKE_area_region_free(NULL, ar);
 373
 374         BLI_freelistN(&sc->regionbase);
 375
 376         for (sa = sc->areabase.first; sa; sa = san) {
 377                 san = sa->next;
 378                 BKE_screen_area_free(sa);
 379         }
 380
 381         BLI_freelistN(&sc->vertbase);
 382         BLI_freelistN(&sc->edgebase);
 383         BLI_freelistN(&sc->areabase);
 384
 385         /* Region and timer are freed by the window manager. */
 386         MEM_SAFE_FREE(sc->tool_tip);
 387 }
 388
 389 /* for depsgraph */
 390 unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
 391 {
 392         ScrArea *sa;
 393         unsigned int layer = 0;
 394
 395         if (screen) {
 396                 /* get all used view3d layers */
 397                 for (sa = screen->areabase.first; sa; sa = sa->next)
 398                         if (sa->spacetype == SPACE_VIEW3D)
 399                                 layer |= ((View3D *)sa->spacedata.first)->lay;
 400         }
 401
 402         if (!layer)
 403                 return scene->lay;
 404
 405         return layer;
 406 }
 407
 408 /* ***************** Utilities ********************** */
 409
 410 /* Find a region of the specified type from the given area */
 411 ARegion *BKE_area_find_region_type(ScrArea *sa, int type)
 412 {
 413         if (sa) {
 414                 ARegion *ar;
 415
 416                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
 417                         if (ar->regiontype == type)
 418                                 return ar;
 419                 }
 420         }
 421         return NULL;
 422 }
 423
 424 ARegion *BKE_area_find_region_active_win(ScrArea *sa)
 425 {
 426         if (sa) {
 427                 ARegion *ar = BLI_findlink(&sa->regionbase, sa->region_active_win);
 428                 if (ar && (ar->regiontype == RGN_TYPE_WINDOW)) {
 429                         return ar;
 430                 }
 431
 432                 /* fallback to any */
 433                 return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
 434         }
 435         return NULL;
 436 }
 437
 438 ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
 439 {
 440         ARegion *ar_found = NULL;
 441         if (sa) {
 442                 ARegion *ar;
 443                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
 444                         if ((regiontype == RGN_TYPE_ANY) || (ar->regiontype == regiontype)) {
 445                                 if (BLI_rcti_isect_pt(&ar->winrct, x, y)) {
 446                                         ar_found = ar;
 447                                         break;
 448                                 }
 449                         }
 450                 }
 451         }
 452         return ar_found;
 453 }
 454
 455 /**
 456  * \note, ideally we can get the area from the context,
 457  * there are a few places however where this isn't practical.
 458  */
 459 ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
 460 {
 461         ScrArea *sa;
 462
 463         for (sa = sc->areabase.first; sa; sa = sa->next) {
 464                 if (BLI_findindex(&sa->spacedata, sl) != -1) {
 465                         break;
 466                 }
 467         }
 468
 469         return sa;
 470 }
 471
 472 /**
 473  * \note Using this function is generally a last resort, you really want to be
 474  * using the context when you can - campbell
 475  */
 476 ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
 477 {
 478         ScrArea *sa, *big = NULL;
 479         int size, maxsize = 0;
 480
 481         for (sa = sc->areabase.first; sa; sa = sa->next) {
 482                 if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
 483                         if (min <= sa->winx && min <= sa->winy) {
 484                                 size = sa->winx * sa->winy;
 485                                 if (size > maxsize) {
 486                                         maxsize = size;
 487                                         big = sa;
 488                                 }
 489                         }
 490                 }
 491         }
 492
 493         return big;
 494 }
 495
 496 ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
 497 {
 498         ScrArea *sa, *sa_found = NULL;
 499
 500         for (sa = sc->areabase.first; sa; sa = sa->next) {
 501                 if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
 502                         if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
 503                                 sa_found = sa;
 504                         }
 505                         break;
 506                 }
 507         }
 508         return sa_found;
 509 }
 510
 511
 512 /**
 513  * Utility function to get the active layer to use when adding new objects.
 514  */
 515 unsigned int BKE_screen_view3d_layer_active_ex(const View3D *v3d, const Scene *scene, bool use_localvd)
 516 {
 517         unsigned int lay;
 518         if ((v3d == NULL) || (v3d->scenelock && !v3d->localvd)) {
 519                 lay = scene->layact;
 520         }
 521         else {
 522                 lay = v3d->layact;
 523         }
 524
 525         if (use_localvd) {
 526                 if (v3d && v3d->localvd) {
 527                         lay |= v3d->lay;
 528                 }
 529         }
 530
 531         return lay;
 532 }
 533 unsigned int BKE_screen_view3d_layer_active(const struct View3D *v3d, const struct Scene *scene)
 534 {
 535         return BKE_screen_view3d_layer_active_ex(v3d, scene, true);
 536 }
 537
 538 /**
 539  * Accumulate all visible layers on this screen.
 540  */
 541 unsigned int BKE_screen_view3d_layer_all(const bScreen *sc)
 542 {
 543         const ScrArea *sa;
 544         unsigned int lay = 0;
 545         for (sa = sc->areabase.first; sa; sa = sa->next) {
 546                 if (sa->spacetype == SPACE_VIEW3D) {
 547                         View3D *v3d = sa->spacedata.first;
 548                         lay |= v3d->lay;
 549                 }
 550         }
 551
 552         return lay;
 553 }
 554
 555 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
 556 {
 557         int bit;
 558
 559         if (v3d->scenelock && v3d->localvd == NULL) {
 560                 v3d->lay = scene->lay;
 561                 v3d->camera = scene->camera;
 562
 563                 if (v3d->camera == NULL) {
 564                         ARegion *ar;
 565
 566                         for (ar = v3d->regionbase.first; ar; ar = ar->next) {
 567                                 if (ar->regiontype == RGN_TYPE_WINDOW) {
 568                                         RegionView3D *rv3d = ar->regiondata;
 569                                         if (rv3d->persp == RV3D_CAMOB)
 570                                                 rv3d->persp = RV3D_PERSP;
 571                                 }
 572                         }
 573                 }
 574
 575                 if ((v3d->lay & v3d->layact) == 0) {
 576                         for (bit = 0; bit < 32; bit++) {
 577                                 if (v3d->lay & (1u << bit)) {
 578                                         v3d->layact = (1u << bit);
 579                                         break;
 580                                 }
 581                         }
 582                 }
 583         }
 584 }
 585
 586 void BKE_screen_view3d_scene_sync(bScreen *sc)
 587 {
 588         /* are there cameras in the views that are not in the scene? */
 589         ScrArea *sa;
 590         for (sa = sc->areabase.first; sa; sa = sa->next) {
 591                 SpaceLink *sl;
 592                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
 593                         if (sl->spacetype == SPACE_VIEW3D) {
 594                                 View3D *v3d = (View3D *) sl;
 595                                 BKE_screen_view3d_sync(v3d, sc->scene);
 596                         }
 597                 }
 598         }
 599 }
 600
 601 void BKE_screen_view3d_main_sync(ListBase *screen_lb, Scene *scene)
 602 {
 603         bScreen *sc;
 604         ScrArea *sa;
 605         SpaceLink *sl;
 606
 607         /* from scene copy to the other views */
 608         for (sc = screen_lb->first; sc; sc = sc->id.next) {
 609                 if (sc->scene != scene)
 610                         continue;
 611
 612                 for (sa = sc->areabase.first; sa; sa = sa->next)
 613                         for (sl = sa->spacedata.first; sl; sl = sl->next)
 614                                 if (sl->spacetype == SPACE_VIEW3D)
 615                                         BKE_screen_view3d_sync((View3D *)sl, scene);
 616         }
 617 }
 618
 619 void BKE_screen_view3d_twmode_remove(View3D *v3d, const int i)
 620 {
 621         const int selected_index = (v3d->twmode - V3D_MANIP_CUSTOM);
 622         if (selected_index == i) {
 623                 v3d->twmode = V3D_MANIP_GLOBAL; /* fallback to global */
 624         }
 625         else if (selected_index > i) {
 626                 v3d->twmode--;
 627         }
 628 }
 629
 630 void BKE_screen_view3d_main_twmode_remove(ListBase *screen_lb, Scene *scene, const int i)
 631 {
 632         bScreen *sc;
 633
 634         for (sc = screen_lb->first; sc; sc = sc->id.next) {
 635                 if (sc->scene == scene) {
 636                         ScrArea *sa;
 637                         for (sa = sc->areabase.first; sa; sa = sa->next) {
 638                                 SpaceLink *sl;
 639                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
 640                                         if (sl->spacetype == SPACE_VIEW3D) {
 641                                                 View3D *v3d = (View3D *)sl;
 642                                                 BKE_screen_view3d_twmode_remove(v3d, i);
 643                                         }
 644                                 }
 645                         }
 646                 }
 647         }
 648 }
 649
 650 /* magic zoom calculation, no idea what
 651  * it signifies, if you find out, tell me! -zr
 652  */
 653
 654 /* simple, its magic dude!
 655  * well, to be honest, this gives a natural feeling zooming
 656  * with multiple keypad presses (ton)
 657  */
 658 float BKE_screen_view3d_zoom_to_fac(float camzoom)
 659 {
 660         return powf(((float)M_SQRT2 + camzoom / 50.0f), 2.0f) / 4.0f;
 661 }
 662
 663 float BKE_screen_view3d_zoom_from_fac(float zoomfac)
 664 {
 665         return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
 666 }
 667
 668 void BKE_screen_gpu_fx_validate(GPUFXSettings *fx_settings)
 669 {
 670         /* currently we use DOF from the camera _only_,
 671          * so we never allocate this, only copy from the Camera */
 672 #if 0
 673         if ((fx_settings->dof == NULL) &&
 674             (fx_settings->fx_flag & GPU_FX_FLAG_DOF))
 675         {
 676                 GPUDOFSettings *fx_dof;
 677                 fx_dof = fx_settings->dof = MEM_callocN(sizeof(GPUDOFSettings), __func__);
 678         }
 679 #endif
 680
 681         if ((fx_settings->ssao == NULL) &&
 682             (fx_settings->fx_flag & GPU_FX_FLAG_SSAO))
 683         {
 684                 GPUSSAOSettings *fx_ssao;
 685                 fx_ssao = fx_settings->ssao = MEM_callocN(sizeof(GPUSSAOSettings), __func__);
 686
 687                 GPU_fx_compositor_init_ssao_settings(fx_ssao);
 688         }
 689 }