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