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