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_main.h"
  65 #include "BKE_material.h"
  66 #include "BKE_mesh.h"
  67 #include "BKE_scene.h"
  68 #include "BKE_node.h"
  69 #include "BKE_curve.h"
  70 #include "BKE_editmesh.h"
  71 #include "BKE_font.h"
  72
  73 #include "GPU_material.h"
  74
  75 /* used in UI and render */
  76 Material defmaterial;
  77
  78 /* called on startup, creator.c */
  79 void init_def_material(void)
  80 {
  81         init_material(&defmaterial);
  82 }
  83
  84 /* not material itself */
  85 void BKE_material_free(Material *ma)
  86 {
  87         BKE_material_free_ex(ma, true);
  88 }
  89
  90 /* not material itself */
  91 void BKE_material_free_ex(Material *ma, bool do_id_user)
  92 {
  93         MTex *mtex;
  94         int a;
  95
  96         for (a = 0; a < MAX_MTEX; a++) {
  97                 mtex = ma->mtex[a];
  98                 if (do_id_user && mtex && mtex->tex) mtex->tex->id.us--;
  99                 if (mtex) MEM_freeN(mtex);
 100         }
 101
 102         if (ma->ramp_col) MEM_freeN(ma->ramp_col);
 103         if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
 104
 105         BKE_animdata_free((ID *)ma);
 106
 107         if (ma->preview)
 108                 BKE_previewimg_free(&ma->preview);
 109         BKE_icon_delete((struct ID *)ma);
 110         ma->id.icon_id = 0;
 111
 112         /* is no lib link block, but material extension */
 113         if (ma->nodetree) {
 114                 ntreeFreeTree_ex(ma->nodetree, do_id_user);
 115                 MEM_freeN(ma->nodetree);
 116         }
 117
 118         if (ma->texpaintslot)
 119                 MEM_freeN(ma->texpaintslot);
 120
 121         if (ma->gpumaterial.first)
 122                 GPU_material_free(&ma->gpumaterial);
 123 }
 124
 125 void init_material(Material *ma)
 126 {
 127         ma->r = ma->g = ma->b = ma->ref = 0.8;
 128         ma->specr = ma->specg = ma->specb = 1.0;
 129         ma->mirr = ma->mirg = ma->mirb = 1.0;
 130         ma->spectra = 1.0;
 131         ma->amb = 1.0;
 132         ma->alpha = 1.0;
 133         ma->spec = ma->hasize = 0.5;
 134         ma->har = 50;
 135         ma->starc = ma->ringc = 4;
 136         ma->linec = 12;
 137         ma->flarec = 1;
 138         ma->flaresize = ma->subsize = 1.0;
 139         ma->flareboost = 1;
 140         ma->seed2 = 6;
 141         ma->friction = 0.5;
 142         ma->refrac = 4.0;
 143         ma->roughness = 0.5;
 144         ma->param[0] = 0.5;
 145         ma->param[1] = 0.1;
 146         ma->param[2] = 0.5;
 147         ma->param[3] = 0.1;
 148         ma->rms = 0.1;
 149         ma->darkness = 1.0;
 150
 151         ma->strand_sta = ma->strand_end = 1.0f;
 152
 153         ma->ang = 1.0;
 154         ma->ray_depth = 2;
 155         ma->ray_depth_tra = 2;
 156         ma->fresnel_mir = 0.0;
 157         ma->fresnel_tra = 0.0;
 158         ma->fresnel_tra_i = 1.25;
 159         ma->fresnel_mir_i = 1.25;
 160         ma->tx_limit = 0.0;
 161         ma->tx_falloff = 1.0;
 162         ma->shad_alpha = 1.0f;
 163         ma->vcol_alpha = 0;
 164
 165         ma->gloss_mir = ma->gloss_tra = 1.0;
 166         ma->samp_gloss_mir = ma->samp_gloss_tra = 18;
 167         ma->adapt_thresh_mir = ma->adapt_thresh_tra = 0.005;
 168         ma->dist_mir = 0.0;
 169         ma->fadeto_mir = MA_RAYMIR_FADETOSKY;
 170
 171         ma->rampfac_col = 1.0;
 172         ma->rampfac_spec = 1.0;
 173         ma->pr_lamp = 3;         /* two lamps, is bits */
 174         ma->pr_type = MA_SPHERE;
 175
 176         ma->sss_radius[0] = 1.0f;
 177         ma->sss_radius[1] = 1.0f;
 178         ma->sss_radius[2] = 1.0f;
 179         ma->sss_col[0] = 1.0f;
 180         ma->sss_col[1] = 1.0f;
 181         ma->sss_col[2] = 1.0f;
 182         ma->sss_error = 0.05f;
 183         ma->sss_scale = 0.1f;
 184         ma->sss_ior = 1.3f;
 185         ma->sss_colfac = 1.0f;
 186         ma->sss_texfac = 0.0f;
 187         ma->sss_front = 1.0f;
 188         ma->sss_back = 1.0f;
 189
 190         ma->vol.density = 1.0f;
 191         ma->vol.emission = 0.0f;
 192         ma->vol.scattering = 1.0f;
 193         ma->vol.reflection = 1.0f;
 194         ma->vol.transmission_col[0] = ma->vol.transmission_col[1] = ma->vol.transmission_col[2] = 1.0f;
 195         ma->vol.reflection_col[0] = ma->vol.reflection_col[1] = ma->vol.reflection_col[2] = 1.0f;
 196         ma->vol.emission_col[0] = ma->vol.emission_col[1] = ma->vol.emission_col[2] = 1.0f;
 197         ma->vol.density_scale = 1.0f;
 198         ma->vol.depth_cutoff = 0.01f;
 199         ma->vol.stepsize_type = MA_VOL_STEP_RANDOMIZED;
 200         ma->vol.stepsize = 0.2f;
 201         ma->vol.shade_type = MA_VOL_SHADE_SHADED;
 202         ma->vol.shadeflag |= MA_VOL_PRECACHESHADING;
 203         ma->vol.precache_resolution = 50;
 204         ma->vol.ms_spread = 0.2f;
 205         ma->vol.ms_diff = 1.f;
 206         ma->vol.ms_intensity = 1.f;
 207
 208         ma->game.flag = GEMAT_BACKCULL;
 209         ma->game.alpha_blend = 0;
 210         ma->game.face_orientation = 0;
 211
 212         ma->mode = MA_TRACEBLE | MA_SHADBUF | MA_SHADOW | MA_RAYBIAS | MA_TANGENT_STR | MA_ZTRANSP;
 213         ma->mode2 = MA_CASTSHADOW;
 214         ma->shade_flag = MA_APPROX_OCCLUSION;
 215         ma->preview = NULL;
 216 }
 217
 218 Material *BKE_material_add(Main *bmain, const char *name)
 219 {
 220         Material *ma;
 221
 222         ma = BKE_libblock_alloc(bmain, ID_MA, name);
 223
 224         init_material(ma);
 225
 226         return ma;
 227 }
 228
 229 /* XXX keep synced with next function */
 230 Material *BKE_material_copy(Material *ma)
 231 {
 232         Material *man;
 233         int a;
 234
 235         man = BKE_libblock_copy(&ma->id);
 236
 237         id_lib_extern((ID *)man->group);
 238
 239         for (a = 0; a < MAX_MTEX; a++) {
 240                 if (ma->mtex[a]) {
 241                         man->mtex[a] = MEM_mallocN(sizeof(MTex), "copymaterial");
 242                         memcpy(man->mtex[a], ma->mtex[a], sizeof(MTex));
 243                         id_us_plus((ID *)man->mtex[a]->tex);
 244                 }
 245         }
 246
 247         if (ma->ramp_col) man->ramp_col = MEM_dupallocN(ma->ramp_col);
 248         if (ma->ramp_spec) man->ramp_spec = MEM_dupallocN(ma->ramp_spec);
 249
 250         if (ma->preview) man->preview = BKE_previewimg_copy(ma->preview);
 251
 252         if (ma->nodetree) {
 253                 man->nodetree = ntreeCopyTree(ma->nodetree);
 254         }
 255
 256         BLI_listbase_clear(&man->gpumaterial);
 257
 258         if (ma->id.lib) {
 259                 BKE_id_lib_local_paths(G.main, ma->id.lib, &man->id);
 260         }
 261
 262         return man;
 263 }
 264
 265 /* XXX (see above) material copy without adding to main dbase */
 266 Material *localize_material(Material *ma)
 267 {
 268         Material *man;
 269         int a;
 270
 271         man = BKE_libblock_copy_nolib(&ma->id, false);
 272
 273         /* no increment for texture ID users, in previewrender.c it prevents decrement */
 274         for (a = 0; a < MAX_MTEX; a++) {
 275                 if (ma->mtex[a]) {
 276                         man->mtex[a] = MEM_mallocN(sizeof(MTex), "copymaterial");
 277                         memcpy(man->mtex[a], ma->mtex[a], sizeof(MTex));
 278                 }
 279         }
 280
 281         if (ma->ramp_col) man->ramp_col = MEM_dupallocN(ma->ramp_col);
 282         if (ma->ramp_spec) man->ramp_spec = MEM_dupallocN(ma->ramp_spec);
 283
 284         man->texpaintslot = NULL;
 285         man->preview = NULL;
 286
 287         if (ma->nodetree)
 288                 man->nodetree = ntreeLocalize(ma->nodetree);
 289
 290         BLI_listbase_clear(&man->gpumaterial);
 291
 292         return man;
 293 }
 294
 295 static void extern_local_material(Material *ma)
 296 {
 297         int i;
 298         for (i = 0; i < MAX_MTEX; i++) {
 299                 if (ma->mtex[i]) id_lib_extern((ID *)ma->mtex[i]->tex);
 300         }
 301 }
 302
 303 void BKE_material_make_local(Material *ma)
 304 {
 305         Main *bmain = G.main;
 306         Object *ob;
 307         Mesh *me;
 308         Curve *cu;
 309         MetaBall *mb;
 310         int a;
 311         bool is_local = false, is_lib = false;
 312
 313         /* - only lib users: do nothing
 314          * - only local users: set flag
 315          * - mixed: make copy
 316          */
 317
 318         if (ma->id.lib == NULL) return;
 319
 320         /* One local user; set flag and return. */
 321         if (ma->id.us == 1) {
 322                 id_clear_lib_data(bmain, &ma->id);
 323                 extern_local_material(ma);
 324                 return;
 325         }
 326
 327         /* Check which other IDs reference this one to determine if it's used by
 328          * lib or local */
 329         /* test objects */
 330         ob = bmain->object.first;
 331         while (ob) {
 332                 if (ob->mat) {
 333                         for (a = 0; a < ob->totcol; a++) {
 334                                 if (ob->mat[a] == ma) {
 335                                         if (ob->id.lib) is_lib = true;
 336                                         else is_local = true;
 337                                 }
 338                         }
 339                 }
 340                 ob = ob->id.next;
 341         }
 342         /* test meshes */
 343         me = bmain->mesh.first;
 344         while (me) {
 345                 if (me->mat) {
 346                         for (a = 0; a < me->totcol; a++) {
 347                                 if (me->mat[a] == ma) {
 348                                         if (me->id.lib) is_lib = true;
 349                                         else is_local = true;
 350                                 }
 351                         }
 352                 }
 353                 me = me->id.next;
 354         }
 355         /* test curves */
 356         cu = bmain->curve.first;
 357         while (cu) {
 358                 if (cu->mat) {
 359                         for (a = 0; a < cu->totcol; a++) {
 360                                 if (cu->mat[a] == ma) {
 361                                         if (cu->id.lib) is_lib = true;
 362                                         else is_local = true;
 363                                 }
 364                         }
 365                 }
 366                 cu = cu->id.next;
 367         }
 368         /* test mballs */
 369         mb = bmain->mball.first;
 370         while (mb) {
 371                 if (mb->mat) {
 372                         for (a = 0; a < mb->totcol; a++) {
 373                                 if (mb->mat[a] == ma) {
 374                                         if (mb->id.lib) is_lib = true;
 375                                         else is_local = true;
 376                                 }
 377                         }
 378                 }
 379                 mb = mb->id.next;
 380         }
 381
 382         /* Only local users. */
 383         if (is_local && is_lib == false) {
 384                 id_clear_lib_data(bmain, &ma->id);
 385                 extern_local_material(ma);
 386         }
 387         /* Both user and local, so copy. */
 388         else if (is_local && is_lib) {
 389                 Material *ma_new = BKE_material_copy(ma);
 390
 391                 ma_new->id.us = 0;
 392
 393                 /* Remap paths of new ID using old library as base. */
 394                 BKE_id_lib_local_paths(bmain, ma->id.lib, &ma_new->id);
 395
 396                 /* do objects */
 397                 ob = bmain->object.first;
 398                 while (ob) {
 399                         if (ob->mat) {
 400                                 for (a = 0; a < ob->totcol; a++) {
 401                                         if (ob->mat[a] == ma) {
 402                                                 if (ob->id.lib == NULL) {
 403                                                         ob->mat[a] = ma_new;
 404                                                         ma_new->id.us++;
 405                                                         ma->id.us--;
 406                                                 }
 407                                         }
 408                                 }
 409                         }
 410                         ob = ob->id.next;
 411                 }
 412                 /* do meshes */
 413                 me = bmain->mesh.first;
 414                 while (me) {
 415                         if (me->mat) {
 416                                 for (a = 0; a < me->totcol; a++) {
 417                                         if (me->mat[a] == ma) {
 418                                                 if (me->id.lib == NULL) {
 419                                                         me->mat[a] = ma_new;
 420                                                         ma_new->id.us++;
 421                                                         ma->id.us--;
 422                                                 }
 423                                         }
 424                                 }
 425                         }
 426                         me = me->id.next;
 427                 }
 428                 /* do curves */
 429                 cu = bmain->curve.first;
 430                 while (cu) {
 431                         if (cu->mat) {
 432                                 for (a = 0; a < cu->totcol; a++) {
 433                                         if (cu->mat[a] == ma) {
 434                                                 if (cu->id.lib == NULL) {
 435                                                         cu->mat[a] = ma_new;
 436                                                         ma_new->id.us++;
 437                                                         ma->id.us--;
 438                                                 }
 439                                         }
 440                                 }
 441                         }
 442                         cu = cu->id.next;
 443                 }
 444                 /* do mballs */
 445                 mb = bmain->mball.first;
 446                 while (mb) {
 447                         if (mb->mat) {
 448                                 for (a = 0; a < mb->totcol; a++) {
 449                                         if (mb->mat[a] == ma) {
 450                                                 if (mb->id.lib == NULL) {
 451                                                         mb->mat[a] = ma_new;
 452                                                         ma_new->id.us++;
 453                                                         ma->id.us--;
 454                                                 }
 455                                         }
 456                                 }
 457                         }
 458                         mb = mb->id.next;
 459                 }
 460         }
 461 }
 462
 463 /* for curve, mball, mesh types */
 464 void extern_local_matarar(struct Material **matar, short totcol)
 465 {
 466         short i;
 467         for (i = 0; i < totcol; i++) {
 468                 id_lib_extern((ID *)matar[i]);
 469         }
 470 }
 471
 472 Material ***give_matarar(Object *ob)
 473 {
 474         Mesh *me;
 475         Curve *cu;
 476         MetaBall *mb;
 477
 478         if (ob->type == OB_MESH) {
 479                 me = ob->data;
 480                 return &(me->mat);
 481         }
 482         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
 483                 cu = ob->data;
 484                 return &(cu->mat);
 485         }
 486         else if (ob->type == OB_MBALL) {
 487                 mb = ob->data;
 488                 return &(mb->mat);
 489         }
 490         return NULL;
 491 }
 492
 493 short *give_totcolp(Object *ob)
 494 {
 495         Mesh *me;
 496         Curve *cu;
 497         MetaBall *mb;
 498
 499         if (ob->type == OB_MESH) {
 500                 me = ob->data;
 501                 return &(me->totcol);
 502         }
 503         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
 504                 cu = ob->data;
 505                 return &(cu->totcol);
 506         }
 507         else if (ob->type == OB_MBALL) {
 508                 mb = ob->data;
 509                 return &(mb->totcol);
 510         }
 511         return NULL;
 512 }
 513
 514 /* same as above but for ID's */
 515 Material ***give_matarar_id(ID *id)
 516 {
 517         /* ensure we don't try get materials from non-obdata */
 518         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 519
 520         switch (GS(id->name)) {
 521                 case ID_ME:
 522                         return &(((Mesh *)id)->mat);
 523                 case ID_CU:
 524                         return &(((Curve *)id)->mat);
 525                 case ID_MB:
 526                         return &(((MetaBall *)id)->mat);
 527         }
 528         return NULL;
 529 }
 530
 531 short *give_totcolp_id(ID *id)
 532 {
 533         /* ensure we don't try get materials from non-obdata */
 534         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 535
 536         switch (GS(id->name)) {
 537                 case ID_ME:
 538                         return &(((Mesh *)id)->totcol);
 539                 case ID_CU:
 540                         return &(((Curve *)id)->totcol);
 541                 case ID_MB:
 542                         return &(((MetaBall *)id)->totcol);
 543         }
 544         return NULL;
 545 }
 546
 547 static void material_data_index_remove_id(ID *id, short index)
 548 {
 549         /* ensure we don't try get materials from non-obdata */
 550         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 551
 552         switch (GS(id->name)) {
 553                 case ID_ME:
 554                         BKE_mesh_material_index_remove((Mesh *)id, index);
 555                         break;
 556                 case ID_CU:
 557                         BKE_curve_material_index_remove((Curve *)id, index);
 558                         break;
 559                 case ID_MB:
 560                         /* meta-elems don't have materials atm */
 561                         break;
 562         }
 563 }
 564
 565 static void material_data_index_clear_id(ID *id)
 566 {
 567         /* ensure we don't try get materials from non-obdata */
 568         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
 569
 570         switch (GS(id->name)) {
 571                 case ID_ME:
 572                         BKE_mesh_material_index_clear((Mesh *)id);
 573                         break;
 574                 case ID_CU:
 575                         BKE_curve_material_index_clear((Curve *)id);
 576                         break;
 577                 case ID_MB:
 578                         /* meta-elems don't have materials atm */
 579                         break;
 580         }
 581 }
 582
 583 void BKE_material_resize_id(struct ID *id, short totcol, bool do_id_user)
 584 {
 585         Material ***matar = give_matarar_id(id);
 586         short *totcolp = give_totcolp_id(id);
 587
 588         if (matar == NULL) {
 589                 return;
 590         }
 591
 592         if (do_id_user && totcol < (*totcolp)) {
 593                 short i;
 594                 for (i = totcol; i < (*totcolp); i++) {
 595                         id_us_min((ID *)(*matar)[i]);
 596                 }
 597         }
 598
 599         if (totcol == 0) {
 600                 if (*totcolp) {
 601                         MEM_freeN(*matar);
 602                         *matar = NULL;
 603                 }
 604         }
 605         else {
 606                 *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
 607         }
 608         *totcolp = totcol;
 609 }
 610
 611 void BKE_material_append_id(ID *id, Material *ma)
 612 {
 613         Material ***matar;
 614         if ((matar = give_matarar_id(id))) {
 615                 short *totcol = give_totcolp_id(id);
 616                 Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
 617                 if (*totcol) memcpy(mat, *matar, sizeof(void *) * (*totcol));
 618                 if (*matar) MEM_freeN(*matar);
 619
 620                 *matar = mat;
 621                 (*matar)[(*totcol)++] = ma;
 622
 623                 id_us_plus((ID *)ma);
 624                 test_object_materials(G.main, id);
 625         }
 626 }
 627
 628 Material *BKE_material_pop_id(ID *id, int index_i, bool update_data)
 629 {
 630         short index = (short)index_i;
 631         Material *ret = NULL;
 632         Material ***matar;
 633         if ((matar = give_matarar_id(id))) {
 634                 short *totcol = give_totcolp_id(id);
 635                 if (index >= 0 && index < (*totcol)) {
 636                         ret = (*matar)[index];
 637                         id_us_min((ID *)ret);
 638
 639                         if (*totcol <= 1) {
 640                                 *totcol = 0;
 641                                 MEM_freeN(*matar);
 642                                 *matar = NULL;
 643                         }
 644                         else {
 645                                 if (index + 1 != (*totcol))
 646                                         memmove((*matar) + index, (*matar) + (index + 1), sizeof(void *) * ((*totcol) - (index + 1)));
 647
 648                                 (*totcol)--;
 649                                 *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
 650                                 test_object_materials(G.main, id);
 651                         }
 652
 653                         if (update_data) {
 654                                 /* decrease mat_nr index */
 655                                 material_data_index_remove_id(id, index);
 656                         }
 657                 }
 658         }
 659
 660         return ret;
 661 }
 662
 663 void BKE_material_clear_id(struct ID *id, bool update_data)
 664 {
 665         Material ***matar;
 666         if ((matar = give_matarar_id(id))) {
 667                 short *totcol = give_totcolp_id(id);
 668                 *totcol = 0;
 669                 if (*matar) {
 670                         MEM_freeN(*matar);
 671                         *matar = NULL;
 672                 }
 673
 674                 if (update_data) {
 675                         /* decrease mat_nr index */
 676                         material_data_index_clear_id(id);
 677                 }
 678         }
 679 }
 680
 681 Material *give_current_material(Object *ob, short act)
 682 {
 683         Material ***matarar, *ma;
 684         const short *totcolp;
 685
 686         if (ob == NULL) return NULL;
 687
 688         /* if object cannot have material, (totcolp == NULL) */
 689         totcolp = give_totcolp(ob);
 690         if (totcolp == NULL || ob->totcol == 0) return NULL;
 691
 692         /* return NULL for invalid 'act', can happen for mesh face indices */
 693         if (act > ob->totcol)
 694                 return NULL;
 695         else if (act <= 0) {
 696                 if (act < 0) {
 697                         printf("Negative material index!\n");
 698                 }
 699                 return NULL;
 700         }
 701
 702         if (ob->matbits && ob->matbits[act - 1]) {    /* in object */
 703                 ma = ob->mat[act - 1];
 704         }
 705         else {                              /* in data */
 706
 707                 /* check for inconsistency */
 708                 if (*totcolp < ob->totcol)
 709                         ob->totcol = *totcolp;
 710                 if (act > ob->totcol) act = ob->totcol;
 711
 712                 matarar = give_matarar(ob);
 713
 714                 if (matarar && *matarar) ma = (*matarar)[act - 1];
 715                 else ma = NULL;
 716
 717         }
 718
 719         return ma;
 720 }
 721
 722 ID *material_from(Object *ob, short act)
 723 {
 724
 725         if (ob == NULL) return NULL;
 726
 727         if (ob->totcol == 0) return ob->data;
 728         if (act == 0) act = 1;
 729
 730         if (ob->matbits[act - 1]) return (ID *)ob;
 731         else return ob->data;
 732 }
 733
 734 Material *give_node_material(Material *ma)
 735 {
 736         if (ma && ma->use_nodes && ma->nodetree) {
 737                 bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
 738
 739                 if (node)
 740                         return (Material *)node->id;
 741         }
 742
 743         return NULL;
 744 }
 745
 746 void BKE_material_resize_object(Object *ob, const short totcol, bool do_id_user)
 747 {
 748         Material **newmatar;
 749         char *newmatbits;
 750
 751         if (do_id_user && totcol < ob->totcol) {
 752                 short i;
 753                 for (i = totcol; i < ob->totcol; i++) {
 754                         id_us_min((ID *)ob->mat[i]);
 755                 }
 756         }
 757
 758         if (totcol == 0) {
 759                 if (ob->totcol) {
 760                         MEM_freeN(ob->mat);
 761                         MEM_freeN(ob->matbits);
 762                         ob->mat = NULL;
 763                         ob->matbits = NULL;
 764                 }
 765         }
 766         else if (ob->totcol < totcol) {
 767                 newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
 768                 newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
 769                 if (ob->totcol) {
 770                         memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
 771                         memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
 772                         MEM_freeN(ob->mat);
 773                         MEM_freeN(ob->matbits);
 774                 }
 775                 ob->mat = newmatar;
 776                 ob->matbits = newmatbits;
 777         }
 778         /* XXX, why not realloc on shrink? - campbell */
 779
 780         ob->totcol = totcol;
 781         if (ob->totcol && ob->actcol == 0) ob->actcol = 1;
 782         if (ob->actcol > ob->totcol) ob->actcol = ob->totcol;
 783 }
 784
 785 void test_object_materials(Main *bmain, ID *id)
 786 {
 787         /* make the ob mat-array same size as 'ob->data' mat-array */
 788         Object *ob;
 789         const short *totcol;
 790
 791         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
 792                 return;
 793         }
 794
 795         BKE_main_lock(bmain);
 796         for (ob = bmain->object.first; ob; ob = ob->id.next) {
 797                 if (ob->data == id) {
 798                         BKE_material_resize_object(ob, *totcol, false);
 799                 }
 800         }
 801         BKE_main_unlock(bmain);
 802 }
 803
 804 void assign_material_id(ID *id, Material *ma, short act)
 805 {
 806         Material *mao, **matar, ***matarar;
 807         short *totcolp;
 808
 809         if (act > MAXMAT) return;
 810         if (act < 1) act = 1;
 811
 812         /* this is needed for Python overrides,
 813          * we just have to take care that the UI can't do this */
 814 #if 0
 815         /* prevent crashing when using accidentally */
 816         BLI_assert(id->lib == NULL);
 817         if (id->lib) return;
 818 #endif
 819
 820         /* test arraylens */
 821
 822         totcolp = give_totcolp_id(id);
 823         matarar = give_matarar_id(id);
 824
 825         if (totcolp == NULL || matarar == NULL) return;
 826
 827         if (act > *totcolp) {
 828                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
 829
 830                 if (*totcolp) {
 831                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
 832                         MEM_freeN(*matarar);
 833                 }
 834
 835                 *matarar = matar;
 836                 *totcolp = act;
 837         }
 838
 839         /* in data */
 840         mao = (*matarar)[act - 1];
 841         if (mao) mao->id.us--;
 842         (*matarar)[act - 1] = ma;
 843
 844         if (ma)
 845                 id_us_plus((ID *)ma);
 846
 847         test_object_materials(G.main, id);
 848 }
 849
 850 void assign_material(Object *ob, Material *ma, short act, int assign_type)
 851 {
 852         Material *mao, **matar, ***matarar;
 853         short *totcolp;
 854         char bit = 0;
 855
 856         if (act > MAXMAT) return;
 857         if (act < 1) act = 1;
 858
 859         /* prevent crashing when using accidentally */
 860         BLI_assert(ob->id.lib == NULL);
 861         if (ob->id.lib) return;
 862
 863         /* test arraylens */
 864
 865         totcolp = give_totcolp(ob);
 866         matarar = give_matarar(ob);
 867
 868         if (totcolp == NULL || matarar == NULL) return;
 869
 870         if (act > *totcolp) {
 871                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
 872
 873                 if (*totcolp) {
 874                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
 875                         MEM_freeN(*matarar);
 876                 }
 877
 878                 *matarar = matar;
 879                 *totcolp = act;
 880         }
 881
 882         /* Determine the object/mesh linking */
 883         if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
 884                 /* copy from previous material */
 885                 bit = ob->matbits[ob->actcol - 1];
 886         }
 887         else {
 888                 switch (assign_type) {
 889                         case BKE_MAT_ASSIGN_OBDATA:
 890                                 bit = 0;
 891                                 break;
 892                         case BKE_MAT_ASSIGN_OBJECT:
 893                                 bit = 1;
 894                                 break;
 895                         case BKE_MAT_ASSIGN_USERPREF:
 896                         default:
 897                                 bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
 898                                 break;
 899                 }
 900         }
 901
 902         if (act > ob->totcol) {
 903                 /* Need more space in the material arrays */
 904                 ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
 905                 ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
 906                 ob->totcol = act;
 907         }
 908
 909         /* do it */
 910
 911         ob->matbits[act - 1] = bit;
 912         if (bit == 1) {   /* in object */
 913                 mao = ob->mat[act - 1];
 914                 if (mao) mao->id.us--;
 915                 ob->mat[act - 1] = ma;
 916         }
 917         else {  /* in data */
 918                 mao = (*matarar)[act - 1];
 919                 if (mao) mao->id.us--;
 920                 (*matarar)[act - 1] = ma;
 921         }
 922
 923         if (ma)
 924                 id_us_plus((ID *)ma);
 925         test_object_materials(G.main, ob->data);
 926 }
 927
 928
 929 void BKE_material_remap_object(Object *ob, const unsigned int *remap)
 930 {
 931         Material ***matar = give_matarar(ob);
 932         const short *totcol_p = give_totcolp(ob);
 933
 934         BLI_array_permute(ob->mat, ob->totcol, remap);
 935
 936         if (ob->matbits) {
 937                 BLI_array_permute(ob->matbits, ob->totcol, remap);
 938         }
 939
 940         if(matar) {
 941                 BLI_array_permute(*matar, *totcol_p, remap);
 942         }
 943
 944         if (ob->type == OB_MESH) {
 945                 BKE_mesh_material_remap(ob->data, remap, ob->totcol);
 946         }
 947         else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
 948                 BKE_curve_material_remap(ob->data, remap, ob->totcol);
 949         }
 950         else {
 951                 /* add support for this object data! */
 952                 BLI_assert(matar == NULL);
 953         }
 954 }
 955
 956
 957 /* XXX - this calls many more update calls per object then are needed, could be optimized */
 958 void assign_matarar(struct Object *ob, struct Material ***matar, short totcol)
 959 {
 960         int actcol_orig = ob->actcol;
 961         short i;
 962
 963         while (object_remove_material_slot(ob)) {}
 964
 965         /* now we have the right number of slots */
 966         for (i = 0; i < totcol; i++)
 967                 assign_material(ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
 968
 969         if (actcol_orig > ob->totcol)
 970                 actcol_orig = ob->totcol;
 971
 972         ob->actcol = actcol_orig;
 973 }
 974
 975
 976 short find_material_index(Object *ob, Material *ma)
 977 {
 978         Material ***matarar;
 979         short a, *totcolp;
 980
 981         if (ma == NULL) return 0;
 982
 983         totcolp = give_totcolp(ob);
 984         matarar = give_matarar(ob);
 985
 986         if (totcolp == NULL || matarar == NULL) return 0;
 987
 988         for (a = 0; a < *totcolp; a++)
 989                 if ((*matarar)[a] == ma)
 990                         break;
 991         if (a < *totcolp)
 992                 return a + 1;
 993         return 0;
 994 }
 995
 996 bool object_add_material_slot(Object *ob)
 997 {
 998         if (ob == NULL) return false;
 999         if (ob->totcol >= MAXMAT) return false;
1000
1001         assign_material(ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
1002         ob->actcol = ob->totcol;
1003         return true;
1004 }
1005
1006 static void do_init_render_material(Material *ma, int r_mode, float *amb)
1007 {
1008         MTex *mtex;
1009         int a, needuv = 0, needtang = 0;
1010
1011         if (ma->flarec == 0) ma->flarec = 1;
1012
1013         /* add all texcoflags from mtex, texco and mapto were cleared in advance */
1014         for (a = 0; a < MAX_MTEX; a++) {
1015
1016                 /* separate tex switching */
1017                 if (ma->septex & (1 << a)) continue;
1018
1019                 mtex = ma->mtex[a];
1020                 if (mtex && mtex->tex && (mtex->tex->type | (mtex->tex->use_nodes && mtex->tex->nodetree) )) {
1021
1022                         ma->texco |= mtex->texco;
1023                         ma->mapto |= mtex->mapto;
1024
1025                         /* always get derivatives for these textures */
1026                         if (ELEM(mtex->tex->type, TEX_IMAGE, TEX_ENVMAP)) ma->texco |= TEXCO_OSA;
1027                         else if (mtex->texflag & (MTEX_COMPAT_BUMP | MTEX_3TAP_BUMP | MTEX_5TAP_BUMP | MTEX_BICUBIC_BUMP)) ma->texco |= TEXCO_OSA;
1028
1029                         if (ma->texco & (TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM | TEXCO_STRAND | TEXCO_STRESS)) needuv = 1;
1030                         else if (ma->texco & (TEXCO_GLOB | TEXCO_UV | TEXCO_OBJECT | TEXCO_SPEED)) needuv = 1;
1031                         else if (ma->texco & (TEXCO_LAVECTOR | TEXCO_VIEW)) needuv = 1;
1032
1033                         if ((ma->mapto & MAP_NORM) && (mtex->normapspace == MTEX_NSPACE_TANGENT))
1034                                 needtang = 1;
1035                 }
1036         }
1037
1038         if (needtang) ma->mode |= MA_NORMAP_TANG;
1039         else ma->mode &= ~MA_NORMAP_TANG;
1040
1041         if (ma->mode & (MA_VERTEXCOL | MA_VERTEXCOLP | MA_FACETEXTURE)) {
1042                 needuv = 1;
1043                 if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;     /* for texfaces */
1044         }
1045         if (needuv) ma->texco |= NEED_UV;
1046
1047         /* since the raytracer doesnt recalc O structs for each ray, we have to preset them all */
1048         if (r_mode & R_RAYTRACE) {
1049                 if ((ma->mode & (MA_RAYMIRROR | MA_SHADOW_TRA)) || ((ma->mode & MA_TRANSP) && (ma->mode & MA_RAYTRANSP))) {
1050                         ma->texco |= NEED_UV | TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM;
1051                         if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;
1052                 }
1053         }
1054
1055         if (amb) {
1056                 ma->ambr = ma->amb * amb[0];
1057                 ma->ambg = ma->amb * amb[1];
1058                 ma->ambb = ma->amb * amb[2];
1059         }
1060
1061         /* local group override */
1062         if ((ma->shade_flag & MA_GROUP_LOCAL) && ma->id.lib && ma->group && ma->group->id.lib) {
1063                 Group *group;
1064
1065                 for (group = G.main->group.first; group; group = group->id.next) {
1066                         if (!group->id.lib && STREQ(group->id.name, ma->group->id.name)) {
1067                                 ma->group = group;
1068                         }
1069                 }
1070         }
1071 }
1072
1073 static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode, float *amb)
1074 {
1075         bNode *node;
1076
1077         for (node = ntree->nodes.first; node; node = node->next) {
1078                 if (node->id) {
1079                         if (GS(node->id->name) == ID_MA) {
1080                                 Material *ma = (Material *)node->id;
1081                                 if (ma != basemat) {
1082                                         do_init_render_material(ma, r_mode, amb);
1083                                         basemat->texco |= ma->texco;
1084                                 }
1085
1086                                 basemat->mode_l |= ma->mode & ~(MA_MODE_PIPELINE | MA_SHLESS);
1087                                 basemat->mode2_l |= ma->mode2 & ~MA_MODE2_PIPELINE;
1088                                 /* basemat only considered shadeless if all node materials are too */
1089                                 if (!(ma->mode & MA_SHLESS))
1090                                         basemat->mode_l &= ~MA_SHLESS;
1091
1092                                 if (ma->strand_surfnor > 0.0f)
1093                                         basemat->mode_l |= MA_STR_SURFDIFF;
1094                         }
1095                         else if (node->type == NODE_GROUP)
1096                                 init_render_nodetree((bNodeTree *)node->id, basemat, r_mode, amb);
1097                 }
1098         }
1099 }
1100
1101 void init_render_material(Material *mat, int r_mode, float *amb)
1102 {
1103
1104         do_init_render_material(mat, r_mode, amb);
1105
1106         if (mat->nodetree && mat->use_nodes) {
1107                 /* mode_l will take the pipeline options from the main material, and the or-ed
1108                  * result of non-pipeline options from the nodes. shadeless is an exception,
1109                  * mode_l will have it set when all node materials are shadeless. */
1110                 mat->mode_l = (mat->mode & MA_MODE_PIPELINE) | MA_SHLESS;
1111                 mat->mode2_l = mat->mode2 & MA_MODE2_PIPELINE;
1112
1113                 /* parses the geom+tex nodes */
1114                 ntreeShaderGetTexcoMode(mat->nodetree, r_mode, &mat->texco, &mat->mode_l);
1115
1116                 init_render_nodetree(mat->nodetree, mat, r_mode, amb);
1117
1118                 if (!mat->nodetree->execdata)
1119                         mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree);
1120         }
1121         else {
1122                 mat->mode_l = mat->mode;
1123                 mat->mode2_l = mat->mode2;
1124
1125                 if (mat->strand_surfnor > 0.0f)
1126                         mat->mode_l |= MA_STR_SURFDIFF;
1127         }
1128 }
1129
1130 void init_render_materials(Main *bmain, int r_mode, float *amb)
1131 {
1132         Material *ma;
1133
1134         /* clear these flags before going over materials, to make sure they
1135          * are cleared only once, otherwise node materials contained in other
1136          * node materials can go wrong */
1137         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1138                 if (ma->id.us) {
1139                         ma->texco = 0;
1140                         ma->mapto = 0;
1141                 }
1142         }
1143
1144         /* two steps, first initialize, then or the flags for layers */
1145         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1146                 /* is_used flag comes back in convertblender.c */
1147                 ma->flag &= ~MA_IS_USED;
1148                 if (ma->id.us)
1149                         init_render_material(ma, r_mode, amb);
1150         }
1151
1152         init_render_material(&defmaterial, r_mode, amb);
1153 }
1154
1155 /* only needed for nodes now */
1156 void end_render_material(Material *mat)
1157 {
1158         if (mat && mat->nodetree && mat->use_nodes) {
1159                 if (mat->nodetree->execdata)
1160                         ntreeShaderEndExecTree(mat->nodetree->execdata);
1161         }
1162 }
1163
1164 void end_render_materials(Main *bmain)
1165 {
1166         Material *ma;
1167         for (ma = bmain->mat.first; ma; ma = ma->id.next)
1168                 if (ma->id.us)
1169                         end_render_material(ma);
1170 }
1171
1172 static bool material_in_nodetree(bNodeTree *ntree, Material *mat)
1173 {
1174         bNode *node;
1175
1176         for (node = ntree->nodes.first; node; node = node->next) {
1177                 if (node->id) {
1178                         if (GS(node->id->name) == ID_MA) {
1179                                 if (node->id == (ID *)mat) {
1180                                         return true;
1181                                 }
1182                         }
1183                         else if (node->type == NODE_GROUP) {
1184                                 if (material_in_nodetree((bNodeTree *)node->id, mat)) {
1185                                         return true;
1186                                 }
1187                         }
1188                 }
1189         }
1190
1191         return false;
1192 }
1193
1194 bool material_in_material(Material *parmat, Material *mat)
1195 {
1196         if (parmat == mat)
1197                 return true;
1198         else if (parmat->nodetree && parmat->use_nodes)
1199                 return material_in_nodetree(parmat->nodetree, mat);
1200         else
1201                 return false;
1202 }
1203
1204
1205 /* ****************** */
1206
1207 /* Update drivers for materials in a nodetree */
1208 static void material_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
1209 {
1210         bNode *node;
1211
1212         /* nodetree itself */
1213         if (ntree->adt && ntree->adt->drivers.first) {
1214                 BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
1215         }
1216
1217         /* nodes */
1218         for (node = ntree->nodes.first; node; node = node->next) {
1219                 if (node->id) {
1220                         if (GS(node->id->name) == ID_MA) {
1221                                 material_drivers_update(scene, (Material *)node->id, ctime);
1222                         }
1223                         else if (node->type == NODE_GROUP) {
1224                                 material_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
1225                         }
1226                 }
1227         }
1228 }
1229
1230 /* Calculate all drivers for materials
1231  * FIXME: this is really a terrible method which may result in some things being calculated
1232  * multiple times. However, without proper despgraph support for these things, we are forced
1233  * into this sort of thing...
1234  */
1235 void material_drivers_update(Scene *scene, Material *ma, float ctime)
1236 {
1237         //if (G.f & G_DEBUG)
1238         //      printf("material_drivers_update(%s, %s)\n", scene->id.name, ma->id.name);
1239
1240         /* Prevent infinite recursion by checking (and tagging the material) as having been visited already
1241          * (see BKE_scene_update_tagged()). This assumes ma->id.flag & LIB_DOIT isn't set by anything else
1242          * in the meantime... [#32017]
1243          */
1244         if (ma->id.flag & LIB_DOIT)
1245                 return;
1246
1247         ma->id.flag |= LIB_DOIT;
1248
1249         /* material itself */
1250         if (ma->adt && ma->adt->drivers.first) {
1251                 BKE_animsys_evaluate_animdata(scene, &ma->id, ma->adt, ctime, ADT_RECALC_DRIVERS);
1252         }
1253
1254         /* nodes */
1255         if (ma->nodetree) {
1256                 material_node_drivers_update(scene, ma->nodetree, ctime);
1257         }
1258
1259         ma->id.flag &= ~LIB_DOIT;
1260 }
1261
1262 bool object_remove_material_slot(Object *ob)
1263 {
1264         Material *mao, ***matarar;
1265         Object *obt;
1266         short *totcolp;
1267         short a, actcol;
1268
1269         if (ob == NULL || ob->totcol == 0) {
1270                 return false;
1271         }
1272
1273         /* this should never happen and used to crash */
1274         if (ob->actcol <= 0) {
1275                 printf("%s: invalid material index %d, report a bug!\n", __func__, ob->actcol);
1276                 BLI_assert(0);
1277                 return false;
1278         }
1279
1280         /* take a mesh/curve/mball as starting point, remove 1 index,
1281          * AND with all objects that share the ob->data
1282          *
1283          * after that check indices in mesh/curve/mball!!!
1284          */
1285
1286         totcolp = give_totcolp(ob);
1287         matarar = give_matarar(ob);
1288
1289         if (ELEM(NULL, matarar, *matarar)) {
1290                 return false;
1291         }
1292
1293         /* can happen on face selection in editmode */
1294         if (ob->actcol > ob->totcol) {
1295                 ob->actcol = ob->totcol;
1296         }
1297
1298         /* we delete the actcol */
1299         mao = (*matarar)[ob->actcol - 1];
1300         if (mao) mao->id.us--;
1301
1302         for (a = ob->actcol; a < ob->totcol; a++)
1303                 (*matarar)[a - 1] = (*matarar)[a];
1304         (*totcolp)--;
1305
1306         if (*totcolp == 0) {
1307                 MEM_freeN(*matarar);
1308                 *matarar = NULL;
1309         }
1310
1311         actcol = ob->actcol;
1312         obt = G.main->object.first;
1313         while (obt) {
1314
1315                 if (obt->data == ob->data) {
1316
1317                         /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
1318                         mao = obt->mat[actcol - 1];
1319                         if (mao) mao->id.us--;
1320
1321                         for (a = actcol; a < obt->totcol; a++) {
1322                                 obt->mat[a - 1] = obt->mat[a];
1323                                 obt->matbits[a - 1] = obt->matbits[a];
1324                         }
1325                         obt->totcol--;
1326                         if (obt->actcol > obt->totcol) obt->actcol = obt->totcol;
1327
1328                         if (obt->totcol == 0) {
1329                                 MEM_freeN(obt->mat);
1330                                 MEM_freeN(obt->matbits);
1331                                 obt->mat = NULL;
1332                                 obt->matbits = NULL;
1333                         }
1334                 }
1335                 obt = obt->id.next;
1336         }
1337
1338         /* check indices from mesh */
1339         if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT)) {
1340                 material_data_index_remove_id((ID *)ob->data, actcol - 1);
1341                 if (ob->curve_cache) {
1342                         BKE_displist_free(&ob->curve_cache->disp);
1343                 }
1344         }
1345
1346         return true;
1347 }
1348
1349 static bool get_mtex_slot_valid_texpaint(struct MTex *mtex)
1350 {
1351         return (mtex && (mtex->texco == TEXCO_UV) &&
1352                 mtex->tex && (mtex->tex->type == TEX_IMAGE) &&
1353                 mtex->tex->ima);
1354 }
1355
1356 static bNode *nodetree_uv_node_recursive(bNode *node)
1357 {
1358         bNode *inode;
1359         bNodeSocket *sock;
1360
1361         for (sock = node->inputs.first; sock; sock = sock->next) {
1362                 if (sock->link) {
1363                         inode = sock->link->fromnode;
1364                         if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1365                                 return inode;
1366                         }
1367                         else {
1368                                 return nodetree_uv_node_recursive(inode);
1369                         }
1370                 }
1371         }
1372
1373         return NULL;
1374 }
1375
1376 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1377 {
1378         MTex **mtex;
1379         short count = 0;
1380         short index = 0, i;
1381
1382         bool use_nodes = BKE_scene_use_new_shading_nodes(scene);
1383         bool is_bi = BKE_scene_uses_blender_internal(scene) || BKE_scene_uses_blender_game(scene);
1384
1385         if (!ma)
1386                 return;
1387
1388         if (ma->texpaintslot) {
1389                 MEM_freeN(ma->texpaintslot);
1390                 ma->tot_slots = 0;
1391                 ma->texpaintslot = NULL;
1392         }
1393
1394         if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1395                 ma->paint_active_slot = 0;
1396                 ma->paint_clone_slot = 0;
1397                 return;
1398         }
1399
1400         if (use_nodes || ma->use_nodes) {
1401                 bNode *node, *active_node;
1402
1403                 if (!(ma->nodetree)) {
1404                         ma->paint_active_slot = 0;
1405                         ma->paint_clone_slot = 0;
1406                         return;
1407                 }
1408
1409                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1410                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id)
1411                                 count++;
1412                 }
1413
1414                 if (count == 0) {
1415                         ma->paint_active_slot = 0;
1416                         ma->paint_clone_slot = 0;
1417                         return;
1418                 }
1419                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1420
1421                 active_node = nodeGetActiveTexture(ma->nodetree);
1422
1423                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1424                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1425                                 if (active_node == node)
1426                                         ma->paint_active_slot = index;
1427                                 ma->texpaintslot[index].ima = (Image *)node->id;
1428
1429                                 /* for new renderer, we need to traverse the treeback in search of a UV node */
1430                                 if (use_nodes) {
1431                                         bNode *uvnode = nodetree_uv_node_recursive(node);
1432
1433                                         if (uvnode) {
1434                                                 NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1435                                                 ma->texpaintslot[index].uvname = storage->uv_map;
1436                                                 /* set a value to index so UI knows that we have a valid pointer for the mesh */
1437                                                 ma->texpaintslot[index].index = 0;
1438                                         }
1439                                         else {
1440                                                 /* just invalidate the index here so UV map does not get displayed on the UI */
1441                                                 ma->texpaintslot[index].index = -1;
1442                                         }
1443                                 }
1444                                 else {
1445                                         ma->texpaintslot[index].index = -1;
1446                                 }
1447                                 index++;
1448                         }
1449                 }
1450         }
1451         else if (is_bi) {
1452                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1453                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1454                                 count++;
1455                         }
1456                 }
1457
1458                 if (count == 0) {
1459                         ma->paint_active_slot = 0;
1460                         ma->paint_clone_slot = 0;
1461                         return;
1462                 }
1463
1464                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1465
1466                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1467                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1468                                 ma->texpaintslot[index].ima = (*mtex)->tex->ima;
1469                                 ma->texpaintslot[index].uvname = (*mtex)->uvname;
1470                                 ma->texpaintslot[index].index = i;
1471
1472                                 index++;
1473                         }
1474                 }
1475         }
1476         else {
1477                 ma->paint_active_slot = 0;
1478                 ma->paint_clone_slot = 0;
1479                 return;
1480         }
1481
1482
1483         ma->tot_slots = count;
1484
1485
1486         if (ma->paint_active_slot >= count) {
1487                 ma->paint_active_slot = count - 1;
1488         }
1489
1490         if (ma->paint_clone_slot >= count) {
1491                 ma->paint_clone_slot = count - 1;
1492         }
1493
1494         return;
1495 }
1496
1497 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1498 {
1499         int i;
1500
1501         for (i = 1; i < ob->totcol + 1; i++) {
1502                 Material *ma = give_current_material(ob, i);
1503                 BKE_texpaint_slot_refresh_cache(scene, ma);
1504         }
1505 }
1506
1507
1508 /* r_col = current value, col = new value, (fac == 0) is no change */
1509 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1510 {
1511         float tmp, facm = 1.0f - fac;
1512
1513         switch (type) {
1514                 case MA_RAMP_BLEND:
1515                         r_col[0] = facm * (r_col[0]) + fac * col[0];
1516                         r_col[1] = facm * (r_col[1]) + fac * col[1];
1517                         r_col[2] = facm * (r_col[2]) + fac * col[2];
1518                         break;
1519                 case MA_RAMP_ADD:
1520                         r_col[0] += fac * col[0];
1521                         r_col[1] += fac * col[1];
1522                         r_col[2] += fac * col[2];
1523                         break;
1524                 case MA_RAMP_MULT:
1525                         r_col[0] *= (facm + fac * col[0]);
1526                         r_col[1] *= (facm + fac * col[1]);
1527                         r_col[2] *= (facm + fac * col[2]);
1528                         break;
1529                 case MA_RAMP_SCREEN:
1530                         r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1531                         r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1532                         r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1533                         break;
1534                 case MA_RAMP_OVERLAY:
1535                         if (r_col[0] < 0.5f)
1536                                 r_col[0] *= (facm + 2.0f * fac * col[0]);
1537                         else
1538                                 r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1539                         if (r_col[1] < 0.5f)
1540                                 r_col[1] *= (facm + 2.0f * fac * col[1]);
1541                         else
1542                                 r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1543                         if (r_col[2] < 0.5f)
1544                                 r_col[2] *= (facm + 2.0f * fac * col[2]);
1545                         else
1546                                 r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1547                         break;
1548                 case MA_RAMP_SUB:
1549                         r_col[0] -= fac * col[0];
1550                         r_col[1] -= fac * col[1];
1551                         r_col[2] -= fac * col[2];
1552                         break;
1553                 case MA_RAMP_DIV:
1554                         if (col[0] != 0.0f)
1555                                 r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1556                         if (col[1] != 0.0f)
1557                                 r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1558                         if (col[2] != 0.0f)
1559                                 r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1560                         break;
1561                 case MA_RAMP_DIFF:
1562                         r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1563                         r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1564                         r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1565                         break;
1566                 case MA_RAMP_DARK:
1567                         r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1568                         r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1569                         r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1570                         break;
1571                 case MA_RAMP_LIGHT:
1572                         tmp = fac * col[0];
1573                         if (tmp > r_col[0]) r_col[0] = tmp;
1574                         tmp = fac * col[1];
1575                         if (tmp > r_col[1]) r_col[1] = tmp;
1576                         tmp = fac * col[2];
1577                         if (tmp > r_col[2]) r_col[2] = tmp;
1578                         break;
1579                 case MA_RAMP_DODGE:
1580                         if (r_col[0] != 0.0f) {
1581                                 tmp = 1.0f - fac * col[0];
1582                                 if (tmp <= 0.0f)
1583                                         r_col[0] = 1.0f;
1584                                 else if ((tmp = (r_col[0]) / tmp) > 1.0f)
1585                                         r_col[0] = 1.0f;
1586                                 else
1587                                         r_col[0] = tmp;
1588                         }
1589                         if (r_col[1] != 0.0f) {
1590                                 tmp = 1.0f - fac * col[1];
1591                                 if (tmp <= 0.0f)
1592                                         r_col[1] = 1.0f;
1593                                 else if ((tmp = (r_col[1]) / tmp) > 1.0f)
1594                                         r_col[1] = 1.0f;
1595                                 else
1596                                         r_col[1] = tmp;
1597                         }
1598                         if (r_col[2] != 0.0f) {
1599                                 tmp = 1.0f - fac * col[2];
1600                                 if (tmp <= 0.0f)
1601                                         r_col[2] = 1.0f;
1602                                 else if ((tmp = (r_col[2]) / tmp) > 1.0f)
1603                                         r_col[2] = 1.0f;
1604                                 else
1605                                         r_col[2] = tmp;
1606                         }
1607                         break;
1608                 case MA_RAMP_BURN:
1609                         tmp = facm + fac * col[0];
1610
1611                         if (tmp <= 0.0f)
1612                                 r_col[0] = 0.0f;
1613                         else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f)
1614                                 r_col[0] = 0.0f;
1615                         else if (tmp > 1.0f)
1616                                 r_col[0] = 1.0f;
1617                         else
1618                                 r_col[0] = tmp;
1619
1620                         tmp = facm + fac * col[1];
1621                         if (tmp <= 0.0f)
1622                                 r_col[1] = 0.0f;
1623                         else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f)
1624                                 r_col[1] = 0.0f;
1625                         else if (tmp > 1.0f)
1626                                 r_col[1] = 1.0f;
1627                         else
1628                                 r_col[1] = tmp;
1629
1630                         tmp = facm + fac * col[2];
1631                         if (tmp <= 0.0f)
1632                                 r_col[2] = 0.0f;
1633                         else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f)
1634                                 r_col[2] = 0.0f;
1635                         else if (tmp > 1.0f)
1636                                 r_col[2] = 1.0f;
1637                         else
1638                                 r_col[2] = tmp;
1639                         break;
1640                 case MA_RAMP_HUE:
1641                 {
1642                         float rH, rS, rV;
1643                         float colH, colS, colV;
1644                         float tmpr, tmpg, tmpb;
1645                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1646                         if (colS != 0) {
1647                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1648                                 hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1649                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1650                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1651                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1652                         }
1653                         break;
1654                 }
1655                 case MA_RAMP_SAT:
1656                 {
1657                         float rH, rS, rV;
1658                         float colH, colS, colV;
1659                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1660                         if (rS != 0) {
1661                                 rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1662                                 hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1663                         }
1664                         break;
1665                 }
1666                 case MA_RAMP_VAL:
1667                 {
1668                         float rH, rS, rV;
1669                         float colH, colS, colV;
1670                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1671                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1672                         hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1673                         break;
1674                 }
1675                 case MA_RAMP_COLOR:
1676                 {
1677                         float rH, rS, rV;
1678                         float colH, colS, colV;
1679                         float tmpr, tmpg, tmpb;
1680                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1681                         if (colS != 0) {
1682                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1683                                 hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1684                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1685                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1686                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1687                         }
1688                         break;
1689                 }
1690                 case MA_RAMP_SOFT:
1691                 {
1692                         float scr, scg, scb;
1693
1694                         /* first calculate non-fac based Screen mix */
1695                         scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1696                         scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1697                         scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1698
1699                         r_col[0] = facm * (r_col[0]) + fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1700                         r_col[1] = facm * (r_col[1]) + fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1701                         r_col[2] = facm * (r_col[2]) + fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1702                         break;
1703                 }
1704                 case MA_RAMP_LINEAR:
1705                         if (col[0] > 0.5f)
1706                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1707                         else
1708                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1709                         if (col[1] > 0.5f)
1710                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1711                         else
1712                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1713                         if (col[2] > 0.5f)
1714                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1715                         else
1716                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1717                         break;
1718         }
1719 }
1720
1721 /**
1722  * \brief copy/paste buffer, if we had a proper py api that would be better
1723  * \note matcopybuf.nodetree does _NOT_ use ID's
1724  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1725  */
1726 static Material matcopybuf;
1727 static short matcopied = 0;
1728
1729 void clear_matcopybuf(void)
1730 {
1731         memset(&matcopybuf, 0, sizeof(Material));
1732         matcopied = 0;
1733 }
1734
1735 void free_matcopybuf(void)
1736 {
1737         int a;
1738
1739         for (a = 0; a < MAX_MTEX; a++) {
1740                 if (matcopybuf.mtex[a]) {
1741                         MEM_freeN(matcopybuf.mtex[a]);
1742                         matcopybuf.mtex[a] = NULL;
1743                 }
1744         }
1745
1746         if (matcopybuf.ramp_col) MEM_freeN(matcopybuf.ramp_col);
1747         if (matcopybuf.ramp_spec) MEM_freeN(matcopybuf.ramp_spec);
1748
1749         matcopybuf.ramp_col = NULL;
1750         matcopybuf.ramp_spec = NULL;
1751
1752         if (matcopybuf.nodetree) {
1753                 ntreeFreeTree_ex(matcopybuf.nodetree, false);
1754                 MEM_freeN(matcopybuf.nodetree);
1755                 matcopybuf.nodetree = NULL;
1756         }
1757
1758         matcopied = 0;
1759 }
1760
1761 void copy_matcopybuf(Material *ma)
1762 {
1763         int a;
1764         MTex *mtex;
1765
1766         if (matcopied)
1767                 free_matcopybuf();
1768
1769         memcpy(&matcopybuf, ma, sizeof(Material));
1770         if (matcopybuf.ramp_col) matcopybuf.ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1771         if (matcopybuf.ramp_spec) matcopybuf.ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1772
1773         for (a = 0; a < MAX_MTEX; a++) {
1774                 mtex = matcopybuf.mtex[a];
1775                 if (mtex) {
1776                         matcopybuf.mtex[a] = MEM_dupallocN(mtex);
1777                 }
1778         }
1779         matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, G.main, false);
1780         matcopybuf.preview = NULL;
1781         BLI_listbase_clear(&matcopybuf.gpumaterial);
1782         matcopied = 1;
1783 }
1784
1785 void paste_matcopybuf(Material *ma)
1786 {
1787         int a;
1788         MTex *mtex;
1789         ID id;
1790
1791         if (matcopied == 0)
1792                 return;
1793         /* free current mat */
1794         if (ma->ramp_col) MEM_freeN(ma->ramp_col);
1795         if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
1796         for (a = 0; a < MAX_MTEX; a++) {
1797                 mtex = ma->mtex[a];
1798                 if (mtex && mtex->tex) mtex->tex->id.us--;
1799                 if (mtex) MEM_freeN(mtex);
1800         }
1801
1802         if (ma->nodetree) {
1803                 ntreeFreeTree(ma->nodetree);
1804                 MEM_freeN(ma->nodetree);
1805         }
1806
1807         GPU_material_free(&ma->gpumaterial);
1808
1809         id = (ma->id);
1810         memcpy(ma, &matcopybuf, sizeof(Material));
1811         (ma->id) = id;
1812
1813         if (matcopybuf.ramp_col) ma->ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1814         if (matcopybuf.ramp_spec) ma->ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1815
1816         for (a = 0; a < MAX_MTEX; a++) {
1817                 mtex = ma->mtex[a];
1818                 if (mtex) {
1819                         ma->mtex[a] = MEM_dupallocN(mtex);
1820                         if (mtex->tex) {
1821                                 /* first check this is in main (we may have loaded another file) [#35500] */
1822                                 if (BLI_findindex(&G.main->tex, mtex->tex) != -1) {
1823                                         id_us_plus((ID *)mtex->tex);
1824                                 }
1825                                 else {
1826                                         ma->mtex[a]->tex = NULL;
1827                                 }
1828                         }
1829                 }
1830         }
1831
1832         ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, G.main, false);
1833 }
1834
1835
1836 /*********************** texface to material convert functions **********************/
1837 /* encode all the TF information into a single int */
1838 static int encode_tfaceflag(MTFace *tf, int convertall)
1839 {
1840         /* calculate the flag */
1841         int flag = tf->mode;
1842
1843         /* options that change the material offline render */
1844         if (!convertall) {
1845                 flag &= ~TF_OBCOL;
1846         }
1847
1848         /* clean flags that are not being converted */
1849         flag &= ~TF_TEX;
1850         flag &= ~TF_SHAREDVERT;
1851         flag &= ~TF_SHAREDCOL;
1852         flag &= ~TF_CONVERTED;
1853
1854         /* light tface flag is ignored in GLSL mode */
1855         flag &= ~TF_LIGHT;
1856
1857         /* 15 is how big the flag can be - hardcoded here and in decode_tfaceflag() */
1858         flag |= tf->transp << 15;
1859
1860         /* increase 1 so flag 0 is different than no flag yet */
1861         return flag + 1;
1862 }
1863
1864 /* set the material options based in the tface flag */
1865 static void decode_tfaceflag(Material *ma, int flag, int convertall)
1866 {
1867         int alphablend;
1868         GameSettings *game = &ma->game;
1869
1870         /* flag is shifted in 1 to make 0 != no flag yet (see encode_tfaceflag) */
1871         flag -= 1;
1872
1873         alphablend = flag >> 15;  /* encoded in the encode_tfaceflag function */
1874         (*game).flag = 0;
1875
1876         /* General Material Options */
1877         if ((flag & TF_DYNAMIC) == 0) (*game).flag    |= GEMAT_NOPHYSICS;
1878
1879         /* Material Offline Rendering Properties */
1880         if (convertall) {
1881                 if (flag & TF_OBCOL) ma->shade_flag |= MA_OBCOLOR;
1882         }
1883
1884         /* Special Face Properties */
1885         if ((flag & TF_TWOSIDE) == 0) (*game).flag |= GEMAT_BACKCULL;
1886         if (flag & TF_INVISIBLE) (*game).flag |= GEMAT_INVISIBLE;
1887         if (flag & TF_BMFONT) (*game).flag |= GEMAT_TEXT;
1888
1889         /* Face Orientation */
1890         if (flag & TF_BILLBOARD) (*game).face_orientation |= GEMAT_HALO;
1891         else if (flag & TF_BILLBOARD2) (*game).face_orientation |= GEMAT_BILLBOARD;
1892         else if (flag & TF_SHADOW) (*game).face_orientation |= GEMAT_SHADOW;
1893
1894         /* Alpha Blend */
1895         if (flag & TF_ALPHASORT && ELEM(alphablend, TF_ALPHA, TF_ADD)) (*game).alpha_blend = GEMAT_ALPHA_SORT;
1896         else if (alphablend & TF_ALPHA) (*game).alpha_blend = GEMAT_ALPHA;
1897         else if (alphablend & TF_ADD) (*game).alpha_blend = GEMAT_ADD;
1898         else if (alphablend & TF_CLIP) (*game).alpha_blend = GEMAT_CLIP;
1899 }
1900
1901 /* boolean check to see if the mesh needs a material */
1902 static int check_tfaceneedmaterial(int flag)
1903 {
1904         /* check if the flags we have are not deprecated != than default material options
1905          * also if only flags are visible and collision see if all objects using this mesh have this option in physics */
1906
1907         /* flag is shifted in 1 to make 0 != no flag yet (see encode_tfaceflag) */
1908         flag -= 1;
1909
1910         /* deprecated flags */
1911         flag &= ~TF_OBCOL;
1912         flag &= ~TF_SHAREDVERT;
1913         flag &= ~TF_SHAREDCOL;
1914
1915         /* light tface flag is ignored in GLSL mode */
1916         flag &= ~TF_LIGHT;
1917
1918         /* automatic detected if tex image has alpha */
1919         flag &= ~(TF_ALPHA << 15);
1920         /* automatic detected if using texture */
1921         flag &= ~TF_TEX;
1922
1923         /* settings for the default NoMaterial */
1924         if (flag == TF_DYNAMIC)
1925                 return 0;
1926
1927         else
1928                 return 1;
1929 }
1930
1931 /* return number of digits of an integer */
1932 /* XXX to be optmized or replaced by an equivalent blender internal function */
1933 static int integer_getdigits(int number)
1934 {
1935         int i = 0;
1936         if (number == 0) return 1;
1937
1938         while (number != 0) {
1939                 number = (int)(number / 10);
1940                 i++;
1941         }
1942         return i;
1943 }
1944
1945 static void calculate_tface_materialname(char *matname, char *newname, int flag)
1946 {
1947         /* if flag has only light and collision and material matches those values
1948          * you can do strcpy(name, mat_name);
1949          * otherwise do: */
1950         int digits = integer_getdigits(flag);
1951         /* clamp the old name, remove the MA prefix and add the .TF.flag suffix
1952          * e.g. matname = "MALoooooooooooooongName"; newname = "Loooooooooooooon.TF.2" */
1953         BLI_snprintf(newname, MAX_ID_NAME, "%.*s.TF.%0*d", MAX_ID_NAME - (digits + 5), matname, digits, flag);
1954 }
1955
1956 /* returns -1 if no match */
1957 static short mesh_getmaterialnumber(Mesh *me, Material *ma)
1958 {
1959         short a;
1960
1961         for (a = 0; a < me->totcol; a++) {
1962                 if (me->mat[a] == ma) {
1963                         return a;
1964                 }
1965         }
1966
1967         return -1;
1968 }
1969
1970 /* append material */
1971 static short mesh_addmaterial(Mesh *me, Material *ma)
1972 {
1973         BKE_material_append_id(&me->id, NULL);
1974         me->mat[me->totcol - 1] = ma;
1975
1976         id_us_plus(&ma->id);
1977
1978         return me->totcol - 1;
1979 }
1980
1981 static void set_facetexture_flags(Material *ma, Image *image)
1982 {
1983         if (image) {
1984                 ma->mode |= MA_FACETEXTURE;
1985                 /* we could check if the texture has alpha, but then more meshes sharing the same
1986                  * material may need it. Let's make it simple. */
1987                 if (BKE_image_has_alpha(image))
1988                         ma->mode |= MA_FACETEXTURE_ALPHA;
1989         }
1990 }
1991
1992 /* returns material number */
1993 static short convert_tfacenomaterial(Main *main, Mesh *me, MTFace *tf, int flag)
1994 {
1995         Material *ma;
1996         char idname[MAX_ID_NAME];
1997         short mat_nr = -1;
1998
1999         /* new material, the name uses the flag*/
2000         BLI_snprintf(idname, sizeof(idname), "MAMaterial.TF.%0*d", integer_getdigits(flag), flag);
2001
2002         if ((ma = BLI_findstring(&main->mat, idname + 2, offsetof(ID, name) + 2))) {
2003                 mat_nr = mesh_getmaterialnumber(me, ma);
2004                 /* assign the material to the mesh */
2005                 if (mat_nr == -1) mat_nr = mesh_addmaterial(me, ma);
2006
2007                 /* if needed set "Face Textures [Alpha]" Material options */
2008                 set_facetexture_flags(ma, tf->tpage);
2009         }
2010         /* create a new material */
2011         else {
2012                 ma = BKE_material_add(main, idname + 2);
2013
2014                 if (ma) {
2015                         printf("TexFace Convert: Material \"%s\" created.\n", idname + 2);
2016                         mat_nr = mesh_addmaterial(me, ma);
2017
2018                         /* if needed set "Face Textures [Alpha]" Material options */
2019                         set_facetexture_flags(ma, tf->tpage);
2020
2021                         decode_tfaceflag(ma, flag, 1);
2022                         /* the final decoding will happen after, outside the main loop
2023                          * for now store the flag into the material and change light/tex/collision
2024                          * store the flag as a negative number */
2025                         ma->game.flag = -flag;
2026                         id_us_min((ID *)ma);
2027                 }
2028                 else {
2029                         printf("Error: Unable to create Material \"%s\" for Mesh \"%s\".", idname + 2, me->id.name + 2);
2030                 }
2031         }
2032
2033         /* set as converted, no need to go bad to this face */
2034         tf->mode |= TF_CONVERTED;
2035         return mat_nr;
2036 }
2037
2038 /* Function to fully convert materials */
2039 static void convert_tfacematerial(Main *main, Material *ma)
2040 {
2041         Mesh *me;
2042         Material *mat_new;
2043         MFace *mf;
2044         MTFace *tf;
2045         int flag, index;
2046         int a;
2047         short mat_nr;
2048         CustomDataLayer *cdl;
2049         char idname[MAX_ID_NAME];
2050
2051         for (me = main->mesh.first; me; me = me->id.next) {
2052                 /* check if this mesh uses this material */
2053                 for (a = 0; a < me->totcol; a++)
2054                         if (me->mat[a] == ma) break;
2055
2056                 /* no material found */
2057                 if (a == me->totcol) continue;
2058
2059                 /* get the active tface layer */
2060                 index = CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
2061                 cdl = (index == -1) ? NULL : &me->fdata.layers[index];
2062                 if (!cdl) continue;
2063
2064                 /* loop over all the faces and stop at the ones that use the material*/
2065                 for (a = 0, mf = me->mface; a < me->totface; a++, mf++) {
2066                         if (me->mat[mf->mat_nr] != ma) continue;
2067
2068                         /* texface data for this face */
2069                         tf = ((MTFace *)cdl->data) + a;
2070                         flag = encode_tfaceflag(tf, 1);
2071
2072                         /* the name of the new material */
2073                         calculate_tface_materialname(ma->id.name, (char *)&idname, flag);
2074
2075                         if ((mat_new = BLI_findstring(&main->mat, idname + 2, offsetof(ID, name) + 2))) {
2076                                 /* material already existent, see if the mesh has it */
2077                                 mat_nr = mesh_getmaterialnumber(me, mat_new);
2078                                 /* material is not in the mesh, add it */
2079                                 if (mat_nr == -1) mat_nr = mesh_addmaterial(me, mat_new);
2080                         }
2081                         /* create a new material */
2082                         else {
2083                                 mat_new = BKE_material_copy(ma);
2084                                 if (mat_new) {
2085                                         /* rename the material*/
2086                                         BLI_strncpy(mat_new->id.name, idname, sizeof(mat_new->id.name));
2087                                         id_us_min((ID *)mat_new);
2088
2089                                         mat_nr = mesh_addmaterial(me, mat_new);
2090                                         decode_tfaceflag(mat_new, flag, 1);
2091                                 }
2092                                 else {
2093                                         printf("Error: Unable to create Material \"%s\" for Mesh \"%s.", idname + 2, me->id.name + 2);
2094                                         mat_nr = mf->mat_nr;
2095                                         continue;
2096                                 }
2097                         }
2098
2099                         /* if the material has a texture but no texture channel
2100                          * set "Face Textures [Alpha]" Material options
2101                          * actually we need to run it always, because of old behavior
2102                          * of using face texture if any texture channel was present (multitex) */
2103                         //if ((!mat_new->mtex[0]) && (!mat_new->mtex[0]->tex))
2104                         set_facetexture_flags(mat_new, tf->tpage);
2105
2106                         /* set the material number to the face*/
2107                         mf->mat_nr = mat_nr;
2108                 }
2109                 /* remove material from mesh */
2110                 for (a = 0; a < me->totcol; ) {
2111                         if (me->mat[a] == ma) {
2112                                 BKE_material_pop_id(&me->id, a, true);
2113                         }
2114                         else {
2115                                 a++;
2116                         }
2117                 }
2118         }
2119 }
2120
2121
2122 #define MAT_BGE_DISPUTED -99999
2123
2124 int do_version_tface(Main *main)
2125 {
2126         Mesh *me;
2127         Material *ma;
2128         MFace *mf;
2129         MTFace *tf;
2130         CustomDataLayer *cdl;
2131         int a;
2132         int flag;
2133         int index;
2134
2135         /* Operator in help menu has been removed for 2.7x */
2136         int fileload = 1;
2137
2138         /* sometimes mesh has no materials but will need a new one. In those
2139          * cases we need to ignore the mf->mat_nr and only look at the face
2140          * mode because it can be zero as uninitialized or the 1st created material
2141          */
2142         int nomaterialslots;
2143
2144         /* alert to user to check the console */
2145         int nowarning = 1;
2146
2147         /* mark all the materials to conversion with a flag
2148          * if there is tface create a complete flag for that storing in flag
2149          * if there is tface and flag > 0: creates a new flag based on this face
2150          * if flags are different set flag to -1
2151          */
2152
2153         /* 1st part: marking mesh materials to update */
2154         for (me = main->mesh.first; me; me = me->id.next) {
2155                 if (me->id.lib) continue;
2156
2157                 /* get the active tface layer */
2158                 index = CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
2159                 cdl = (index == -1) ? NULL : &me->fdata.layers[index];
2160                 if (!cdl) continue;
2161
2162                 nomaterialslots = (me->totcol == 0 ? 1 : 0);
2163
2164                 /* loop over all the faces*/
2165                 for (a = 0, mf = me->mface; a < me->totface; a++, mf++) {
2166                         /* texface data for this face */
2167                         tf = ((MTFace *)cdl->data) + a;
2168
2169                         /* conversion should happen only once */
2170                         if (fileload)
2171                                 tf->mode &= ~TF_CONVERTED;
2172                         else {
2173                                 if ((tf->mode & TF_CONVERTED)) continue;
2174                                 else tf->mode |= TF_CONVERTED;
2175                         }
2176
2177                         /* no material slots */
2178                         if (nomaterialslots) {
2179                                 flag = encode_tfaceflag(tf, 1);
2180
2181                                 /* create/find a new material and assign to the face */
2182                                 if (check_tfaceneedmaterial(flag)) {
2183                                         mf->mat_nr = convert_tfacenomaterial(main, me, tf, flag);
2184                                 }
2185                                 /* else mark them as no-material to be reverted to 0 later */
2186                                 else {
2187                                         mf->mat_nr = -1;
2188                                 }
2189                         }
2190                         else if (mf->mat_nr < me->totcol) {
2191                                 ma = me->mat[mf->mat_nr];
2192
2193                                 /* no material create one if necessary */
2194                                 if (!ma) {
2195                                         /* find a new material and assign to the face */
2196                                         flag = encode_tfaceflag(tf, 1);
2197
2198                                         /* create/find a new material and assign to the face */
2199                                         if (check_tfaceneedmaterial(flag))
2200                                                 mf->mat_nr = convert_tfacenomaterial(main, me, tf, flag);
2201
2202                                         continue;
2203                                 }
2204
2205                                 /* we can't read from this if it comes from a library,
2206                                  * at doversion time: direct_link might not have happened on it,
2207                                  * so ma->mtex is not pointing to valid memory yet.
2208                                  * later we could, but it's better not */
2209                                 else if (ma->id.lib)
2210                                         continue;
2211
2212                                 /* material already marked as disputed */
2213                                 else if (ma->game.flag == MAT_BGE_DISPUTED)
2214                                         continue;
2215
2216                                 /* found a material */
2217                                 else {
2218                                         flag = encode_tfaceflag(tf, ((fileload) ? 0 : 1));
2219
2220                                         /* first time changing this material */
2221                                         if (ma->game.flag == 0)
2222                                                 ma->game.flag = -flag;
2223
2224                                         /* mark material as disputed */
2225                                         else if (ma->game.flag != -flag) {
2226                                                 ma->game.flag = MAT_BGE_DISPUTED;
2227                                                 continue;
2228                                         }
2229
2230                                         /* material ok so far */
2231                                         else {
2232                                                 ma->game.flag = -flag;
2233
2234                                                 /* some people uses multitexture with TexFace by creating a texture
2235                                                  * channel which not necessarily the tf->tpage image. But the game engine
2236                                                  * was enabling it. Now it's required to set "Face Texture [Alpha] in the
2237                                                  * material settings. */
2238                                                 if (!fileload)
2239                                                         set_facetexture_flags(ma, tf->tpage);
2240                                         }
2241                                 }
2242                         }
2243                         else {
2244                                 continue;
2245                         }
2246                 }
2247
2248                 /* if we didn't have material slot and now we do, we need to
2249                  * make sure the materials are correct */
2250                 if (nomaterialslots) {
2251                         if (me->totcol > 0) {
2252                                 for (a = 0, mf = me->mface; a < me->totface; a++, mf++) {
2253                                         if (mf->mat_nr == -1) {
2254                                                 /* texface data for this face */
2255                                                 tf = ((MTFace *)cdl->data) + a;
2256                                                 mf->mat_nr = convert_tfacenomaterial(main, me, tf, encode_tfaceflag(tf, 1));
2257                                         }
2258                                 }
2259                         }
2260                         else {
2261                                 for (a = 0, mf = me->mface; a < me->totface; a++, mf++) {
2262                                         mf->mat_nr = 0;
2263                                 }
2264                         }
2265                 }
2266
2267         }
2268
2269         /* 2nd part - conversion */
2270         /* skip library files */
2271
2272         /* we shouldn't loop through the materials created in the loop. make the loop stop at its original length) */
2273         for (ma = main->mat.first, a = 0; ma; ma = ma->id.next, a++) {
2274                 if (ma->id.lib) continue;
2275
2276                 /* disputed material */
2277                 if (ma->game.flag == MAT_BGE_DISPUTED) {
2278                         ma->game.flag = 0;
2279                         if (fileload) {
2280                                 printf("Warning: material \"%s\" skipped.\n", ma->id.name + 2);
2281                                 nowarning = 0;
2282                         }
2283                         else {
2284                                 convert_tfacematerial(main, ma);
2285                         }
2286                         continue;
2287                 }
2288
2289                 /* no conflicts in this material - 90% of cases
2290                  * convert from tface system to material */
2291                 else if (ma->game.flag < 0) {
2292                         decode_tfaceflag(ma, -(ma->game.flag), 1);
2293
2294                         /* material is good make sure all faces using
2295                          * this material are set to converted */
2296                         if (fileload) {
2297                                 for (me = main->mesh.first; me; me = me->id.next) {
2298                                         /* check if this mesh uses this material */
2299                                         for (a = 0; a < me->totcol; a++)
2300                                                 if (me->mat[a] == ma) break;
2301
2302                                         /* no material found */
2303                                         if (a == me->totcol) continue;
2304
2305                                         /* get the active tface layer */
2306                                         index = CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
2307                                         cdl = (index == -1) ? NULL : &me->fdata.layers[index];
2308                                         if (!cdl) continue;
2309
2310                                         /* loop over all the faces and stop at the ones that use the material*/
2311                                         for (a = 0, mf = me->mface; a < me->totface; a++, mf++) {
2312                                                 if (me->mat[mf->mat_nr] == ma) {
2313                                                         /* texface data for this face */
2314                                                         tf = ((MTFace *)cdl->data) + a;
2315                                                         tf->mode |= TF_CONVERTED;
2316                                                 }
2317                                         }
2318                                 }
2319                         }
2320                 }
2321                 /* material is not used by faces with texface
2322                  * set the default flag - do it only once */
2323                 else {
2324                         if (fileload) {
2325                                 ma->game.flag = GEMAT_BACKCULL;
2326                         }
2327                 }
2328         }
2329
2330         return nowarning;
2331 }
2332