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