source/blender/blenkernel/intern/material.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/material.c
  29  *  \ingroup bke
  30  */
  31
  32
  33 #include <string.h>
  34 #include <math.h>
  35 #include <stddef.h>
  36
  37 #include "MEM_guardedalloc.h"
  38
  39 #include "DNA_anim_types.h"
  40 #include "DNA_curve_types.h"
  41 #include "DNA_group_types.h"
  42 #include "DNA_material_types.h"
  43 #include "DNA_mesh_types.h"
  44 #include "DNA_meshdata_types.h"
  45 #include "DNA_customdata_types.h"
  46 #include "DNA_ID.h"
  47 #include "DNA_meta_types.h"
  48 #include "DNA_node_types.h"
  49 #include "DNA_object_types.h"
  50 #include "DNA_scene_types.h"
  51
  52 #include "BLI_math.h"
  53 #include "BLI_listbase.h"
  54 #include "BLI_utildefines.h"
  55 #include "BLI_string.h"
  56 #include "BLI_array_utils.h"
  57
  58 #include "BKE_animsys.h"
  59 #include "BKE_displist.h"
  60 #include "BKE_global.h"
  61 #include "BKE_icons.h"
  62 #include "BKE_image.h"
  63 #include "BKE_library.h"
  64 #include "BKE_library_query.h"
  65 #include "BKE_library_remap.h"
  66 #include "BKE_main.h"
  67 #include "BKE_material.h"
  68 #include "BKE_mesh.h"
  69 #include "BKE_scene.h"
  70 #include "BKE_node.h"
  71 #include "BKE_curve.h"
  72 #include "BKE_editmesh.h"
  73 #include "BKE_font.h"
  74
  75 #include "DEG_depsgraph_build.h"
  76
  77 #include "GPU_material.h"
  78
  79 /* used in UI and render */
  80 Material defmaterial;
  81
  82 /* called on startup, creator.c */
  83 void init_def_material(void)
  84 {
  85         BKE_material_init(&defmaterial);
  86 }
  87
  88 /** Free (or release) any data used by this material (does not free the material itself). */
  89 void BKE_material_free(Material *ma)
  90 {
  91         int a;
  92
  93         BKE_animdata_free((ID *)ma, false);
  94
  95         for (a = 0; a < MAX_MTEX; a++) {
  96                 MEM_SAFE_FREE(ma->mtex[a]);
  97         }
  98
  99         MEM_SAFE_FREE(ma->ramp_col);
 100         MEM_SAFE_FREE(ma->ramp_spec);
 101
 102         /* is no lib link block, but material extension */
 103         if (ma->nodetree) {
 104                 ntreeFreeTree(ma->nodetree);
 105                 MEM_freeN(ma->nodetree);
 106                 ma->nodetree = NULL;
 107         }
 108
 109         MEM_SAFE_FREE(ma->texpaintslot);
 110
 111         GPU_material_free(&ma->gpumaterial);
 112
 113         BKE_icon_id_delete((ID *)ma);
 114         BKE_previewimg_free(&ma->preview);
 115 }
 116
 117 void BKE_material_init(Material *ma)
 118 {
 119         BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(ma, id));
 120
 121         ma->r = ma->g = ma->b = ma->ref = 0.8;
 122         ma->specr = ma->specg = ma->specb = 1.0;
 123         ma->mirr = ma->mirg = ma->mirb = 1.0;
 124         ma->spectra = 1.0;
 125         ma->amb = 1.0;
 126         ma->alpha = 1.0;
 127         ma->spec = ma->hasize = 0.5;
 128         ma->har = 50;
 129         ma->starc = ma->ringc = 4;
 130         ma->linec = 12;
 131         ma->flarec = 1;
 132         ma->flaresize = ma->subsize = 1.0;
 133         ma->flareboost = 1;
 134         ma->seed2 = 6;
 135         ma->friction = 0.5;
 136         ma->refrac = 4.0;
 137         ma->roughness = 0.5;
 138         ma->param[0] = 0.5;
 139         ma->param[1] = 0.1;
 140         ma->param[2] = 0.5;
 141         ma->param[3] = 0.1;
 142         ma->rms = 0.1;
 143         ma->darkness = 1.0;
 144
 145         ma->strand_sta = ma->strand_end = 1.0f;
 146
 147         ma->ang = 1.0;
 148         ma->ray_depth = 2;
 149         ma->ray_depth_tra = 2;
 150         ma->fresnel_mir = 0.0;
 151         ma->fresnel_tra = 0.0;
 152         ma->fresnel_tra_i = 1.25;
 153         ma->fresnel_mir_i = 1.25;
 154         ma->tx_limit = 0.0;
 155         ma->tx_falloff = 1.0;
 156         ma->shad_alpha = 1.0f;
 157         ma->vcol_alpha = 0;
 158
 159         ma->gloss_mir = ma->gloss_tra = 1.0;
 160         ma->samp_gloss_mir = ma->samp_gloss_tra = 18;
 161         ma->adapt_thresh_mir = ma->adapt_thresh_tra = 0.005;
 162         ma->dist_mir = 0.0;
 163         ma->fadeto_mir = MA_RAYMIR_FADETOSKY;
 164
 165         ma->rampfac_col = 1.0;
 166         ma->rampfac_spec = 1.0;
 167         ma->pr_lamp = 3;         /* two lamps, is bits */
 168         ma->pr_type = MA_SPHERE;
 169
 170         ma->sss_radius[0] = 1.0f;
 171         ma->sss_radius[1] = 1.0f;
 172         ma->sss_radius[2] = 1.0f;
 173         ma->sss_col[0] = 1.0f;
 174         ma->sss_col[1] = 1.0f;
 175         ma->sss_col[2] = 1.0f;
 176         ma->sss_error = 0.05f;
 177         ma->sss_scale = 0.1f;
 178         ma->sss_ior = 1.3f;
 179         ma->sss_colfac = 1.0f;
 180         ma->sss_texfac = 0.0f;
 181         ma->sss_front = 1.0f;
 182         ma->sss_back = 1.0f;
 183
 184         ma->vol.density = 1.0f;
 185         ma->vol.emission = 0.0f;
 186         ma->vol.scattering = 1.0f;
 187         ma->vol.reflection = 1.0f;
 188         ma->vol.transmission_col[0] = ma->vol.transmission_col[1] = ma->vol.transmission_col[2] = 1.0f;
 189         ma->vol.reflection_col[0] = ma->vol.reflection_col[1] = ma->vol.reflection_col[2] = 1.0f;
 190         ma->vol.emission_col[0] = ma->vol.emission_col[1] = ma->vol.emission_col[2] = 1.0f;
 191         ma->vol.density_scale = 1.0f;
 192         ma->vol.depth_cutoff = 0.01f;
 193         ma->vol.stepsize_type = MA_VOL_STEP_RANDOMIZED;
 194         ma->vol.stepsize = 0.2f;
 195         ma->vol.shade_type = MA_VOL_SHADE_SHADED;
 196         ma->vol.shadeflag |= MA_VOL_PRECACHESHADING;
 197         ma->vol.precache_resolution = 50;
 198         ma->vol.ms_spread = 0.2f;
 199         ma->vol.ms_diff = 1.f;
 200         ma->vol.ms_intensity = 1.f;
 201
 202         ma->game.flag = GEMAT_BACKCULL;
 203         ma->game.alpha_blend = 0;
 204         ma->game.face_orientation = 0;
 205
 206         ma->mode = MA_TRACEBLE | MA_SHADBUF | MA_SHADOW | MA_RAYBIAS | MA_TANGENT_STR | MA_ZTRANSP;
 207         ma->mode2 = MA_CASTSHADOW;
 208         ma->shade_flag = MA_APPROX_OCCLUSION;
 209         ma->preview = NULL;
 210
 211         ma->alpha_threshold = 0.5f;
 212 }
 213
 214 Material *BKE_material_add(Main *bmain, const char *name)
 215 {
 216         Material *ma;
 217
 218         ma = BKE_libblock_alloc(bmain, ID_MA, name, 0);
 219
 220         BKE_material_init(ma);
 221
 222         return ma;
 223 }
 224
 225 /**
 226  * Only copy internal data of Material ID from source to already allocated/initialized destination.
 227  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
 228  *
 229  * WARNING! This function will not handle ID user count!
 230  *
 231  * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
 232  */
 233 void BKE_material_copy_data(Main *bmain, Material *ma_dst, const Material *ma_src, const int flag)
 234 {
 235         for (int a = 0; a < MAX_MTEX; a++) {
 236                 if (ma_src->mtex[a]) {
 237                         ma_dst->mtex[a] = MEM_mallocN(sizeof(*ma_dst->mtex[a]), __func__);
 238                         *ma_dst->mtex[a] = *ma_src->mtex[a];
 239                 }
 240         }
 241
 242         if (ma_src->ramp_col) {
 243                 ma_dst->ramp_col = MEM_dupallocN(ma_src->ramp_col);
 244         }
 245         if (ma_src->ramp_spec) {
 246                 ma_dst->ramp_spec = MEM_dupallocN(ma_src->ramp_spec);
 247         }
 248
 249         if (ma_src->nodetree) {
 250                 BKE_id_copy_ex(bmain, (ID *)ma_src->nodetree, (ID **)&ma_dst->nodetree, flag, false);
 251         }
 252
 253         if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
 254                 BKE_previewimg_id_copy(&ma_dst->id, &ma_src->id);
 255         }
 256         else {
 257                 ma_dst->preview = NULL;
 258         }
 259
 260         BLI_listbase_clear(&ma_dst->gpumaterial);
 261
 262         /* TODO Duplicate Engine Settings and set runtime to NULL */
 263 }
 264
 265 Material *BKE_material_copy(Main *bmain, const Material *ma)
 266 {
 267         Material *ma_copy;
 268         BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy, 0, false);
 269         return ma_copy;
 270 }
 271
 272 /* XXX (see above) material copy without adding to main dbase */
 273 Material *localize_material(Material *ma)
 274 {
 275         /* TODO replace with something like
 276          *      Material *ma_copy;
 277          *      BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy, LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT, false);
 278          *      return ma_copy;
 279          *
 280          * ... Once f*** nodes are fully converted to that too :( */
 281
 282         Material *man;
 283         int a;
 284
 285         man = BKE_libblock_copy_nolib(&ma->id, false);
 286
 287         /* no increment for texture ID users, in previewrender.c it prevents decrement */
 288         for (a = 0; a < MAX_MTEX; a++) {
 289                 if (ma->mtex[a]) {
 290                         man->mtex[a] = MEM_mallocN(sizeof(MTex), "copymaterial");
 291                         memcpy(man->mtex[a], ma->mtex[a], sizeof(MTex));
 292                 }
 293         }
 294
 295         if (ma->ramp_col) man->ramp_col = MEM_dupallocN(ma->ramp_col);
 296         if (ma->ramp_spec) man->ramp_spec = MEM_dupallocN(ma->ramp_spec);
 297
 298         man->texpaintslot = NULL;
 299         man->preview = NULL;
 300
 301         if (ma->nodetree)
 302                 man->nodetree = ntreeLocalize(ma->nodetree);
 303
 304         BLI_listbase_clear(&man->gpumaterial);
 305
 306         /* TODO Duplicate Engine Settings and set runtime to NULL */
 307
 308         return man;
 309 }
 310
 311 void BKE_material_make_local(Main *bmain, Material *ma, const bool lib_local)
 312 {
 313         BKE_id_make_local_generic(bmain, &ma->id, true, lib_local);
 314 }
 315
 316 Material ***give_matarar(Object *ob)
 317 {
 318         Mesh *me;
 319         Curve *cu;
 320         MetaBall *mb;
 321
 322         if (ob->type == OB_MESH) {
 323                 me = ob->data;
 324                 return &(me->mat);
 325         }
 326         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
 327                 cu = ob->data;
 328                 return &(cu->mat);
 329         }
 330         else if (ob->type == OB_MBALL) {
 331                 mb = ob->data;
 332                 return &(mb->mat);
 333         }
 334         return NULL;
 335 }
 336
 337 short *give_totcolp(Object *ob)
 338 {
 339         Mesh *me;
 340         Curve *cu;
 341         MetaBall *mb;
 342
 343         if (ob->type == OB_MESH) {
 344                 me = ob->data;
 345                 return &(me->totcol);
 346         }
 347         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
 348                 cu = ob->data;
 349                 return &(cu->totcol);
 350         }
 351         else if (ob->type == OB_MBALL) {
 352                 mb = ob->data;
 353                 return &(mb->totcol);
 354         }
 355         return NULL;
 356 }
 357
 358 /* same as above but for ID's */
 359 Material ***give_matarar_id(ID *id)
 360 {
 361         /* ensure we don't try get materials from non-obdata */
 362         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 363
 364         switch (GS(id->name)) {
 365                 case ID_ME:
 366                         return &(((Mesh *)id)->mat);
 367                 case ID_CU:
 368                         return &(((Curve *)id)->mat);
 369                 case ID_MB:
 370                         return &(((MetaBall *)id)->mat);
 371                 default:
 372                         break;
 373         }
 374         return NULL;
 375 }
 376
 377 short *give_totcolp_id(ID *id)
 378 {
 379         /* ensure we don't try get materials from non-obdata */
 380         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 381
 382         switch (GS(id->name)) {
 383                 case ID_ME:
 384                         return &(((Mesh *)id)->totcol);
 385                 case ID_CU:
 386                         return &(((Curve *)id)->totcol);
 387                 case ID_MB:
 388                         return &(((MetaBall *)id)->totcol);
 389                 default:
 390                         break;
 391         }
 392         return NULL;
 393 }
 394
 395 static void material_data_index_remove_id(ID *id, short index)
 396 {
 397         /* ensure we don't try get materials from non-obdata */
 398         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 399
 400         switch (GS(id->name)) {
 401                 case ID_ME:
 402                         BKE_mesh_material_index_remove((Mesh *)id, index);
 403                         break;
 404                 case ID_CU:
 405                         BKE_curve_material_index_remove((Curve *)id, index);
 406                         break;
 407                 case ID_MB:
 408                         /* meta-elems don't have materials atm */
 409                         break;
 410                 default:
 411                         break;
 412         }
 413 }
 414
 415 static void material_data_index_clear_id(ID *id)
 416 {
 417         /* ensure we don't try get materials from non-obdata */
 418         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 419
 420         switch (GS(id->name)) {
 421                 case ID_ME:
 422                         BKE_mesh_material_index_clear((Mesh *)id);
 423                         break;
 424                 case ID_CU:
 425                         BKE_curve_material_index_clear((Curve *)id);
 426                         break;
 427                 case ID_MB:
 428                         /* meta-elems don't have materials atm */
 429                         break;
 430                 default:
 431                         break;
 432         }
 433 }
 434
 435 void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
 436 {
 437         Material ***matar = give_matarar_id(id);
 438         short *totcolp = give_totcolp_id(id);
 439
 440         if (matar == NULL) {
 441                 return;
 442         }
 443
 444         if (do_id_user && totcol < (*totcolp)) {
 445                 short i;
 446                 for (i = totcol; i < (*totcolp); i++) {
 447                         id_us_min((ID *)(*matar)[i]);
 448                 }
 449         }
 450
 451         if (totcol == 0) {
 452                 if (*totcolp) {
 453                         MEM_freeN(*matar);
 454                         *matar = NULL;
 455                 }
 456         }
 457         else {
 458                 *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
 459         }
 460         *totcolp = totcol;
 461
 462         DEG_relations_tag_update(bmain);
 463 }
 464
 465 void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
 466 {
 467         Material ***matar;
 468         if ((matar = give_matarar_id(id))) {
 469                 short *totcol = give_totcolp_id(id);
 470                 Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
 471                 if (*totcol) memcpy(mat, *matar, sizeof(void *) * (*totcol));
 472                 if (*matar) MEM_freeN(*matar);
 473
 474                 *matar = mat;
 475                 (*matar)[(*totcol)++] = ma;
 476
 477                 id_us_plus((ID *)ma);
 478                 test_all_objects_materials(bmain, id);
 479                 DEG_relations_tag_update(bmain);
 480         }
 481 }
 482
 483 Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i, bool update_data)
 484 {
 485         short index = (short)index_i;
 486         Material *ret = NULL;
 487         Material ***matar;
 488         if ((matar = give_matarar_id(id))) {
 489                 short *totcol = give_totcolp_id(id);
 490                 if (index >= 0 && index < (*totcol)) {
 491                         ret = (*matar)[index];
 492                         id_us_min((ID *)ret);
 493
 494                         if (*totcol <= 1) {
 495                                 *totcol = 0;
 496                                 MEM_freeN(*matar);
 497                                 *matar = NULL;
 498                         }
 499                         else {
 500                                 if (index + 1 != (*totcol))
 501                                         memmove((*matar) + index, (*matar) + (index + 1), sizeof(void *) * ((*totcol) - (index + 1)));
 502
 503                                 (*totcol)--;
 504                                 *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
 505                                 test_all_objects_materials(G.main, id);
 506                         }
 507
 508                         if (update_data) {
 509                                 /* decrease mat_nr index */
 510                                 material_data_index_remove_id(id, index);
 511                         }
 512
 513                         DEG_relations_tag_update(bmain);
 514                 }
 515         }
 516
 517         return ret;
 518 }
 519
 520 void BKE_material_clear_id(Main *bmain, ID *id, bool update_data)
 521 {
 522         Material ***matar;
 523         if ((matar = give_matarar_id(id))) {
 524                 short *totcol = give_totcolp_id(id);
 525
 526                 while ((*totcol)--) {
 527                         id_us_min((ID *)((*matar)[*totcol]));
 528                 }
 529                 *totcol = 0;
 530                 if (*matar) {
 531                         MEM_freeN(*matar);
 532                         *matar = NULL;
 533                 }
 534
 535                 if (update_data) {
 536                         /* decrease mat_nr index */
 537                         material_data_index_clear_id(id);
 538                 }
 539
 540                 DEG_relations_tag_update(bmain);
 541         }
 542 }
 543
 544 Material *give_current_material(Object *ob, short act)
 545 {
 546         Material ***matarar, *ma;
 547         const short *totcolp;
 548
 549         if (ob == NULL) return NULL;
 550
 551         /* if object cannot have material, (totcolp == NULL) */
 552         totcolp = give_totcolp(ob);
 553         if (totcolp == NULL || ob->totcol == 0) return NULL;
 554
 555         /* return NULL for invalid 'act', can happen for mesh face indices */
 556         if (act > ob->totcol)
 557                 return NULL;
 558         else if (act <= 0) {
 559                 if (act < 0) {
 560                         printf("Negative material index!\n");
 561                 }
 562                 return NULL;
 563         }
 564
 565         if (ob->matbits && ob->matbits[act - 1]) {    /* in object */
 566                 ma = ob->mat[act - 1];
 567         }
 568         else {                              /* in data */
 569
 570                 /* check for inconsistency */
 571                 if (*totcolp < ob->totcol)
 572                         ob->totcol = *totcolp;
 573                 if (act > ob->totcol) act = ob->totcol;
 574
 575                 matarar = give_matarar(ob);
 576
 577                 if (matarar && *matarar) ma = (*matarar)[act - 1];
 578                 else ma = NULL;
 579
 580         }
 581
 582         return ma;
 583 }
 584
 585 Material *give_node_material(Material *ma)
 586 {
 587         if (ma && ma->use_nodes && ma->nodetree) {
 588                 bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
 589
 590                 if (node)
 591                         return (Material *)node->id;
 592         }
 593
 594         return NULL;
 595 }
 596
 597 void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
 598 {
 599         Material **newmatar;
 600         char *newmatbits;
 601
 602         if (do_id_user && totcol < ob->totcol) {
 603                 short i;
 604                 for (i = totcol; i < ob->totcol; i++) {
 605                         id_us_min((ID *)ob->mat[i]);
 606                 }
 607         }
 608
 609         if (totcol == 0) {
 610                 if (ob->totcol) {
 611                         MEM_freeN(ob->mat);
 612                         MEM_freeN(ob->matbits);
 613                         ob->mat = NULL;
 614                         ob->matbits = NULL;
 615                 }
 616         }
 617         else if (ob->totcol < totcol) {
 618                 newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
 619                 newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
 620                 if (ob->totcol) {
 621                         memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
 622                         memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
 623                         MEM_freeN(ob->mat);
 624                         MEM_freeN(ob->matbits);
 625                 }
 626                 ob->mat = newmatar;
 627                 ob->matbits = newmatbits;
 628         }
 629         /* XXX, why not realloc on shrink? - campbell */
 630
 631         ob->totcol = totcol;
 632         if (ob->totcol && ob->actcol == 0) ob->actcol = 1;
 633         if (ob->actcol > ob->totcol) ob->actcol = ob->totcol;
 634
 635         DEG_relations_tag_update(bmain);
 636 }
 637
 638 void test_object_materials(Object *ob, ID *id)
 639 {
 640         /* make the ob mat-array same size as 'ob->data' mat-array */
 641         const short *totcol;
 642
 643         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
 644                 return;
 645         }
 646
 647         BKE_material_resize_object(G.main, ob, *totcol, false);
 648 }
 649
 650 void test_all_objects_materials(Main *bmain, ID *id)
 651 {
 652         /* make the ob mat-array same size as 'ob->data' mat-array */
 653         Object *ob;
 654         const short *totcol;
 655
 656         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
 657                 return;
 658         }
 659
 660         BKE_main_lock(bmain);
 661         for (ob = bmain->object.first; ob; ob = ob->id.next) {
 662                 if (ob->data == id) {
 663                         BKE_material_resize_object(bmain, ob, *totcol, false);
 664                 }
 665         }
 666         BKE_main_unlock(bmain);
 667 }
 668
 669 void assign_material_id(ID *id, Material *ma, short act)
 670 {
 671         Material *mao, **matar, ***matarar;
 672         short *totcolp;
 673
 674         if (act > MAXMAT) return;
 675         if (act < 1) act = 1;
 676
 677         /* this is needed for Python overrides,
 678          * we just have to take care that the UI can't do this */
 679 #if 0
 680         /* prevent crashing when using accidentally */
 681         BLI_assert(id->lib == NULL);
 682         if (id->lib) return;
 683 #endif
 684
 685         /* test arraylens */
 686
 687         totcolp = give_totcolp_id(id);
 688         matarar = give_matarar_id(id);
 689
 690         if (totcolp == NULL || matarar == NULL) return;
 691
 692         if (act > *totcolp) {
 693                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
 694
 695                 if (*totcolp) {
 696                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
 697                         MEM_freeN(*matarar);
 698                 }
 699
 700                 *matarar = matar;
 701                 *totcolp = act;
 702         }
 703
 704         /* in data */
 705         mao = (*matarar)[act - 1];
 706         if (mao)
 707                 id_us_min(&mao->id);
 708         (*matarar)[act - 1] = ma;
 709
 710         if (ma)
 711                 id_us_plus(&ma->id);
 712
 713         test_all_objects_materials(G.main, id);
 714 }
 715
 716 void assign_material(Object *ob, Material *ma, short act, int assign_type)
 717 {
 718         Material *mao, **matar, ***matarar;
 719         short *totcolp;
 720         char bit = 0;
 721
 722         if (act > MAXMAT) return;
 723         if (act < 1) act = 1;
 724
 725         /* prevent crashing when using accidentally */
 726         BLI_assert(!ID_IS_LINKED_DATABLOCK(ob));
 727         if (ID_IS_LINKED_DATABLOCK(ob)) return;
 728
 729         /* test arraylens */
 730
 731         totcolp = give_totcolp(ob);
 732         matarar = give_matarar(ob);
 733
 734         if (totcolp == NULL || matarar == NULL) return;
 735
 736         if (act > *totcolp) {
 737                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
 738
 739                 if (*totcolp) {
 740                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
 741                         MEM_freeN(*matarar);
 742                 }
 743
 744                 *matarar = matar;
 745                 *totcolp = act;
 746         }
 747
 748         if (act > ob->totcol) {
 749                 /* Need more space in the material arrays */
 750                 ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
 751                 ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
 752                 ob->totcol = act;
 753         }
 754
 755         /* Determine the object/mesh linking */
 756         if (assign_type == BKE_MAT_ASSIGN_EXISTING) {
 757                 /* keep existing option (avoid confusion in scripts),
 758                  * intentionally ignore userpref (default to obdata). */
 759                 bit = ob->matbits[act - 1];
 760         }
 761         else if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
 762                 /* copy from previous material */
 763                 bit = ob->matbits[ob->actcol - 1];
 764         }
 765         else {
 766                 switch (assign_type) {
 767                         case BKE_MAT_ASSIGN_OBDATA:
 768                                 bit = 0;
 769                                 break;
 770                         case BKE_MAT_ASSIGN_OBJECT:
 771                                 bit = 1;
 772                                 break;
 773                         case BKE_MAT_ASSIGN_USERPREF:
 774                         default:
 775                                 bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
 776                                 break;
 777                 }
 778         }
 779
 780         /* do it */
 781
 782         ob->matbits[act - 1] = bit;
 783         if (bit == 1) {   /* in object */
 784                 mao = ob->mat[act - 1];
 785                 if (mao)
 786                         id_us_min(&mao->id);
 787                 ob->mat[act - 1] = ma;
 788                 test_object_materials(ob, ob->data);
 789         }
 790         else {  /* in data */
 791                 mao = (*matarar)[act - 1];
 792                 if (mao)
 793                         id_us_min(&mao->id);
 794                 (*matarar)[act - 1] = ma;
 795                 test_all_objects_materials(G.main, ob->data);  /* Data may be used by several objects... */
 796         }
 797
 798         if (ma)
 799                 id_us_plus(&ma->id);
 800 }
 801
 802
 803 void BKE_material_remap_object(Object *ob, const unsigned int *remap)
 804 {
 805         Material ***matar = give_matarar(ob);
 806         const short *totcol_p = give_totcolp(ob);
 807
 808         BLI_array_permute(ob->mat, ob->totcol, remap);
 809
 810         if (ob->matbits) {
 811                 BLI_array_permute(ob->matbits, ob->totcol, remap);
 812         }
 813
 814         if (matar) {
 815                 BLI_array_permute(*matar, *totcol_p, remap);
 816         }
 817
 818         if (ob->type == OB_MESH) {
 819                 BKE_mesh_material_remap(ob->data, remap, ob->totcol);
 820         }
 821         else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
 822                 BKE_curve_material_remap(ob->data, remap, ob->totcol);
 823         }
 824         else {
 825                 /* add support for this object data! */
 826                 BLI_assert(matar == NULL);
 827         }
 828 }
 829
 830 /**
 831  * Calculate a material remapping from \a ob_src to \a ob_dst.
 832  *
 833  * \param remap_src_to_dst: An array the size of `ob_src->totcol`
 834  * where index values are filled in which map to \a ob_dst materials.
 835  */
 836 void BKE_material_remap_object_calc(
 837         Object *ob_dst, Object *ob_src,
 838         short *remap_src_to_dst)
 839 {
 840         if (ob_src->totcol == 0) {
 841                 return;
 842         }
 843
 844         GHash *gh_mat_map = BLI_ghash_ptr_new_ex(__func__, ob_src->totcol);
 845
 846         for (int i = 0; i < ob_dst->totcol; i++) {
 847                 Material *ma_src = give_current_material(ob_dst, i + 1);
 848                 BLI_ghash_reinsert(gh_mat_map, ma_src, SET_INT_IN_POINTER(i), NULL, NULL);
 849         }
 850
 851         /* setup default mapping (when materials don't match) */
 852         {
 853                 int i = 0;
 854                 if (ob_dst->totcol >= ob_src->totcol) {
 855                         for (; i < ob_src->totcol; i++) {
 856                                 remap_src_to_dst[i] = i;
 857                         }
 858                 }
 859                 else {
 860                         for (; i < ob_dst->totcol; i++) {
 861                                 remap_src_to_dst[i] = i;
 862                         }
 863                         for (; i < ob_src->totcol; i++) {
 864                                 remap_src_to_dst[i] = 0;
 865                         }
 866                 }
 867         }
 868
 869         for (int i = 0; i < ob_src->totcol; i++) {
 870                 Material *ma_src = give_current_material(ob_src, i + 1);
 871
 872                 if ((i < ob_dst->totcol) && (ma_src == give_current_material(ob_dst, i + 1))) {
 873                         /* when objects have exact matching materials - keep existing index */
 874                 }
 875                 else {
 876                         void **index_src_p = BLI_ghash_lookup_p(gh_mat_map, ma_src);
 877                         if (index_src_p) {
 878                                 remap_src_to_dst[i] = GET_INT_FROM_POINTER(*index_src_p);
 879                         }
 880                 }
 881         }
 882
 883         BLI_ghash_free(gh_mat_map, NULL, NULL);
 884 }
 885
 886
 887 /* XXX - this calls many more update calls per object then are needed, could be optimized */
 888 void assign_matarar(struct Object *ob, struct Material ***matar, short totcol)
 889 {
 890         int actcol_orig = ob->actcol;
 891         short i;
 892
 893         while ((ob->totcol > totcol) &&
 894                BKE_object_material_slot_remove(ob))
 895         {
 896                 /* pass */
 897         }
 898
 899         /* now we have the right number of slots */
 900         for (i = 0; i < totcol; i++)
 901                 assign_material(ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
 902
 903         if (actcol_orig > ob->totcol)
 904                 actcol_orig = ob->totcol;
 905
 906         ob->actcol = actcol_orig;
 907 }
 908
 909
 910 short BKE_object_material_slot_find_index(Object *ob, Material *ma)
 911 {
 912         Material ***matarar;
 913         short a, *totcolp;
 914
 915         if (ma == NULL) return 0;
 916
 917         totcolp = give_totcolp(ob);
 918         matarar = give_matarar(ob);
 919
 920         if (totcolp == NULL || matarar == NULL) return 0;
 921
 922         for (a = 0; a < *totcolp; a++)
 923                 if ((*matarar)[a] == ma)
 924                         break;
 925         if (a < *totcolp)
 926                 return a + 1;
 927         return 0;
 928 }
 929
 930 bool BKE_object_material_slot_add(Object *ob)
 931 {
 932         if (ob == NULL) return false;
 933         if (ob->totcol >= MAXMAT) return false;
 934
 935         assign_material(ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
 936         ob->actcol = ob->totcol;
 937         return true;
 938 }
 939
 940 static void do_init_render_material(Material *ma, int r_mode, float *amb)
 941 {
 942         MTex *mtex;
 943         int a, needuv = 0, needtang = 0;
 944
 945         if (ma->flarec == 0) ma->flarec = 1;
 946
 947         /* add all texcoflags from mtex, texco and mapto were cleared in advance */
 948         for (a = 0; a < MAX_MTEX; a++) {
 949
 950                 /* separate tex switching */
 951                 if (ma->septex & (1 << a)) continue;
 952
 953                 mtex = ma->mtex[a];
 954                 if (mtex && mtex->tex && (mtex->tex->type | (mtex->tex->use_nodes && mtex->tex->nodetree) )) {
 955
 956                         ma->texco |= mtex->texco;
 957                         ma->mapto |= mtex->mapto;
 958
 959                         /* always get derivatives for these textures */
 960                         if (ELEM(mtex->tex->type, TEX_IMAGE, TEX_ENVMAP)) ma->texco |= TEXCO_OSA;
 961                         else if (mtex->texflag & (MTEX_COMPAT_BUMP | MTEX_3TAP_BUMP | MTEX_5TAP_BUMP | MTEX_BICUBIC_BUMP)) ma->texco |= TEXCO_OSA;
 962
 963                         if (ma->texco & (TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM | TEXCO_STRAND | TEXCO_STRESS)) needuv = 1;
 964                         else if (ma->texco & (TEXCO_GLOB | TEXCO_UV | TEXCO_OBJECT | TEXCO_SPEED)) needuv = 1;
 965                         else if (ma->texco & (TEXCO_LAVECTOR | TEXCO_VIEW)) needuv = 1;
 966
 967                         if ((ma->mapto & MAP_NORM) && (mtex->normapspace == MTEX_NSPACE_TANGENT))
 968                                 needtang = 1;
 969                 }
 970         }
 971
 972         if (needtang) ma->mode |= MA_NORMAP_TANG;
 973         else ma->mode &= ~MA_NORMAP_TANG;
 974
 975         if (ma->mode & (MA_VERTEXCOL | MA_VERTEXCOLP)) {
 976                 needuv = 1;
 977                 if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;     /* for texfaces */
 978         }
 979         if (needuv) ma->texco |= NEED_UV;
 980
 981         /* since the raytracer doesnt recalc O structs for each ray, we have to preset them all */
 982         if (r_mode & R_RAYTRACE) {
 983                 if ((ma->mode & (MA_RAYMIRROR | MA_SHADOW_TRA)) || ((ma->mode & MA_TRANSP) && (ma->mode & MA_RAYTRANSP))) {
 984                         ma->texco |= NEED_UV | TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM;
 985                         if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;
 986                 }
 987         }
 988
 989         if (amb) {
 990                 ma->ambr = ma->amb * amb[0];
 991                 ma->ambg = ma->amb * amb[1];
 992                 ma->ambb = ma->amb * amb[2];
 993         }
 994
 995         /* local group override */
 996         if ((ma->shade_flag & MA_GROUP_LOCAL) && ma->id.lib && ma->group && ma->group->id.lib) {
 997                 Group *group;
 998
 999                 for (group = G.main->group.first; group; group = group->id.next) {
1000                         if (!ID_IS_LINKED_DATABLOCK(group) && STREQ(group->id.name, ma->group->id.name)) {
1001                                 ma->group = group;
1002                         }
1003                 }
1004         }
1005 }
1006
1007 static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode, float *amb)
1008 {
1009         bNode *node;
1010
1011         /* parses the geom+tex nodes */
1012         ntreeShaderGetTexcoMode(ntree, r_mode, &basemat->texco, &basemat->mode_l);
1013         for (node = ntree->nodes.first; node; node = node->next) {
1014                 if (node->id) {
1015                         if (GS(node->id->name) == ID_MA) {
1016                                 Material *ma = (Material *)node->id;
1017                                 if (ma != basemat) {
1018                                         do_init_render_material(ma, r_mode, amb);
1019                                         basemat->texco |= ma->texco;
1020                                 }
1021
1022                                 basemat->mode_l |= ma->mode & ~(MA_MODE_PIPELINE | MA_SHLESS);
1023                                 basemat->mode2_l |= ma->mode2 & ~MA_MODE2_PIPELINE;
1024                                 /* basemat only considered shadeless if all node materials are too */
1025                                 if (!(ma->mode & MA_SHLESS))
1026                                         basemat->mode_l &= ~MA_SHLESS;
1027
1028                                 if (ma->strand_surfnor > 0.0f)
1029                                         basemat->mode_l |= MA_STR_SURFDIFF;
1030                         }
1031                         else if (node->type == NODE_GROUP)
1032                                 init_render_nodetree((bNodeTree *)node->id, basemat, r_mode, amb);
1033                 }
1034                 else if (node->typeinfo->type == SH_NODE_NORMAL_MAP) {
1035                         basemat->mode2_l |= MA_TANGENT_CONCRETE;
1036                         NodeShaderNormalMap *nm = node->storage;
1037                         bool taken_into_account = false;
1038                         for (int i = 0; i < basemat->nmap_tangent_names_count; i++) {
1039                                 if (STREQ(basemat->nmap_tangent_names[i], nm->uv_map)) {
1040                                         taken_into_account = true;
1041                                         break;
1042                                 }
1043                         }
1044                         if (!taken_into_account) {
1045                                 BLI_assert(basemat->nmap_tangent_names_count < MAX_MTFACE + 1);
1046                                 strcpy(basemat->nmap_tangent_names[basemat->nmap_tangent_names_count++], nm->uv_map);
1047                         }
1048                 }
1049         }
1050 }
1051
1052 void init_render_material(Material *mat, int r_mode, float *amb)
1053 {
1054
1055         do_init_render_material(mat, r_mode, amb);
1056
1057         if (mat->nodetree && mat->use_nodes) {
1058                 /* mode_l will take the pipeline options from the main material, and the or-ed
1059                  * result of non-pipeline options from the nodes. shadeless is an exception,
1060                  * mode_l will have it set when all node materials are shadeless. */
1061                 mat->mode_l = (mat->mode & MA_MODE_PIPELINE) | MA_SHLESS;
1062                 mat->mode2_l = mat->mode2 & MA_MODE2_PIPELINE;
1063                 mat->nmap_tangent_names_count = 0;
1064                 init_render_nodetree(mat->nodetree, mat, r_mode, amb);
1065
1066                 if (!mat->nodetree->execdata)
1067                         mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree);
1068         }
1069         else {
1070                 mat->mode_l = mat->mode;
1071                 mat->mode2_l = mat->mode2;
1072
1073                 if (mat->strand_surfnor > 0.0f)
1074                         mat->mode_l |= MA_STR_SURFDIFF;
1075         }
1076 }
1077
1078 void init_render_materials(Main *bmain, int r_mode, float *amb, bool do_default_material)
1079 {
1080         Material *ma;
1081
1082         /* clear these flags before going over materials, to make sure they
1083          * are cleared only once, otherwise node materials contained in other
1084          * node materials can go wrong */
1085         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1086                 if (ma->id.us) {
1087                         ma->texco = 0;
1088                         ma->mapto = 0;
1089                 }
1090         }
1091
1092         /* two steps, first initialize, then or the flags for layers */
1093         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1094                 /* is_used flag comes back in convertblender.c */
1095                 ma->flag &= ~MA_IS_USED;
1096                 if (ma->id.us)
1097                         init_render_material(ma, r_mode, amb);
1098         }
1099
1100         if (do_default_material) {
1101                 init_render_material(&defmaterial, r_mode, amb);
1102         }
1103 }
1104
1105 /* only needed for nodes now */
1106 void end_render_material(Material *mat)
1107 {
1108         if (mat && mat->nodetree && mat->use_nodes) {
1109                 if (mat->nodetree->execdata)
1110                         ntreeShaderEndExecTree(mat->nodetree->execdata);
1111         }
1112 }
1113
1114 void end_render_materials(Main *bmain)
1115 {
1116         Material *ma;
1117         for (ma = bmain->mat.first; ma; ma = ma->id.next)
1118                 if (ma->id.us)
1119                         end_render_material(ma);
1120 }
1121
1122 static bool material_in_nodetree(bNodeTree *ntree, Material *mat)
1123 {
1124         bNode *node;
1125
1126         for (node = ntree->nodes.first; node; node = node->next) {
1127                 if (node->id) {
1128                         if (GS(node->id->name) == ID_MA) {
1129                                 if (node->id == (ID *)mat) {
1130                                         return true;
1131                                 }
1132                         }
1133                         else if (node->type == NODE_GROUP) {
1134                                 if (material_in_nodetree((bNodeTree *)node->id, mat)) {
1135                                         return true;
1136                                 }
1137                         }
1138                 }
1139         }
1140
1141         return false;
1142 }
1143
1144 bool material_in_material(Material *parmat, Material *mat)
1145 {
1146         if (parmat == mat)
1147                 return true;
1148         else if (parmat->nodetree && parmat->use_nodes)
1149                 return material_in_nodetree(parmat->nodetree, mat);
1150         else
1151                 return false;
1152 }
1153
1154
1155 /* ****************** */
1156
1157 /* Update drivers for materials in a nodetree */
1158 static void material_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
1159 {
1160         bNode *node;
1161
1162         /* nodetree itself */
1163         if (ntree->adt && ntree->adt->drivers.first) {
1164                 BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
1165         }
1166
1167         /* nodes */
1168         for (node = ntree->nodes.first; node; node = node->next) {
1169                 if (node->id) {
1170                         if (GS(node->id->name) == ID_MA) {
1171                                 material_drivers_update(scene, (Material *)node->id, ctime);
1172                         }
1173                         else if (node->type == NODE_GROUP) {
1174                                 material_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
1175                         }
1176                 }
1177         }
1178 }
1179
1180 /* Calculate all drivers for materials
1181  * FIXME: this is really a terrible method which may result in some things being calculated
1182  * multiple times. However, without proper despgraph support for these things, we are forced
1183  * into this sort of thing...
1184  */
1185 void material_drivers_update(Scene *scene, Material *ma, float ctime)
1186 {
1187         //if (G.f & G_DEBUG)
1188         //      printf("material_drivers_update(%s, %s)\n", scene->id.name, ma->id.name);
1189
1190         /* Prevent infinite recursion by checking (and tagging the material) as having been visited already
1191          * (see BKE_scene_update_tagged()). This assumes ma->id.tag & LIB_TAG_DOIT isn't set by anything else
1192          * in the meantime... [#32017]
1193          */
1194         if (ma->id.tag & LIB_TAG_DOIT)
1195                 return;
1196
1197         ma->id.tag |= LIB_TAG_DOIT;
1198
1199         /* material itself */
1200         if (ma->adt && ma->adt->drivers.first) {
1201                 BKE_animsys_evaluate_animdata(scene, &ma->id, ma->adt, ctime, ADT_RECALC_DRIVERS);
1202         }
1203
1204         /* nodes */
1205         if (ma->nodetree) {
1206                 material_node_drivers_update(scene, ma->nodetree, ctime);
1207         }
1208
1209         ma->id.tag &= ~LIB_TAG_DOIT;
1210 }
1211
1212 bool BKE_object_material_slot_remove(Object *ob)
1213 {
1214         Material *mao, ***matarar;
1215         Object *obt;
1216         short *totcolp;
1217         short a, actcol;
1218
1219         if (ob == NULL || ob->totcol == 0) {
1220                 return false;
1221         }
1222
1223         /* this should never happen and used to crash */
1224         if (ob->actcol <= 0) {
1225                 printf("%s: invalid material index %d, report a bug!\n", __func__, ob->actcol);
1226                 BLI_assert(0);
1227                 return false;
1228         }
1229
1230         /* take a mesh/curve/mball as starting point, remove 1 index,
1231          * AND with all objects that share the ob->data
1232          *
1233          * after that check indices in mesh/curve/mball!!!
1234          */
1235
1236         totcolp = give_totcolp(ob);
1237         matarar = give_matarar(ob);
1238
1239         if (ELEM(NULL, matarar, *matarar)) {
1240                 return false;
1241         }
1242
1243         /* can happen on face selection in editmode */
1244         if (ob->actcol > ob->totcol) {
1245                 ob->actcol = ob->totcol;
1246         }
1247
1248         /* we delete the actcol */
1249         mao = (*matarar)[ob->actcol - 1];
1250         if (mao)
1251                 id_us_min(&mao->id);
1252
1253         for (a = ob->actcol; a < ob->totcol; a++)
1254                 (*matarar)[a - 1] = (*matarar)[a];
1255         (*totcolp)--;
1256
1257         if (*totcolp == 0) {
1258                 MEM_freeN(*matarar);
1259                 *matarar = NULL;
1260         }
1261
1262         actcol = ob->actcol;
1263         obt = G.main->object.first;
1264         while (obt) {
1265
1266                 if (obt->data == ob->data) {
1267
1268                         /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
1269                         mao = obt->mat[actcol - 1];
1270                         if (mao)
1271                                 id_us_min(&mao->id);
1272
1273                         for (a = actcol; a < obt->totcol; a++) {
1274                                 obt->mat[a - 1] = obt->mat[a];
1275                                 obt->matbits[a - 1] = obt->matbits[a];
1276                         }
1277                         obt->totcol--;
1278                         if (obt->actcol > obt->totcol) obt->actcol = obt->totcol;
1279
1280                         if (obt->totcol == 0) {
1281                                 MEM_freeN(obt->mat);
1282                                 MEM_freeN(obt->matbits);
1283                                 obt->mat = NULL;
1284                                 obt->matbits = NULL;
1285                         }
1286                 }
1287                 obt = obt->id.next;
1288         }
1289
1290         /* check indices from mesh */
1291         if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT)) {
1292                 material_data_index_remove_id((ID *)ob->data, actcol - 1);
1293                 if (ob->curve_cache) {
1294                         BKE_displist_free(&ob->curve_cache->disp);
1295                 }
1296         }
1297
1298         return true;
1299 }
1300
1301 static bool get_mtex_slot_valid_texpaint(struct MTex *mtex)
1302 {
1303         return (mtex && (mtex->texco == TEXCO_UV) &&
1304                 mtex->tex && (mtex->tex->type == TEX_IMAGE) &&
1305                 mtex->tex->ima);
1306 }
1307
1308 static bNode *nodetree_uv_node_recursive(bNode *node)
1309 {
1310         bNode *inode;
1311         bNodeSocket *sock;
1312
1313         for (sock = node->inputs.first; sock; sock = sock->next) {
1314                 if (sock->link) {
1315                         inode = sock->link->fromnode;
1316                         if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1317                                 return inode;
1318                         }
1319                         else {
1320                                 return nodetree_uv_node_recursive(inode);
1321                         }
1322                 }
1323         }
1324
1325         return NULL;
1326 }
1327
1328 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1329 {
1330         MTex **mtex;
1331         short count = 0;
1332         short index = 0, i;
1333
1334         bool use_nodes = BKE_scene_use_new_shading_nodes(scene);
1335         bool is_bi = BKE_scene_uses_blender_internal(scene) || BKE_scene_uses_blender_game(scene);
1336
1337         /* XXX, for 2.8 testing & development its useful to have non Cycles/BI engines use material nodes
1338          * In the future we may have some way to check this which each engine can define.
1339          * For now use material slots for Clay/Eevee.
1340          * - Campbell */
1341         if (!(use_nodes || is_bi)) {
1342                 is_bi = true;
1343         }
1344
1345         if (!ma)
1346                 return;
1347
1348         if (ma->texpaintslot) {
1349                 MEM_freeN(ma->texpaintslot);
1350                 ma->tot_slots = 0;
1351                 ma->texpaintslot = NULL;
1352         }
1353
1354         if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1355                 ma->paint_active_slot = 0;
1356                 ma->paint_clone_slot = 0;
1357                 return;
1358         }
1359
1360         if (use_nodes || ma->use_nodes) {
1361                 bNode *node, *active_node;
1362
1363                 if (!(ma->nodetree)) {
1364                         ma->paint_active_slot = 0;
1365                         ma->paint_clone_slot = 0;
1366                         return;
1367                 }
1368
1369                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1370                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id)
1371                                 count++;
1372                 }
1373
1374                 if (count == 0) {
1375                         ma->paint_active_slot = 0;
1376                         ma->paint_clone_slot = 0;
1377                         return;
1378                 }
1379                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1380
1381                 active_node = nodeGetActiveTexture(ma->nodetree);
1382
1383                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1384                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1385                                 if (active_node == node)
1386                                         ma->paint_active_slot = index;
1387                                 ma->texpaintslot[index].ima = (Image *)node->id;
1388
1389                                 /* for new renderer, we need to traverse the treeback in search of a UV node */
1390                                 if (use_nodes) {
1391                                         bNode *uvnode = nodetree_uv_node_recursive(node);
1392
1393                                         if (uvnode) {
1394                                                 NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1395                                                 ma->texpaintslot[index].uvname = storage->uv_map;
1396                                                 /* set a value to index so UI knows that we have a valid pointer for the mesh */
1397                                                 ma->texpaintslot[index].index = 0;
1398                                         }
1399                                         else {
1400                                                 /* just invalidate the index here so UV map does not get displayed on the UI */
1401                                                 ma->texpaintslot[index].index = -1;
1402                                         }
1403                                 }
1404                                 else {
1405                                         ma->texpaintslot[index].index = -1;
1406                                 }
1407                                 index++;
1408                         }
1409                 }
1410         }
1411         else if (is_bi) {
1412                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1413                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1414                                 count++;
1415                         }
1416                 }
1417
1418                 if (count == 0) {
1419                         ma->paint_active_slot = 0;
1420                         ma->paint_clone_slot = 0;
1421                         return;
1422                 }
1423
1424                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1425
1426                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1427                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1428                                 ma->texpaintslot[index].ima = (*mtex)->tex->ima;
1429                                 ma->texpaintslot[index].uvname = (*mtex)->uvname;
1430                                 ma->texpaintslot[index].index = i;
1431
1432                                 index++;
1433                         }
1434                 }
1435         }
1436         else {
1437                 ma->paint_active_slot = 0;
1438                 ma->paint_clone_slot = 0;
1439                 return;
1440         }
1441
1442
1443         ma->tot_slots = count;
1444
1445
1446         if (ma->paint_active_slot >= count) {
1447                 ma->paint_active_slot = count - 1;
1448         }
1449
1450         if (ma->paint_clone_slot >= count) {
1451                 ma->paint_clone_slot = count - 1;
1452         }
1453
1454         return;
1455 }
1456
1457 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1458 {
1459         int i;
1460
1461         for (i = 1; i < ob->totcol + 1; i++) {
1462                 Material *ma = give_current_material(ob, i);
1463                 BKE_texpaint_slot_refresh_cache(scene, ma);
1464         }
1465 }
1466
1467
1468 /* r_col = current value, col = new value, (fac == 0) is no change */
1469 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1470 {
1471         float tmp, facm = 1.0f - fac;
1472
1473         switch (type) {
1474                 case MA_RAMP_BLEND:
1475                         r_col[0] = facm * (r_col[0]) + fac * col[0];
1476                         r_col[1] = facm * (r_col[1]) + fac * col[1];
1477                         r_col[2] = facm * (r_col[2]) + fac * col[2];
1478                         break;
1479                 case MA_RAMP_ADD:
1480                         r_col[0] += fac * col[0];
1481                         r_col[1] += fac * col[1];
1482                         r_col[2] += fac * col[2];
1483                         break;
1484                 case MA_RAMP_MULT:
1485                         r_col[0] *= (facm + fac * col[0]);
1486                         r_col[1] *= (facm + fac * col[1]);
1487                         r_col[2] *= (facm + fac * col[2]);
1488                         break;
1489                 case MA_RAMP_SCREEN:
1490                         r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1491                         r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1492                         r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1493                         break;
1494                 case MA_RAMP_OVERLAY:
1495                         if (r_col[0] < 0.5f)
1496                                 r_col[0] *= (facm + 2.0f * fac * col[0]);
1497                         else
1498                                 r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1499                         if (r_col[1] < 0.5f)
1500                                 r_col[1] *= (facm + 2.0f * fac * col[1]);
1501                         else
1502                                 r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1503                         if (r_col[2] < 0.5f)
1504                                 r_col[2] *= (facm + 2.0f * fac * col[2]);
1505                         else
1506                                 r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1507                         break;
1508                 case MA_RAMP_SUB:
1509                         r_col[0] -= fac * col[0];
1510                         r_col[1] -= fac * col[1];
1511                         r_col[2] -= fac * col[2];
1512                         break;
1513                 case MA_RAMP_DIV:
1514                         if (col[0] != 0.0f)
1515                                 r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1516                         if (col[1] != 0.0f)
1517                                 r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1518                         if (col[2] != 0.0f)
1519                                 r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1520                         break;
1521                 case MA_RAMP_DIFF:
1522                         r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1523                         r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1524                         r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1525                         break;
1526                 case MA_RAMP_DARK:
1527                         r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1528                         r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1529                         r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1530                         break;
1531                 case MA_RAMP_LIGHT:
1532                         tmp = fac * col[0];
1533                         if (tmp > r_col[0]) r_col[0] = tmp;
1534                         tmp = fac * col[1];
1535                         if (tmp > r_col[1]) r_col[1] = tmp;
1536                         tmp = fac * col[2];
1537                         if (tmp > r_col[2]) r_col[2] = tmp;
1538                         break;
1539                 case MA_RAMP_DODGE:
1540                         if (r_col[0] != 0.0f) {
1541                                 tmp = 1.0f - fac * col[0];
1542                                 if (tmp <= 0.0f)
1543                                         r_col[0] = 1.0f;
1544                                 else if ((tmp = (r_col[0]) / tmp) > 1.0f)
1545                                         r_col[0] = 1.0f;
1546                                 else
1547                                         r_col[0] = tmp;
1548                         }
1549                         if (r_col[1] != 0.0f) {
1550                                 tmp = 1.0f - fac * col[1];
1551                                 if (tmp <= 0.0f)
1552                                         r_col[1] = 1.0f;
1553                                 else if ((tmp = (r_col[1]) / tmp) > 1.0f)
1554                                         r_col[1] = 1.0f;
1555                                 else
1556                                         r_col[1] = tmp;
1557                         }
1558                         if (r_col[2] != 0.0f) {
1559                                 tmp = 1.0f - fac * col[2];
1560                                 if (tmp <= 0.0f)
1561                                         r_col[2] = 1.0f;
1562                                 else if ((tmp = (r_col[2]) / tmp) > 1.0f)
1563                                         r_col[2] = 1.0f;
1564                                 else
1565                                         r_col[2] = tmp;
1566                         }
1567                         break;
1568                 case MA_RAMP_BURN:
1569                         tmp = facm + fac * col[0];
1570
1571                         if (tmp <= 0.0f)
1572                                 r_col[0] = 0.0f;
1573                         else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f)
1574                                 r_col[0] = 0.0f;
1575                         else if (tmp > 1.0f)
1576                                 r_col[0] = 1.0f;
1577                         else
1578                                 r_col[0] = tmp;
1579
1580                         tmp = facm + fac * col[1];
1581                         if (tmp <= 0.0f)
1582                                 r_col[1] = 0.0f;
1583                         else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f)
1584                                 r_col[1] = 0.0f;
1585                         else if (tmp > 1.0f)
1586                                 r_col[1] = 1.0f;
1587                         else
1588                                 r_col[1] = tmp;
1589
1590                         tmp = facm + fac * col[2];
1591                         if (tmp <= 0.0f)
1592                                 r_col[2] = 0.0f;
1593                         else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f)
1594                                 r_col[2] = 0.0f;
1595                         else if (tmp > 1.0f)
1596                                 r_col[2] = 1.0f;
1597                         else
1598                                 r_col[2] = tmp;
1599                         break;
1600                 case MA_RAMP_HUE:
1601                 {
1602                         float rH, rS, rV;
1603                         float colH, colS, colV;
1604                         float tmpr, tmpg, tmpb;
1605                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1606                         if (colS != 0) {
1607                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1608                                 hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1609                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1610                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1611                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1612                         }
1613                         break;
1614                 }
1615                 case MA_RAMP_SAT:
1616                 {
1617                         float rH, rS, rV;
1618                         float colH, colS, colV;
1619                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1620                         if (rS != 0) {
1621                                 rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1622                                 hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1623                         }
1624                         break;
1625                 }
1626                 case MA_RAMP_VAL:
1627                 {
1628                         float rH, rS, rV;
1629                         float colH, colS, colV;
1630                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1631                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1632                         hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1633                         break;
1634                 }
1635                 case MA_RAMP_COLOR:
1636                 {
1637                         float rH, rS, rV;
1638                         float colH, colS, colV;
1639                         float tmpr, tmpg, tmpb;
1640                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1641                         if (colS != 0) {
1642                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1643                                 hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1644                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1645                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1646                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1647                         }
1648                         break;
1649                 }
1650                 case MA_RAMP_SOFT:
1651                 {
1652                         float scr, scg, scb;
1653
1654                         /* first calculate non-fac based Screen mix */
1655                         scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1656                         scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1657                         scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1658
1659                         r_col[0] = facm * (r_col[0]) + fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1660                         r_col[1] = facm * (r_col[1]) + fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1661                         r_col[2] = facm * (r_col[2]) + fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1662                         break;
1663                 }
1664                 case MA_RAMP_LINEAR:
1665                         if (col[0] > 0.5f)
1666                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1667                         else
1668                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1669                         if (col[1] > 0.5f)
1670                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1671                         else
1672                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1673                         if (col[2] > 0.5f)
1674                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1675                         else
1676                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1677                         break;
1678         }
1679 }
1680
1681 /**
1682  * \brief copy/paste buffer, if we had a proper py api that would be better
1683  * \note matcopybuf.nodetree does _NOT_ use ID's
1684  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1685  */
1686 static Material matcopybuf;
1687 static short matcopied = 0;
1688
1689 void clear_matcopybuf(void)
1690 {
1691         memset(&matcopybuf, 0, sizeof(Material));
1692         matcopied = 0;
1693 }
1694
1695 void free_matcopybuf(void)
1696 {
1697         int a;
1698
1699         for (a = 0; a < MAX_MTEX; a++) {
1700                 if (matcopybuf.mtex[a]) {
1701                         MEM_freeN(matcopybuf.mtex[a]);
1702                         matcopybuf.mtex[a] = NULL;
1703                 }
1704         }
1705
1706         if (matcopybuf.ramp_col) MEM_freeN(matcopybuf.ramp_col);
1707         if (matcopybuf.ramp_spec) MEM_freeN(matcopybuf.ramp_spec);
1708
1709         matcopybuf.ramp_col = NULL;
1710         matcopybuf.ramp_spec = NULL;
1711
1712         if (matcopybuf.nodetree) {
1713                 ntreeFreeTree(matcopybuf.nodetree);
1714                 MEM_freeN(matcopybuf.nodetree);
1715                 matcopybuf.nodetree = NULL;
1716         }
1717
1718         matcopied = 0;
1719 }
1720
1721 void copy_matcopybuf(Material *ma)
1722 {
1723         int a;
1724         MTex *mtex;
1725
1726         if (matcopied)
1727                 free_matcopybuf();
1728
1729         memcpy(&matcopybuf, ma, sizeof(Material));
1730         if (matcopybuf.ramp_col) matcopybuf.ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1731         if (matcopybuf.ramp_spec) matcopybuf.ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1732
1733         for (a = 0; a < MAX_MTEX; a++) {
1734                 mtex = matcopybuf.mtex[a];
1735                 if (mtex) {
1736                         matcopybuf.mtex[a] = MEM_dupallocN(mtex);
1737                 }
1738         }
1739         matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, G.main, false);
1740         matcopybuf.preview = NULL;
1741         BLI_listbase_clear(&matcopybuf.gpumaterial);
1742         /* TODO Duplicate Engine Settings and set runtime to NULL */
1743         matcopied = 1;
1744 }
1745
1746 void paste_matcopybuf(Material *ma)
1747 {
1748         int a;
1749         MTex *mtex;
1750         ID id;
1751
1752         if (matcopied == 0)
1753                 return;
1754         /* free current mat */
1755         if (ma->ramp_col) MEM_freeN(ma->ramp_col);
1756         if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
1757         for (a = 0; a < MAX_MTEX; a++) {
1758                 mtex = ma->mtex[a];
1759                 if (mtex && mtex->tex)
1760                         id_us_min(&mtex->tex->id);
1761                 if (mtex)
1762                         MEM_freeN(mtex);
1763         }
1764
1765         if (ma->nodetree) {
1766                 ntreeFreeTree(ma->nodetree);
1767                 MEM_freeN(ma->nodetree);
1768         }
1769
1770         GPU_material_free(&ma->gpumaterial);
1771
1772         id = (ma->id);
1773         memcpy(ma, &matcopybuf, sizeof(Material));
1774         (ma->id) = id;
1775
1776         if (matcopybuf.ramp_col) ma->ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1777         if (matcopybuf.ramp_spec) ma->ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1778
1779         for (a = 0; a < MAX_MTEX; a++) {
1780                 mtex = ma->mtex[a];
1781                 if (mtex) {
1782                         ma->mtex[a] = MEM_dupallocN(mtex);
1783                         if (mtex->tex) {
1784                                 /* first check this is in main (we may have loaded another file) [#35500] */
1785                                 if (BLI_findindex(&G.main->tex, mtex->tex) != -1) {
1786                                         id_us_plus((ID *)mtex->tex);
1787                                 }
1788                                 else {
1789                                         ma->mtex[a]->tex = NULL;
1790                                 }
1791                         }
1792                 }
1793         }
1794
1795         ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, G.main, false);
1796 }
1797
1798 struct Image *BKE_object_material_edit_image_get(Object *ob, short mat_nr)
1799 {
1800         Material *ma = give_current_material(ob, mat_nr + 1);
1801         return ma ? ma->edit_image : NULL;
1802 }
1803
1804 struct Image **BKE_object_material_edit_image_get_array(Object *ob)
1805 {
1806         Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
1807         for (int i = 0; i < ob->totcol; i++) {
1808                 image_array[i] = BKE_object_material_edit_image_get(ob, i);
1809         }
1810         return image_array;
1811 }
1812
1813 bool BKE_object_material_edit_image_set(Object *ob, short mat_nr, Image *image)
1814 {
1815         Material *ma = give_current_material(ob, mat_nr + 1);
1816         if (ma) {
1817                 /* both may be NULL */
1818                 id_us_min((ID *)ma->edit_image);
1819                 ma->edit_image = image;
1820                 id_us_plus((ID *)ma->edit_image);
1821                 return true;
1822         }
1823         return false;
1824 }
1825
1826 void BKE_material_eval(const struct EvaluationContext *UNUSED(eval_ctx), Material *material)
1827 {
1828         if (G.debug & G_DEBUG_DEPSGRAPH) {
1829                 printf("%s on %s (%p)\n", __func__, material->id.name, material);
1830         }
1831         if ((BLI_listbase_is_empty(&material->gpumaterial) == false)) {
1832                 GPU_material_uniform_buffer_tag_dirty(&material->gpumaterial);
1833         }
1834 }