Merge branch 'master' into blender2.8
[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_library_query.h"
65 #include "BKE_library_remap.h"
66 #include "BKE_main.h"
67 #include "BKE_material.h"
68 #include "BKE_mesh.h"
69 #include "BKE_scene.h"
70 #include "BKE_node.h"
71 #include "BKE_curve.h"
72 #include "BKE_editmesh.h"
73 #include "BKE_font.h"
74
75 #include "DEG_depsgraph_build.h"
76
77 #include "GPU_material.h"
78
79 /* used in UI and render */
80 Material defmaterial;
81
82 /* called on startup, creator.c */
83 void init_def_material(void)
84 {
85         BKE_material_init(&defmaterial);
86 }
87
88 /** Free (or release) any data used by this material (does not free the material itself). */
89 void BKE_material_free(Material *ma)
90 {
91         int a;
92
93         BKE_animdata_free((ID *)ma, false);
94         
95         for (a = 0; a < MAX_MTEX; a++) {
96                 MEM_SAFE_FREE(ma->mtex[a]);
97         }
98         
99         MEM_SAFE_FREE(ma->ramp_col);
100         MEM_SAFE_FREE(ma->ramp_spec);
101         
102         /* is no lib link block, but material extension */
103         if (ma->nodetree) {
104                 ntreeFreeTree(ma->nodetree);
105                 MEM_freeN(ma->nodetree);
106                 ma->nodetree = NULL;
107         }
108
109         MEM_SAFE_FREE(ma->texpaintslot);
110
111         GPU_material_free(&ma->gpumaterial);
112
113         BKE_icon_id_delete((ID *)ma);
114         BKE_previewimg_free(&ma->preview);
115 }
116
117 void BKE_material_init(Material *ma)
118 {
119         BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(ma, id));
120
121         ma->r = ma->g = ma->b = ma->ref = 0.8;
122         ma->specr = ma->specg = ma->specb = 1.0;
123         ma->mirr = ma->mirg = ma->mirb = 1.0;
124         ma->spectra = 1.0;
125         ma->amb = 1.0;
126         ma->alpha = 1.0;
127         ma->spec = ma->hasize = 0.5;
128         ma->har = 50;
129         ma->starc = ma->ringc = 4;
130         ma->linec = 12;
131         ma->flarec = 1;
132         ma->flaresize = ma->subsize = 1.0;
133         ma->flareboost = 1;
134         ma->seed2 = 6;
135         ma->friction = 0.5;
136         ma->refrac = 4.0;
137         ma->roughness = 0.5;
138         ma->param[0] = 0.5;
139         ma->param[1] = 0.1;
140         ma->param[2] = 0.5;
141         ma->param[3] = 0.1;
142         ma->rms = 0.1;
143         ma->darkness = 1.0;
144
145         ma->strand_sta = ma->strand_end = 1.0f;
146
147         ma->ang = 1.0;
148         ma->ray_depth = 2;
149         ma->ray_depth_tra = 2;
150         ma->fresnel_mir = 0.0;
151         ma->fresnel_tra = 0.0;
152         ma->fresnel_tra_i = 1.25;
153         ma->fresnel_mir_i = 1.25;
154         ma->tx_limit = 0.0;
155         ma->tx_falloff = 1.0;
156         ma->shad_alpha = 1.0f;
157         ma->vcol_alpha = 0;
158         
159         ma->gloss_mir = ma->gloss_tra = 1.0;
160         ma->samp_gloss_mir = ma->samp_gloss_tra = 18;
161         ma->adapt_thresh_mir = ma->adapt_thresh_tra = 0.005;
162         ma->dist_mir = 0.0;
163         ma->fadeto_mir = MA_RAYMIR_FADETOSKY;
164         
165         ma->rampfac_col = 1.0;
166         ma->rampfac_spec = 1.0;
167         ma->pr_lamp = 3;         /* two lamps, is bits */
168         ma->pr_type = MA_SPHERE;
169
170         ma->sss_radius[0] = 1.0f;
171         ma->sss_radius[1] = 1.0f;
172         ma->sss_radius[2] = 1.0f;
173         ma->sss_col[0] = 1.0f;
174         ma->sss_col[1] = 1.0f;
175         ma->sss_col[2] = 1.0f;
176         ma->sss_error = 0.05f;
177         ma->sss_scale = 0.1f;
178         ma->sss_ior = 1.3f;
179         ma->sss_colfac = 1.0f;
180         ma->sss_texfac = 0.0f;
181         ma->sss_front = 1.0f;
182         ma->sss_back = 1.0f;
183
184         ma->vol.density = 1.0f;
185         ma->vol.emission = 0.0f;
186         ma->vol.scattering = 1.0f;
187         ma->vol.reflection = 1.0f;
188         ma->vol.transmission_col[0] = ma->vol.transmission_col[1] = ma->vol.transmission_col[2] = 1.0f;
189         ma->vol.reflection_col[0] = ma->vol.reflection_col[1] = ma->vol.reflection_col[2] = 1.0f;
190         ma->vol.emission_col[0] = ma->vol.emission_col[1] = ma->vol.emission_col[2] = 1.0f;
191         ma->vol.density_scale = 1.0f;
192         ma->vol.depth_cutoff = 0.01f;
193         ma->vol.stepsize_type = MA_VOL_STEP_RANDOMIZED;
194         ma->vol.stepsize = 0.2f;
195         ma->vol.shade_type = MA_VOL_SHADE_SHADED;
196         ma->vol.shadeflag |= MA_VOL_PRECACHESHADING;
197         ma->vol.precache_resolution = 50;
198         ma->vol.ms_spread = 0.2f;
199         ma->vol.ms_diff = 1.f;
200         ma->vol.ms_intensity = 1.f;
201         
202         ma->game.flag = GEMAT_BACKCULL;
203         ma->game.alpha_blend = 0;
204         ma->game.face_orientation = 0;
205         
206         ma->mode = MA_TRACEBLE | MA_SHADBUF | MA_SHADOW | MA_RAYBIAS | MA_TANGENT_STR | MA_ZTRANSP;
207         ma->mode2 = MA_CASTSHADOW;
208         ma->shade_flag = MA_APPROX_OCCLUSION;
209         ma->preview = NULL;
210
211         ma->alpha_threshold = 0.5f;
212 }
213
214 Material *BKE_material_add(Main *bmain, const char *name)
215 {
216         Material *ma;
217
218         ma = BKE_libblock_alloc(bmain, ID_MA, name, 0);
219         
220         BKE_material_init(ma);
221         
222         return ma;
223 }
224
225 /**
226  * Only copy internal data of Material ID from source to already allocated/initialized destination.
227  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
228  *
229  * WARNING! This function will not handle ID user count!
230  *
231  * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
232  */
233 void BKE_material_copy_data(Main *bmain, Material *ma_dst, const Material *ma_src, const int flag)
234 {
235         for (int a = 0; a < MAX_MTEX; a++) {
236                 if (ma_src->mtex[a]) {
237                         ma_dst->mtex[a] = MEM_mallocN(sizeof(*ma_dst->mtex[a]), __func__);
238                         *ma_dst->mtex[a] = *ma_src->mtex[a];
239                 }
240         }
241
242         if (ma_src->ramp_col) {
243                 ma_dst->ramp_col = MEM_dupallocN(ma_src->ramp_col);
244         }
245         if (ma_src->ramp_spec) {
246                 ma_dst->ramp_spec = MEM_dupallocN(ma_src->ramp_spec);
247         }
248
249         if (ma_src->nodetree) {
250                 BKE_id_copy_ex(bmain, (ID *)ma_src->nodetree, (ID **)&ma_dst->nodetree, flag, false);
251         }
252
253         if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
254                 BKE_previewimg_id_copy(&ma_dst->id, &ma_src->id);
255         }
256         else {
257                 ma_dst->preview = NULL;
258         }
259
260         BLI_listbase_clear(&ma_dst->gpumaterial);
261
262         /* TODO Duplicate Engine Settings and set runtime to NULL */
263 }
264
265 Material *BKE_material_copy(Main *bmain, const Material *ma)
266 {
267         Material *ma_copy;
268         BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy, 0, false);
269         return ma_copy;
270 }
271
272 /* XXX (see above) material copy without adding to main dbase */
273 Material *localize_material(Material *ma)
274 {
275         /* TODO replace with something like
276          *      Material *ma_copy;
277          *      BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy, LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT, false);
278          *      return ma_copy;
279          *
280          * ... Once f*** nodes are fully converted to that too :( */
281
282         Material *man;
283         int a;
284         
285         man = BKE_libblock_copy_nolib(&ma->id, false);
286
287         /* no increment for texture ID users, in previewrender.c it prevents decrement */
288         for (a = 0; a < MAX_MTEX; a++) {
289                 if (ma->mtex[a]) {
290                         man->mtex[a] = MEM_mallocN(sizeof(MTex), "copymaterial");
291                         memcpy(man->mtex[a], ma->mtex[a], sizeof(MTex));
292                 }
293         }
294         
295         if (ma->ramp_col) man->ramp_col = MEM_dupallocN(ma->ramp_col);
296         if (ma->ramp_spec) man->ramp_spec = MEM_dupallocN(ma->ramp_spec);
297
298         man->texpaintslot = NULL;
299         man->preview = NULL;
300         
301         if (ma->nodetree)
302                 man->nodetree = ntreeLocalize(ma->nodetree);
303         
304         BLI_listbase_clear(&man->gpumaterial);
305
306         /* TODO Duplicate Engine Settings and set runtime to NULL */
307         
308         return man;
309 }
310
311 void BKE_material_make_local(Main *bmain, Material *ma, const bool lib_local)
312 {
313         BKE_id_make_local_generic(bmain, &ma->id, true, lib_local);
314 }
315
316 Material ***give_matarar(Object *ob)
317 {
318         Mesh *me;
319         Curve *cu;
320         MetaBall *mb;
321         
322         if (ob->type == OB_MESH) {
323                 me = ob->data;
324                 return &(me->mat);
325         }
326         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
327                 cu = ob->data;
328                 return &(cu->mat);
329         }
330         else if (ob->type == OB_MBALL) {
331                 mb = ob->data;
332                 return &(mb->mat);
333         }
334         return NULL;
335 }
336
337 short *give_totcolp(Object *ob)
338 {
339         Mesh *me;
340         Curve *cu;
341         MetaBall *mb;
342         
343         if (ob->type == OB_MESH) {
344                 me = ob->data;
345                 return &(me->totcol);
346         }
347         else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
348                 cu = ob->data;
349                 return &(cu->totcol);
350         }
351         else if (ob->type == OB_MBALL) {
352                 mb = ob->data;
353                 return &(mb->totcol);
354         }
355         return NULL;
356 }
357
358 /* same as above but for ID's */
359 Material ***give_matarar_id(ID *id)
360 {
361         /* ensure we don't try get materials from non-obdata */
362         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
363
364         switch (GS(id->name)) {
365                 case ID_ME:
366                         return &(((Mesh *)id)->mat);
367                 case ID_CU:
368                         return &(((Curve *)id)->mat);
369                 case ID_MB:
370                         return &(((MetaBall *)id)->mat);
371                 default:
372                         break;
373         }
374         return NULL;
375 }
376
377 short *give_totcolp_id(ID *id)
378 {
379         /* ensure we don't try get materials from non-obdata */
380         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
381
382         switch (GS(id->name)) {
383                 case ID_ME:
384                         return &(((Mesh *)id)->totcol);
385                 case ID_CU:
386                         return &(((Curve *)id)->totcol);
387                 case ID_MB:
388                         return &(((MetaBall *)id)->totcol);
389                 default:
390                         break;
391         }
392         return NULL;
393 }
394
395 static void material_data_index_remove_id(ID *id, short index)
396 {
397         /* ensure we don't try get materials from non-obdata */
398         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
399
400         switch (GS(id->name)) {
401                 case ID_ME:
402                         BKE_mesh_material_index_remove((Mesh *)id, index);
403                         break;
404                 case ID_CU:
405                         BKE_curve_material_index_remove((Curve *)id, index);
406                         break;
407                 case ID_MB:
408                         /* meta-elems don't have materials atm */
409                         break;
410                 default:
411                         break;
412         }
413 }
414
415 static void material_data_index_clear_id(ID *id)
416 {
417         /* ensure we don't try get materials from non-obdata */
418         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
419
420         switch (GS(id->name)) {
421                 case ID_ME:
422                         BKE_mesh_material_index_clear((Mesh *)id);
423                         break;
424                 case ID_CU:
425                         BKE_curve_material_index_clear((Curve *)id);
426                         break;
427                 case ID_MB:
428                         /* meta-elems don't have materials atm */
429                         break;
430                 default:
431                         break;
432         }
433 }
434
435 void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
436 {
437         Material ***matar = give_matarar_id(id);
438         short *totcolp = give_totcolp_id(id);
439
440         if (matar == NULL) {
441                 return;
442         }
443
444         if (do_id_user && totcol < (*totcolp)) {
445                 short i;
446                 for (i = totcol; i < (*totcolp); i++) {
447                         id_us_min((ID *)(*matar)[i]);
448                 }
449         }
450
451         if (totcol == 0) {
452                 if (*totcolp) {
453                         MEM_freeN(*matar);
454                         *matar = NULL;
455                 }
456         }
457         else {
458                 *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
459         }
460         *totcolp = totcol;
461
462         DEG_relations_tag_update(bmain);
463 }
464
465 void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
466 {
467         Material ***matar;
468         if ((matar = give_matarar_id(id))) {
469                 short *totcol = give_totcolp_id(id);
470                 Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
471                 if (*totcol) memcpy(mat, *matar, sizeof(void *) * (*totcol));
472                 if (*matar) MEM_freeN(*matar);
473
474                 *matar = mat;
475                 (*matar)[(*totcol)++] = ma;
476
477                 id_us_plus((ID *)ma);
478                 test_all_objects_materials(bmain, id);
479                 DEG_relations_tag_update(bmain);
480         }
481 }
482
483 Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i, bool update_data)
484 {
485         short index = (short)index_i;
486         Material *ret = NULL;
487         Material ***matar;
488         if ((matar = give_matarar_id(id))) {
489                 short *totcol = give_totcolp_id(id);
490                 if (index >= 0 && index < (*totcol)) {
491                         ret = (*matar)[index];
492                         id_us_min((ID *)ret);
493
494                         if (*totcol <= 1) {
495                                 *totcol = 0;
496                                 MEM_freeN(*matar);
497                                 *matar = NULL;
498                         }
499                         else {
500                                 if (index + 1 != (*totcol))
501                                         memmove((*matar) + index, (*matar) + (index + 1), sizeof(void *) * ((*totcol) - (index + 1)));
502
503                                 (*totcol)--;
504                                 *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
505                                 test_all_objects_materials(G.main, id);
506                         }
507
508                         if (update_data) {
509                                 /* decrease mat_nr index */
510                                 material_data_index_remove_id(id, index);
511                         }
512
513                         DEG_relations_tag_update(bmain);
514                 }
515         }
516         
517         return ret;
518 }
519
520 void BKE_material_clear_id(Main *bmain, ID *id, bool update_data)
521 {
522         Material ***matar;
523         if ((matar = give_matarar_id(id))) {
524                 short *totcol = give_totcolp_id(id);
525
526                 while ((*totcol)--) {
527                         id_us_min((ID *)((*matar)[*totcol]));
528                 }
529                 *totcol = 0;
530                 if (*matar) {
531                         MEM_freeN(*matar);
532                         *matar = NULL;
533                 }
534
535                 if (update_data) {
536                         /* decrease mat_nr index */
537                         material_data_index_clear_id(id);
538                 }
539
540                 DEG_relations_tag_update(bmain);
541         }
542 }
543
544 Material *give_current_material(Object *ob, short act)
545 {
546         Material ***matarar, *ma;
547         const short *totcolp;
548
549         if (ob == NULL) return NULL;
550         
551         /* if object cannot have material, (totcolp == NULL) */
552         totcolp = give_totcolp(ob);
553         if (totcolp == NULL || ob->totcol == 0) return NULL;
554
555         /* return NULL for invalid 'act', can happen for mesh face indices */
556         if (act > ob->totcol)
557                 return NULL;
558         else if (act <= 0) {
559                 if (act < 0) {
560                         printf("Negative material index!\n");
561                 }
562                 return NULL;
563         }
564
565         if (ob->matbits && ob->matbits[act - 1]) {    /* in object */
566                 ma = ob->mat[act - 1];
567         }
568         else {                              /* in data */
569
570                 /* check for inconsistency */
571                 if (*totcolp < ob->totcol)
572                         ob->totcol = *totcolp;
573                 if (act > ob->totcol) act = ob->totcol;
574
575                 matarar = give_matarar(ob);
576                 
577                 if (matarar && *matarar) ma = (*matarar)[act - 1];
578                 else ma = NULL;
579                 
580         }
581         
582         return ma;
583 }
584
585 Material *give_node_material(Material *ma)
586 {
587         if (ma && ma->use_nodes && ma->nodetree) {
588                 bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
589
590                 if (node)
591                         return (Material *)node->id;
592         }
593
594         return NULL;
595 }
596
597 void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
598 {
599         Material **newmatar;
600         char *newmatbits;
601
602         if (do_id_user && totcol < ob->totcol) {
603                 short i;
604                 for (i = totcol; i < ob->totcol; i++) {
605                         id_us_min((ID *)ob->mat[i]);
606                 }
607         }
608
609         if (totcol == 0) {
610                 if (ob->totcol) {
611                         MEM_freeN(ob->mat);
612                         MEM_freeN(ob->matbits);
613                         ob->mat = NULL;
614                         ob->matbits = NULL;
615                 }
616         }
617         else if (ob->totcol < totcol) {
618                 newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
619                 newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
620                 if (ob->totcol) {
621                         memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
622                         memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
623                         MEM_freeN(ob->mat);
624                         MEM_freeN(ob->matbits);
625                 }
626                 ob->mat = newmatar;
627                 ob->matbits = newmatbits;
628         }
629         /* XXX, why not realloc on shrink? - campbell */
630
631         ob->totcol = totcol;
632         if (ob->totcol && ob->actcol == 0) ob->actcol = 1;
633         if (ob->actcol > ob->totcol) ob->actcol = ob->totcol;
634
635         DEG_relations_tag_update(bmain);
636 }
637
638 void test_object_materials(Object *ob, ID *id)
639 {
640         /* make the ob mat-array same size as 'ob->data' mat-array */
641         const short *totcol;
642
643         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
644                 return;
645         }
646
647         BKE_material_resize_object(G.main, ob, *totcol, false);
648 }
649
650 void test_all_objects_materials(Main *bmain, ID *id)
651 {
652         /* make the ob mat-array same size as 'ob->data' mat-array */
653         Object *ob;
654         const short *totcol;
655
656         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
657                 return;
658         }
659
660         BKE_main_lock(bmain);
661         for (ob = bmain->object.first; ob; ob = ob->id.next) {
662                 if (ob->data == id) {
663                         BKE_material_resize_object(bmain, ob, *totcol, false);
664                 }
665         }
666         BKE_main_unlock(bmain);
667 }
668
669 void assign_material_id(ID *id, Material *ma, short act)
670 {
671         Material *mao, **matar, ***matarar;
672         short *totcolp;
673
674         if (act > MAXMAT) return;
675         if (act < 1) act = 1;
676
677         /* this is needed for Python overrides,
678          * we just have to take care that the UI can't do this */
679 #if 0
680         /* prevent crashing when using accidentally */
681         BLI_assert(id->lib == NULL);
682         if (id->lib) return;
683 #endif
684
685         /* test arraylens */
686
687         totcolp = give_totcolp_id(id);
688         matarar = give_matarar_id(id);
689
690         if (totcolp == NULL || matarar == NULL) return;
691
692         if (act > *totcolp) {
693                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
694
695                 if (*totcolp) {
696                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
697                         MEM_freeN(*matarar);
698                 }
699
700                 *matarar = matar;
701                 *totcolp = act;
702         }
703
704         /* in data */
705         mao = (*matarar)[act - 1];
706         if (mao)
707                 id_us_min(&mao->id);
708         (*matarar)[act - 1] = ma;
709
710         if (ma)
711                 id_us_plus(&ma->id);
712
713         test_all_objects_materials(G.main, id);
714 }
715
716 void assign_material(Object *ob, Material *ma, short act, int assign_type)
717 {
718         Material *mao, **matar, ***matarar;
719         short *totcolp;
720         char bit = 0;
721
722         if (act > MAXMAT) return;
723         if (act < 1) act = 1;
724         
725         /* prevent crashing when using accidentally */
726         BLI_assert(!ID_IS_LINKED_DATABLOCK(ob));
727         if (ID_IS_LINKED_DATABLOCK(ob)) return;
728         
729         /* test arraylens */
730         
731         totcolp = give_totcolp(ob);
732         matarar = give_matarar(ob);
733         
734         if (totcolp == NULL || matarar == NULL) return;
735         
736         if (act > *totcolp) {
737                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
738
739                 if (*totcolp) {
740                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
741                         MEM_freeN(*matarar);
742                 }
743
744                 *matarar = matar;
745                 *totcolp = act;
746         }
747
748         if (act > ob->totcol) {
749                 /* Need more space in the material arrays */
750                 ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
751                 ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
752                 ob->totcol = act;
753         }
754
755         /* Determine the object/mesh linking */
756         if (assign_type == BKE_MAT_ASSIGN_EXISTING) {
757                 /* keep existing option (avoid confusion in scripts),
758                  * intentionally ignore userpref (default to obdata). */
759                 bit = ob->matbits[act - 1];
760         }
761         else if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
762                 /* copy from previous material */
763                 bit = ob->matbits[ob->actcol - 1];
764         }
765         else {
766                 switch (assign_type) {
767                         case BKE_MAT_ASSIGN_OBDATA:
768                                 bit = 0;
769                                 break;
770                         case BKE_MAT_ASSIGN_OBJECT:
771                                 bit = 1;
772                                 break;
773                         case BKE_MAT_ASSIGN_USERPREF:
774                         default:
775                                 bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
776                                 break;
777                 }
778         }
779         
780         /* do it */
781
782         ob->matbits[act - 1] = bit;
783         if (bit == 1) {   /* in object */
784                 mao = ob->mat[act - 1];
785                 if (mao)
786                         id_us_min(&mao->id);
787                 ob->mat[act - 1] = ma;
788                 test_object_materials(ob, ob->data);
789         }
790         else {  /* in data */
791                 mao = (*matarar)[act - 1];
792                 if (mao)
793                         id_us_min(&mao->id);
794                 (*matarar)[act - 1] = ma;
795                 test_all_objects_materials(G.main, ob->data);  /* Data may be used by several objects... */
796         }
797
798         if (ma)
799                 id_us_plus(&ma->id);
800 }
801
802
803 void BKE_material_remap_object(Object *ob, const unsigned int *remap)
804 {
805         Material ***matar = give_matarar(ob);
806         const short *totcol_p = give_totcolp(ob);
807
808         BLI_array_permute(ob->mat, ob->totcol, remap);
809
810         if (ob->matbits) {
811                 BLI_array_permute(ob->matbits, ob->totcol, remap);
812         }
813
814         if (matar) {
815                 BLI_array_permute(*matar, *totcol_p, remap);
816         }
817
818         if (ob->type == OB_MESH) {
819                 BKE_mesh_material_remap(ob->data, remap, ob->totcol);
820         }
821         else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
822                 BKE_curve_material_remap(ob->data, remap, ob->totcol);
823         }
824         else {
825                 /* add support for this object data! */
826                 BLI_assert(matar == NULL);
827         }
828 }
829
830 /**
831  * Calculate a material remapping from \a ob_src to \a ob_dst.
832  *
833  * \param remap_src_to_dst: An array the size of `ob_src->totcol`
834  * where index values are filled in which map to \a ob_dst materials.
835  */
836 void BKE_material_remap_object_calc(
837         Object *ob_dst, Object *ob_src,
838         short *remap_src_to_dst)
839 {
840         if (ob_src->totcol == 0) {
841                 return;
842         }
843
844         GHash *gh_mat_map = BLI_ghash_ptr_new_ex(__func__, ob_src->totcol);
845
846         for (int i = 0; i < ob_dst->totcol; i++) {
847                 Material *ma_src = give_current_material(ob_dst, i + 1);
848                 BLI_ghash_reinsert(gh_mat_map, ma_src, SET_INT_IN_POINTER(i), NULL, NULL);
849         }
850
851         /* setup default mapping (when materials don't match) */
852         {
853                 int i = 0;
854                 if (ob_dst->totcol >= ob_src->totcol) {
855                         for (; i < ob_src->totcol; i++) {
856                                 remap_src_to_dst[i] = i;
857                         }
858                 }
859                 else {
860                         for (; i < ob_dst->totcol; i++) {
861                                 remap_src_to_dst[i] = i;
862                         }
863                         for (; i < ob_src->totcol; i++) {
864                                 remap_src_to_dst[i] = 0;
865                         }
866                 }
867         }
868
869         for (int i = 0; i < ob_src->totcol; i++) {
870                 Material *ma_src = give_current_material(ob_src, i + 1);
871
872                 if ((i < ob_dst->totcol) && (ma_src == give_current_material(ob_dst, i + 1))) {
873                         /* when objects have exact matching materials - keep existing index */
874                 }
875                 else {
876                         void **index_src_p = BLI_ghash_lookup_p(gh_mat_map, ma_src);
877                         if (index_src_p) {
878                                 remap_src_to_dst[i] = GET_INT_FROM_POINTER(*index_src_p);
879                         }
880                 }
881         }
882
883         BLI_ghash_free(gh_mat_map, NULL, NULL);
884 }
885
886
887 /* XXX - this calls many more update calls per object then are needed, could be optimized */
888 void assign_matarar(struct Object *ob, struct Material ***matar, short totcol)
889 {
890         int actcol_orig = ob->actcol;
891         short i;
892
893         while ((ob->totcol > totcol) &&
894                BKE_object_material_slot_remove(ob))
895         {
896                 /* pass */
897         }
898
899         /* now we have the right number of slots */
900         for (i = 0; i < totcol; i++)
901                 assign_material(ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
902
903         if (actcol_orig > ob->totcol)
904                 actcol_orig = ob->totcol;
905
906         ob->actcol = actcol_orig;
907 }
908
909
910 short BKE_object_material_slot_find_index(Object *ob, Material *ma)
911 {
912         Material ***matarar;
913         short a, *totcolp;
914         
915         if (ma == NULL) return 0;
916         
917         totcolp = give_totcolp(ob);
918         matarar = give_matarar(ob);
919         
920         if (totcolp == NULL || matarar == NULL) return 0;
921         
922         for (a = 0; a < *totcolp; a++)
923                 if ((*matarar)[a] == ma)
924                         break;
925         if (a < *totcolp)
926                 return a + 1;
927         return 0;
928 }
929
930 bool BKE_object_material_slot_add(Object *ob)
931 {
932         if (ob == NULL) return false;
933         if (ob->totcol >= MAXMAT) return false;
934         
935         assign_material(ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
936         ob->actcol = ob->totcol;
937         return true;
938 }
939
940 static void do_init_render_material(Material *ma, int r_mode, float *amb)
941 {
942         MTex *mtex;
943         int a, needuv = 0, needtang = 0;
944         
945         if (ma->flarec == 0) ma->flarec = 1;
946
947         /* add all texcoflags from mtex, texco and mapto were cleared in advance */
948         for (a = 0; a < MAX_MTEX; a++) {
949                 
950                 /* separate tex switching */
951                 if (ma->septex & (1 << a)) continue;
952
953                 mtex = ma->mtex[a];
954                 if (mtex && mtex->tex && (mtex->tex->type | (mtex->tex->use_nodes && mtex->tex->nodetree) )) {
955                         
956                         ma->texco |= mtex->texco;
957                         ma->mapto |= mtex->mapto;
958
959                         /* always get derivatives for these textures */
960                         if (ELEM(mtex->tex->type, TEX_IMAGE, TEX_ENVMAP)) ma->texco |= TEXCO_OSA;
961                         else if (mtex->texflag & (MTEX_COMPAT_BUMP | MTEX_3TAP_BUMP | MTEX_5TAP_BUMP | MTEX_BICUBIC_BUMP)) ma->texco |= TEXCO_OSA;
962                         
963                         if (ma->texco & (TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM | TEXCO_STRAND | TEXCO_STRESS)) needuv = 1;
964                         else if (ma->texco & (TEXCO_GLOB | TEXCO_UV | TEXCO_OBJECT | TEXCO_SPEED)) needuv = 1;
965                         else if (ma->texco & (TEXCO_LAVECTOR | TEXCO_VIEW)) needuv = 1;
966
967                         if ((ma->mapto & MAP_NORM) && (mtex->normapspace == MTEX_NSPACE_TANGENT))
968                                 needtang = 1;
969                 }
970         }
971
972         if (needtang) ma->mode |= MA_NORMAP_TANG;
973         else ma->mode &= ~MA_NORMAP_TANG;
974         
975         if (ma->mode & (MA_VERTEXCOL | MA_VERTEXCOLP)) {
976                 needuv = 1;
977                 if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;     /* for texfaces */
978         }
979         if (needuv) ma->texco |= NEED_UV;
980         
981         /* since the raytracer doesnt recalc O structs for each ray, we have to preset them all */
982         if (r_mode & R_RAYTRACE) {
983                 if ((ma->mode & (MA_RAYMIRROR | MA_SHADOW_TRA)) || ((ma->mode & MA_TRANSP) && (ma->mode & MA_RAYTRANSP))) {
984                         ma->texco |= NEED_UV | TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM;
985                         if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;
986                 }
987         }
988         
989         if (amb) {
990                 ma->ambr = ma->amb * amb[0];
991                 ma->ambg = ma->amb * amb[1];
992                 ma->ambb = ma->amb * amb[2];
993         }
994
995         /* local group override */
996         if ((ma->shade_flag & MA_GROUP_LOCAL) && ma->id.lib && ma->group && ma->group->id.lib) {
997                 Group *group;
998
999                 for (group = G.main->group.first; group; group = group->id.next) {
1000                         if (!ID_IS_LINKED_DATABLOCK(group) && STREQ(group->id.name, ma->group->id.name)) {
1001                                 ma->group = group;
1002                         }
1003                 }
1004         }
1005 }
1006
1007 static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode, float *amb)
1008 {
1009         bNode *node;
1010
1011         /* parses the geom+tex nodes */
1012         ntreeShaderGetTexcoMode(ntree, r_mode, &basemat->texco, &basemat->mode_l);
1013         for (node = ntree->nodes.first; node; node = node->next) {
1014                 if (node->id) {
1015                         if (GS(node->id->name) == ID_MA) {
1016                                 Material *ma = (Material *)node->id;
1017                                 if (ma != basemat) {
1018                                         do_init_render_material(ma, r_mode, amb);
1019                                         basemat->texco |= ma->texco;
1020                                 }
1021
1022                                 basemat->mode_l |= ma->mode & ~(MA_MODE_PIPELINE | MA_SHLESS);
1023                                 basemat->mode2_l |= ma->mode2 & ~MA_MODE2_PIPELINE;
1024                                 /* basemat only considered shadeless if all node materials are too */
1025                                 if (!(ma->mode & MA_SHLESS))
1026                                         basemat->mode_l &= ~MA_SHLESS;
1027
1028                                 if (ma->strand_surfnor > 0.0f)
1029                                         basemat->mode_l |= MA_STR_SURFDIFF;
1030                         }
1031                         else if (node->type == NODE_GROUP)
1032                                 init_render_nodetree((bNodeTree *)node->id, basemat, r_mode, amb);
1033                 }
1034                 else if (node->typeinfo->type == SH_NODE_NORMAL_MAP) {
1035                         basemat->mode2_l |= MA_TANGENT_CONCRETE;
1036                         NodeShaderNormalMap *nm = node->storage;
1037                         bool taken_into_account = false;
1038                         for (int i = 0; i < basemat->nmap_tangent_names_count; i++) {
1039                                 if (STREQ(basemat->nmap_tangent_names[i], nm->uv_map)) {
1040                                         taken_into_account = true;
1041                                         break;
1042                                 }
1043                         }
1044                         if (!taken_into_account) {
1045                                 BLI_assert(basemat->nmap_tangent_names_count < MAX_MTFACE + 1);
1046                                 strcpy(basemat->nmap_tangent_names[basemat->nmap_tangent_names_count++], nm->uv_map);
1047                         }
1048                 }
1049         }
1050 }
1051
1052 void init_render_material(Material *mat, int r_mode, float *amb)
1053 {
1054         
1055         do_init_render_material(mat, r_mode, amb);
1056         
1057         if (mat->nodetree && mat->use_nodes) {
1058                 /* mode_l will take the pipeline options from the main material, and the or-ed
1059                  * result of non-pipeline options from the nodes. shadeless is an exception,
1060                  * mode_l will have it set when all node materials are shadeless. */
1061                 mat->mode_l = (mat->mode & MA_MODE_PIPELINE) | MA_SHLESS;
1062                 mat->mode2_l = mat->mode2 & MA_MODE2_PIPELINE;
1063                 mat->nmap_tangent_names_count = 0;
1064                 init_render_nodetree(mat->nodetree, mat, r_mode, amb);
1065                 
1066                 if (!mat->nodetree->execdata)
1067                         mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree);
1068         }
1069         else {
1070                 mat->mode_l = mat->mode;
1071                 mat->mode2_l = mat->mode2;
1072
1073                 if (mat->strand_surfnor > 0.0f)
1074                         mat->mode_l |= MA_STR_SURFDIFF;
1075         }
1076 }
1077
1078 void init_render_materials(Main *bmain, int r_mode, float *amb, bool do_default_material)
1079 {
1080         Material *ma;
1081         
1082         /* clear these flags before going over materials, to make sure they
1083          * are cleared only once, otherwise node materials contained in other
1084          * node materials can go wrong */
1085         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1086                 if (ma->id.us) {
1087                         ma->texco = 0;
1088                         ma->mapto = 0;
1089                 }
1090         }
1091
1092         /* two steps, first initialize, then or the flags for layers */
1093         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1094                 /* is_used flag comes back in convertblender.c */
1095                 ma->flag &= ~MA_IS_USED;
1096                 if (ma->id.us) 
1097                         init_render_material(ma, r_mode, amb);
1098         }
1099
1100         if (do_default_material) {
1101                 init_render_material(&defmaterial, r_mode, amb);
1102         }
1103 }
1104
1105 /* only needed for nodes now */
1106 void end_render_material(Material *mat)
1107 {
1108         if (mat && mat->nodetree && mat->use_nodes) {
1109                 if (mat->nodetree->execdata)
1110                         ntreeShaderEndExecTree(mat->nodetree->execdata);
1111         }
1112 }
1113
1114 void end_render_materials(Main *bmain)
1115 {
1116         Material *ma;
1117         for (ma = bmain->mat.first; ma; ma = ma->id.next)
1118                 if (ma->id.us) 
1119                         end_render_material(ma);
1120 }
1121
1122 static bool material_in_nodetree(bNodeTree *ntree, Material *mat)
1123 {
1124         bNode *node;
1125
1126         for (node = ntree->nodes.first; node; node = node->next) {
1127                 if (node->id) {
1128                         if (GS(node->id->name) == ID_MA) {
1129                                 if (node->id == (ID *)mat) {
1130                                         return true;
1131                                 }
1132                         }
1133                         else if (node->type == NODE_GROUP) {
1134                                 if (material_in_nodetree((bNodeTree *)node->id, mat)) {
1135                                         return true;
1136                                 }
1137                         }
1138                 }
1139         }
1140
1141         return false;
1142 }
1143
1144 bool material_in_material(Material *parmat, Material *mat)
1145 {
1146         if (parmat == mat)
1147                 return true;
1148         else if (parmat->nodetree && parmat->use_nodes)
1149                 return material_in_nodetree(parmat->nodetree, mat);
1150         else
1151                 return false;
1152 }
1153
1154
1155 /* ****************** */
1156
1157 /* Update drivers for materials in a nodetree */
1158 static void material_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
1159 {
1160         bNode *node;
1161
1162         /* nodetree itself */
1163         if (ntree->adt && ntree->adt->drivers.first) {
1164                 BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
1165         }
1166         
1167         /* nodes */
1168         for (node = ntree->nodes.first; node; node = node->next) {
1169                 if (node->id) {
1170                         if (GS(node->id->name) == ID_MA) {
1171                                 material_drivers_update(scene, (Material *)node->id, ctime);
1172                         }
1173                         else if (node->type == NODE_GROUP) {
1174                                 material_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
1175                         }
1176                 }
1177         }
1178 }
1179
1180 /* Calculate all drivers for materials 
1181  * FIXME: this is really a terrible method which may result in some things being calculated
1182  * multiple times. However, without proper despgraph support for these things, we are forced
1183  * into this sort of thing...
1184  */
1185 void material_drivers_update(Scene *scene, Material *ma, float ctime)
1186 {
1187         //if (G.f & G_DEBUG)
1188         //      printf("material_drivers_update(%s, %s)\n", scene->id.name, ma->id.name);
1189         
1190         /* Prevent infinite recursion by checking (and tagging the material) as having been visited already
1191          * (see BKE_scene_update_tagged()). This assumes ma->id.tag & LIB_TAG_DOIT isn't set by anything else
1192          * in the meantime... [#32017]
1193          */
1194         if (ma->id.tag & LIB_TAG_DOIT)
1195                 return;
1196
1197         ma->id.tag |= LIB_TAG_DOIT;
1198         
1199         /* material itself */
1200         if (ma->adt && ma->adt->drivers.first) {
1201                 BKE_animsys_evaluate_animdata(scene, &ma->id, ma->adt, ctime, ADT_RECALC_DRIVERS);
1202         }
1203         
1204         /* nodes */
1205         if (ma->nodetree) {
1206                 material_node_drivers_update(scene, ma->nodetree, ctime);
1207         }
1208
1209         ma->id.tag &= ~LIB_TAG_DOIT;
1210 }
1211
1212 bool BKE_object_material_slot_remove(Object *ob)
1213 {
1214         Material *mao, ***matarar;
1215         Object *obt;
1216         short *totcolp;
1217         short a, actcol;
1218         
1219         if (ob == NULL || ob->totcol == 0) {
1220                 return false;
1221         }
1222
1223         /* this should never happen and used to crash */
1224         if (ob->actcol <= 0) {
1225                 printf("%s: invalid material index %d, report a bug!\n", __func__, ob->actcol);
1226                 BLI_assert(0);
1227                 return false;
1228         }
1229
1230         /* take a mesh/curve/mball as starting point, remove 1 index,
1231          * AND with all objects that share the ob->data
1232          * 
1233          * after that check indices in mesh/curve/mball!!!
1234          */
1235         
1236         totcolp = give_totcolp(ob);
1237         matarar = give_matarar(ob);
1238
1239         if (ELEM(NULL, matarar, *matarar)) {
1240                 return false;
1241         }
1242
1243         /* can happen on face selection in editmode */
1244         if (ob->actcol > ob->totcol) {
1245                 ob->actcol = ob->totcol;
1246         }
1247         
1248         /* we delete the actcol */
1249         mao = (*matarar)[ob->actcol - 1];
1250         if (mao)
1251                 id_us_min(&mao->id);
1252         
1253         for (a = ob->actcol; a < ob->totcol; a++)
1254                 (*matarar)[a - 1] = (*matarar)[a];
1255         (*totcolp)--;
1256         
1257         if (*totcolp == 0) {
1258                 MEM_freeN(*matarar);
1259                 *matarar = NULL;
1260         }
1261         
1262         actcol = ob->actcol;
1263         obt = G.main->object.first;
1264         while (obt) {
1265         
1266                 if (obt->data == ob->data) {
1267                         
1268                         /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
1269                         mao = obt->mat[actcol - 1];
1270                         if (mao)
1271                                 id_us_min(&mao->id);
1272                 
1273                         for (a = actcol; a < obt->totcol; a++) {
1274                                 obt->mat[a - 1] = obt->mat[a];
1275                                 obt->matbits[a - 1] = obt->matbits[a];
1276                         }
1277                         obt->totcol--;
1278                         if (obt->actcol > obt->totcol) obt->actcol = obt->totcol;
1279                         
1280                         if (obt->totcol == 0) {
1281                                 MEM_freeN(obt->mat);
1282                                 MEM_freeN(obt->matbits);
1283                                 obt->mat = NULL;
1284                                 obt->matbits = NULL;
1285                         }
1286                 }
1287                 obt = obt->id.next;
1288         }
1289
1290         /* check indices from mesh */
1291         if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT)) {
1292                 material_data_index_remove_id((ID *)ob->data, actcol - 1);
1293                 if (ob->curve_cache) {
1294                         BKE_displist_free(&ob->curve_cache->disp);
1295                 }
1296         }
1297
1298         return true;
1299 }
1300
1301 static bool get_mtex_slot_valid_texpaint(struct MTex *mtex)
1302 {
1303         return (mtex && (mtex->texco == TEXCO_UV) &&
1304                 mtex->tex && (mtex->tex->type == TEX_IMAGE) &&
1305                 mtex->tex->ima);
1306 }
1307
1308 static bNode *nodetree_uv_node_recursive(bNode *node)
1309 {
1310         bNode *inode;
1311         bNodeSocket *sock;
1312         
1313         for (sock = node->inputs.first; sock; sock = sock->next) {
1314                 if (sock->link) {
1315                         inode = sock->link->fromnode;
1316                         if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1317                                 return inode;
1318                         }
1319                         else {
1320                                 return nodetree_uv_node_recursive(inode);
1321                         }
1322                 }
1323         }
1324         
1325         return NULL;
1326 }
1327
1328 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1329 {
1330         MTex **mtex;
1331         short count = 0;
1332         short index = 0, i;
1333
1334         bool use_nodes = BKE_scene_use_new_shading_nodes(scene);
1335         bool is_bi = BKE_scene_uses_blender_internal(scene) || BKE_scene_uses_blender_game(scene);
1336
1337         /* XXX, for 2.8 testing & development its useful to have non Cycles/BI engines use material nodes
1338          * In the future we may have some way to check this which each engine can define.
1339          * For now use material slots for Clay/Eevee.
1340          * - Campbell */
1341         if (!(use_nodes || is_bi)) {
1342                 is_bi = true;
1343         }
1344         
1345         if (!ma)
1346                 return;
1347
1348         if (ma->texpaintslot) {
1349                 MEM_freeN(ma->texpaintslot);
1350                 ma->tot_slots = 0;
1351                 ma->texpaintslot = NULL;
1352         }
1353
1354         if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1355                 ma->paint_active_slot = 0;
1356                 ma->paint_clone_slot = 0;
1357                 return;
1358         }
1359         
1360         if (use_nodes || ma->use_nodes) {
1361                 bNode *node, *active_node;
1362
1363                 if (!(ma->nodetree)) {
1364                         ma->paint_active_slot = 0;
1365                         ma->paint_clone_slot = 0;
1366                         return;
1367                 }
1368
1369                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1370                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id)
1371                                 count++;
1372                 }
1373
1374                 if (count == 0) {
1375                         ma->paint_active_slot = 0;
1376                         ma->paint_clone_slot = 0;
1377                         return;
1378                 }
1379                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1380
1381                 active_node = nodeGetActiveTexture(ma->nodetree);
1382
1383                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1384                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1385                                 if (active_node == node)
1386                                         ma->paint_active_slot = index;
1387                                 ma->texpaintslot[index].ima = (Image *)node->id;
1388                                 
1389                                 /* for new renderer, we need to traverse the treeback in search of a UV node */
1390                                 if (use_nodes) {
1391                                         bNode *uvnode = nodetree_uv_node_recursive(node);
1392                                         
1393                                         if (uvnode) {
1394                                                 NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1395                                                 ma->texpaintslot[index].uvname = storage->uv_map;
1396                                                 /* set a value to index so UI knows that we have a valid pointer for the mesh */
1397                                                 ma->texpaintslot[index].index = 0;
1398                                         }
1399                                         else {
1400                                                 /* just invalidate the index here so UV map does not get displayed on the UI */
1401                                                 ma->texpaintslot[index].index = -1;
1402                                         }
1403                                 }
1404                                 else {
1405                                         ma->texpaintslot[index].index = -1;
1406                                 }
1407                                 index++;
1408                         }
1409                 }
1410         }
1411         else if (is_bi) {
1412                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1413                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1414                                 count++;
1415                         }
1416                 }
1417
1418                 if (count == 0) {
1419                         ma->paint_active_slot = 0;
1420                         ma->paint_clone_slot = 0;
1421                         return;
1422                 }
1423
1424                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1425
1426                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1427                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1428                                 ma->texpaintslot[index].ima = (*mtex)->tex->ima;
1429                                 ma->texpaintslot[index].uvname = (*mtex)->uvname;
1430                                 ma->texpaintslot[index].index = i;
1431                                 
1432                                 index++;
1433                         }
1434                 }
1435         }
1436         else {
1437                 ma->paint_active_slot = 0;
1438                 ma->paint_clone_slot = 0;
1439                 return;
1440         }       
1441
1442
1443         ma->tot_slots = count;
1444         
1445         
1446         if (ma->paint_active_slot >= count) {
1447                 ma->paint_active_slot = count - 1;
1448         }
1449
1450         if (ma->paint_clone_slot >= count) {
1451                 ma->paint_clone_slot = count - 1;
1452         }
1453
1454         return;
1455 }
1456
1457 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1458 {
1459         int i;
1460
1461         for (i = 1; i < ob->totcol + 1; i++) {
1462                 Material *ma = give_current_material(ob, i);
1463                 BKE_texpaint_slot_refresh_cache(scene, ma);
1464         }
1465 }
1466
1467
1468 /* r_col = current value, col = new value, (fac == 0) is no change */
1469 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1470 {
1471         float tmp, facm = 1.0f - fac;
1472         
1473         switch (type) {
1474                 case MA_RAMP_BLEND:
1475                         r_col[0] = facm * (r_col[0]) + fac * col[0];
1476                         r_col[1] = facm * (r_col[1]) + fac * col[1];
1477                         r_col[2] = facm * (r_col[2]) + fac * col[2];
1478                         break;
1479                 case MA_RAMP_ADD:
1480                         r_col[0] += fac * col[0];
1481                         r_col[1] += fac * col[1];
1482                         r_col[2] += fac * col[2];
1483                         break;
1484                 case MA_RAMP_MULT:
1485                         r_col[0] *= (facm + fac * col[0]);
1486                         r_col[1] *= (facm + fac * col[1]);
1487                         r_col[2] *= (facm + fac * col[2]);
1488                         break;
1489                 case MA_RAMP_SCREEN:
1490                         r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1491                         r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1492                         r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1493                         break;
1494                 case MA_RAMP_OVERLAY:
1495                         if (r_col[0] < 0.5f)
1496                                 r_col[0] *= (facm + 2.0f * fac * col[0]);
1497                         else
1498                                 r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1499                         if (r_col[1] < 0.5f)
1500                                 r_col[1] *= (facm + 2.0f * fac * col[1]);
1501                         else
1502                                 r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1503                         if (r_col[2] < 0.5f)
1504                                 r_col[2] *= (facm + 2.0f * fac * col[2]);
1505                         else
1506                                 r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1507                         break;
1508                 case MA_RAMP_SUB:
1509                         r_col[0] -= fac * col[0];
1510                         r_col[1] -= fac * col[1];
1511                         r_col[2] -= fac * col[2];
1512                         break;
1513                 case MA_RAMP_DIV:
1514                         if (col[0] != 0.0f)
1515                                 r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1516                         if (col[1] != 0.0f)
1517                                 r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1518                         if (col[2] != 0.0f)
1519                                 r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1520                         break;
1521                 case MA_RAMP_DIFF:
1522                         r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1523                         r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1524                         r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1525                         break;
1526                 case MA_RAMP_DARK:
1527                         r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1528                         r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1529                         r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1530                         break;
1531                 case MA_RAMP_LIGHT:
1532                         tmp = fac * col[0];
1533                         if (tmp > r_col[0]) r_col[0] = tmp;
1534                         tmp = fac * col[1];
1535                         if (tmp > r_col[1]) r_col[1] = tmp;
1536                         tmp = fac * col[2];
1537                         if (tmp > r_col[2]) r_col[2] = tmp;
1538                         break;
1539                 case MA_RAMP_DODGE:
1540                         if (r_col[0] != 0.0f) {
1541                                 tmp = 1.0f - fac * col[0];
1542                                 if (tmp <= 0.0f)
1543                                         r_col[0] = 1.0f;
1544                                 else if ((tmp = (r_col[0]) / tmp) > 1.0f)
1545                                         r_col[0] = 1.0f;
1546                                 else
1547                                         r_col[0] = tmp;
1548                         }
1549                         if (r_col[1] != 0.0f) {
1550                                 tmp = 1.0f - fac * col[1];
1551                                 if (tmp <= 0.0f)
1552                                         r_col[1] = 1.0f;
1553                                 else if ((tmp = (r_col[1]) / tmp) > 1.0f)
1554                                         r_col[1] = 1.0f;
1555                                 else
1556                                         r_col[1] = tmp;
1557                         }
1558                         if (r_col[2] != 0.0f) {
1559                                 tmp = 1.0f - fac * col[2];
1560                                 if (tmp <= 0.0f)
1561                                         r_col[2] = 1.0f;
1562                                 else if ((tmp = (r_col[2]) / tmp) > 1.0f)
1563                                         r_col[2] = 1.0f;
1564                                 else
1565                                         r_col[2] = tmp;
1566                         }
1567                         break;
1568                 case MA_RAMP_BURN:
1569                         tmp = facm + fac * col[0];
1570
1571                         if (tmp <= 0.0f)
1572                                 r_col[0] = 0.0f;
1573                         else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f)
1574                                 r_col[0] = 0.0f;
1575                         else if (tmp > 1.0f)
1576                                 r_col[0] = 1.0f;
1577                         else
1578                                 r_col[0] = tmp;
1579
1580                         tmp = facm + fac * col[1];
1581                         if (tmp <= 0.0f)
1582                                 r_col[1] = 0.0f;
1583                         else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f)
1584                                 r_col[1] = 0.0f;
1585                         else if (tmp > 1.0f)
1586                                 r_col[1] = 1.0f;
1587                         else
1588                                 r_col[1] = tmp;
1589
1590                         tmp = facm + fac * col[2];
1591                         if (tmp <= 0.0f)
1592                                 r_col[2] = 0.0f;
1593                         else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f)
1594                                 r_col[2] = 0.0f;
1595                         else if (tmp > 1.0f)
1596                                 r_col[2] = 1.0f;
1597                         else
1598                                 r_col[2] = tmp;
1599                         break;
1600                 case MA_RAMP_HUE:
1601                 {
1602                         float rH, rS, rV;
1603                         float colH, colS, colV;
1604                         float tmpr, tmpg, tmpb;
1605                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1606                         if (colS != 0) {
1607                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1608                                 hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1609                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1610                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1611                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1612                         }
1613                         break;
1614                 }
1615                 case MA_RAMP_SAT:
1616                 {
1617                         float rH, rS, rV;
1618                         float colH, colS, colV;
1619                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1620                         if (rS != 0) {
1621                                 rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1622                                 hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1623                         }
1624                         break;
1625                 }
1626                 case MA_RAMP_VAL:
1627                 {
1628                         float rH, rS, rV;
1629                         float colH, colS, colV;
1630                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1631                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1632                         hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1633                         break;
1634                 }
1635                 case MA_RAMP_COLOR:
1636                 {
1637                         float rH, rS, rV;
1638                         float colH, colS, colV;
1639                         float tmpr, tmpg, tmpb;
1640                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1641                         if (colS != 0) {
1642                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1643                                 hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1644                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1645                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1646                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1647                         }
1648                         break;
1649                 }
1650                 case MA_RAMP_SOFT:
1651                 {
1652                         float scr, scg, scb;
1653
1654                         /* first calculate non-fac based Screen mix */
1655                         scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1656                         scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1657                         scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1658
1659                         r_col[0] = facm * (r_col[0]) + fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1660                         r_col[1] = facm * (r_col[1]) + fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1661                         r_col[2] = facm * (r_col[2]) + fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1662                         break;
1663                 }
1664                 case MA_RAMP_LINEAR:
1665                         if (col[0] > 0.5f)
1666                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1667                         else
1668                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1669                         if (col[1] > 0.5f)
1670                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1671                         else
1672                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1673                         if (col[2] > 0.5f)
1674                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1675                         else
1676                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1677                         break;
1678         }
1679 }
1680
1681 /**
1682  * \brief copy/paste buffer, if we had a proper py api that would be better
1683  * \note matcopybuf.nodetree does _NOT_ use ID's
1684  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1685  */
1686 static Material matcopybuf;
1687 static short matcopied = 0;
1688
1689 void clear_matcopybuf(void)
1690 {
1691         memset(&matcopybuf, 0, sizeof(Material));
1692         matcopied = 0;
1693 }
1694
1695 void free_matcopybuf(void)
1696 {
1697         int a;
1698
1699         for (a = 0; a < MAX_MTEX; a++) {
1700                 if (matcopybuf.mtex[a]) {
1701                         MEM_freeN(matcopybuf.mtex[a]);
1702                         matcopybuf.mtex[a] = NULL;
1703                 }
1704         }
1705
1706         if (matcopybuf.ramp_col) MEM_freeN(matcopybuf.ramp_col);
1707         if (matcopybuf.ramp_spec) MEM_freeN(matcopybuf.ramp_spec);
1708
1709         matcopybuf.ramp_col = NULL;
1710         matcopybuf.ramp_spec = NULL;
1711
1712         if (matcopybuf.nodetree) {
1713                 ntreeFreeTree(matcopybuf.nodetree);
1714                 MEM_freeN(matcopybuf.nodetree);
1715                 matcopybuf.nodetree = NULL;
1716         }
1717
1718         matcopied = 0;
1719 }
1720
1721 void copy_matcopybuf(Material *ma)
1722 {
1723         int a;
1724         MTex *mtex;
1725
1726         if (matcopied)
1727                 free_matcopybuf();
1728
1729         memcpy(&matcopybuf, ma, sizeof(Material));
1730         if (matcopybuf.ramp_col) matcopybuf.ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1731         if (matcopybuf.ramp_spec) matcopybuf.ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1732
1733         for (a = 0; a < MAX_MTEX; a++) {
1734                 mtex = matcopybuf.mtex[a];
1735                 if (mtex) {
1736                         matcopybuf.mtex[a] = MEM_dupallocN(mtex);
1737                 }
1738         }
1739         matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, G.main, false);
1740         matcopybuf.preview = NULL;
1741         BLI_listbase_clear(&matcopybuf.gpumaterial);
1742         /* TODO Duplicate Engine Settings and set runtime to NULL */
1743         matcopied = 1;
1744 }
1745
1746 void paste_matcopybuf(Material *ma)
1747 {
1748         int a;
1749         MTex *mtex;
1750         ID id;
1751
1752         if (matcopied == 0)
1753                 return;
1754         /* free current mat */
1755         if (ma->ramp_col) MEM_freeN(ma->ramp_col);
1756         if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
1757         for (a = 0; a < MAX_MTEX; a++) {
1758                 mtex = ma->mtex[a];
1759                 if (mtex && mtex->tex)
1760                         id_us_min(&mtex->tex->id);
1761                 if (mtex)
1762                         MEM_freeN(mtex);
1763         }
1764
1765         if (ma->nodetree) {
1766                 ntreeFreeTree(ma->nodetree);
1767                 MEM_freeN(ma->nodetree);
1768         }
1769
1770         GPU_material_free(&ma->gpumaterial);
1771
1772         id = (ma->id);
1773         memcpy(ma, &matcopybuf, sizeof(Material));
1774         (ma->id) = id;
1775
1776         if (matcopybuf.ramp_col) ma->ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1777         if (matcopybuf.ramp_spec) ma->ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1778
1779         for (a = 0; a < MAX_MTEX; a++) {
1780                 mtex = ma->mtex[a];
1781                 if (mtex) {
1782                         ma->mtex[a] = MEM_dupallocN(mtex);
1783                         if (mtex->tex) {
1784                                 /* first check this is in main (we may have loaded another file) [#35500] */
1785                                 if (BLI_findindex(&G.main->tex, mtex->tex) != -1) {
1786                                         id_us_plus((ID *)mtex->tex);
1787                                 }
1788                                 else {
1789                                         ma->mtex[a]->tex = NULL;
1790                                 }
1791                         }
1792                 }
1793         }
1794
1795         ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, G.main, false);
1796 }
1797
1798 struct Image *BKE_object_material_edit_image_get(Object *ob, short mat_nr)
1799 {
1800         Material *ma = give_current_material(ob, mat_nr + 1);
1801         return ma ? ma->edit_image : NULL;
1802 }
1803
1804 struct Image **BKE_object_material_edit_image_get_array(Object *ob)
1805 {
1806         Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
1807         for (int i = 0; i < ob->totcol; i++) {
1808                 image_array[i] = BKE_object_material_edit_image_get(ob, i);
1809         }
1810         return image_array;
1811 }
1812
1813 bool BKE_object_material_edit_image_set(Object *ob, short mat_nr, Image *image)
1814 {
1815         Material *ma = give_current_material(ob, mat_nr + 1);
1816         if (ma) {
1817                 /* both may be NULL */
1818                 id_us_min((ID *)ma->edit_image);
1819                 ma->edit_image = image;
1820                 id_us_plus((ID *)ma->edit_image);
1821                 return true;
1822         }
1823         return false;
1824 }
1825
1826 void BKE_material_eval(const struct EvaluationContext *UNUSED(eval_ctx), Material *material)
1827 {
1828         if (G.debug & G_DEBUG_DEPSGRAPH) {
1829                 printf("%s on %s (%p)\n", __func__, material->id.name, material);
1830         }
1831         if ((BLI_listbase_is_empty(&material->gpumaterial) == false)) {
1832                 GPU_material_uniform_buffer_tag_dirty(&material->gpumaterial);
1833         }
1834 }