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