Depsgraph: Pass copy-on-write pointer to material update
[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         }
372         return NULL;
373 }
374
375 short *give_totcolp_id(ID *id)
376 {
377         /* ensure we don't try get materials from non-obdata */
378         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
379
380         switch (GS(id->name)) {
381                 case ID_ME:
382                         return &(((Mesh *)id)->totcol);
383                 case ID_CU:
384                         return &(((Curve *)id)->totcol);
385                 case ID_MB:
386                         return &(((MetaBall *)id)->totcol);
387         }
388         return NULL;
389 }
390
391 static void material_data_index_remove_id(ID *id, short index)
392 {
393         /* ensure we don't try get materials from non-obdata */
394         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
395
396         switch (GS(id->name)) {
397                 case ID_ME:
398                         BKE_mesh_material_index_remove((Mesh *)id, index);
399                         break;
400                 case ID_CU:
401                         BKE_curve_material_index_remove((Curve *)id, index);
402                         break;
403                 case ID_MB:
404                         /* meta-elems don't have materials atm */
405                         break;
406         }
407 }
408
409 static void material_data_index_clear_id(ID *id)
410 {
411         /* ensure we don't try get materials from non-obdata */
412         BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
413
414         switch (GS(id->name)) {
415                 case ID_ME:
416                         BKE_mesh_material_index_clear((Mesh *)id);
417                         break;
418                 case ID_CU:
419                         BKE_curve_material_index_clear((Curve *)id);
420                         break;
421                 case ID_MB:
422                         /* meta-elems don't have materials atm */
423                         break;
424         }
425 }
426
427 void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
428 {
429         Material ***matar = give_matarar_id(id);
430         short *totcolp = give_totcolp_id(id);
431
432         if (matar == NULL) {
433                 return;
434         }
435
436         if (do_id_user && totcol < (*totcolp)) {
437                 short i;
438                 for (i = totcol; i < (*totcolp); i++) {
439                         id_us_min((ID *)(*matar)[i]);
440                 }
441         }
442
443         if (totcol == 0) {
444                 if (*totcolp) {
445                         MEM_freeN(*matar);
446                         *matar = NULL;
447                 }
448         }
449         else {
450                 *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
451         }
452         *totcolp = totcol;
453
454         DEG_relations_tag_update(bmain);
455 }
456
457 void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
458 {
459         Material ***matar;
460         if ((matar = give_matarar_id(id))) {
461                 short *totcol = give_totcolp_id(id);
462                 Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
463                 if (*totcol) memcpy(mat, *matar, sizeof(void *) * (*totcol));
464                 if (*matar) MEM_freeN(*matar);
465
466                 *matar = mat;
467                 (*matar)[(*totcol)++] = ma;
468
469                 id_us_plus((ID *)ma);
470                 test_all_objects_materials(bmain, id);
471                 DEG_relations_tag_update(bmain);
472         }
473 }
474
475 Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i, bool update_data)
476 {
477         short index = (short)index_i;
478         Material *ret = NULL;
479         Material ***matar;
480         if ((matar = give_matarar_id(id))) {
481                 short *totcol = give_totcolp_id(id);
482                 if (index >= 0 && index < (*totcol)) {
483                         ret = (*matar)[index];
484                         id_us_min((ID *)ret);
485
486                         if (*totcol <= 1) {
487                                 *totcol = 0;
488                                 MEM_freeN(*matar);
489                                 *matar = NULL;
490                         }
491                         else {
492                                 if (index + 1 != (*totcol))
493                                         memmove((*matar) + index, (*matar) + (index + 1), sizeof(void *) * ((*totcol) - (index + 1)));
494
495                                 (*totcol)--;
496                                 *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
497                                 test_all_objects_materials(G.main, id);
498                         }
499
500                         if (update_data) {
501                                 /* decrease mat_nr index */
502                                 material_data_index_remove_id(id, index);
503                         }
504
505                         DEG_relations_tag_update(bmain);
506                 }
507         }
508         
509         return ret;
510 }
511
512 void BKE_material_clear_id(Main *bmain, ID *id, bool update_data)
513 {
514         Material ***matar;
515         if ((matar = give_matarar_id(id))) {
516                 short *totcol = give_totcolp_id(id);
517
518                 while ((*totcol)--) {
519                         id_us_min((ID *)((*matar)[*totcol]));
520                 }
521                 *totcol = 0;
522                 if (*matar) {
523                         MEM_freeN(*matar);
524                         *matar = NULL;
525                 }
526
527                 if (update_data) {
528                         /* decrease mat_nr index */
529                         material_data_index_clear_id(id);
530                 }
531
532                 DEG_relations_tag_update(bmain);
533         }
534 }
535
536 Material *give_current_material(Object *ob, short act)
537 {
538         Material ***matarar, *ma;
539         const short *totcolp;
540
541         if (ob == NULL) return NULL;
542         
543         /* if object cannot have material, (totcolp == NULL) */
544         totcolp = give_totcolp(ob);
545         if (totcolp == NULL || ob->totcol == 0) return NULL;
546
547         /* return NULL for invalid 'act', can happen for mesh face indices */
548         if (act > ob->totcol)
549                 return NULL;
550         else if (act <= 0) {
551                 if (act < 0) {
552                         printf("Negative material index!\n");
553                 }
554                 return NULL;
555         }
556
557         if (ob->matbits && ob->matbits[act - 1]) {    /* in object */
558                 ma = ob->mat[act - 1];
559         }
560         else {                              /* in data */
561
562                 /* check for inconsistency */
563                 if (*totcolp < ob->totcol)
564                         ob->totcol = *totcolp;
565                 if (act > ob->totcol) act = ob->totcol;
566
567                 matarar = give_matarar(ob);
568                 
569                 if (matarar && *matarar) ma = (*matarar)[act - 1];
570                 else ma = NULL;
571                 
572         }
573         
574         return ma;
575 }
576
577 Material *give_node_material(Material *ma)
578 {
579         if (ma && ma->use_nodes && ma->nodetree) {
580                 bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
581
582                 if (node)
583                         return (Material *)node->id;
584         }
585
586         return NULL;
587 }
588
589 void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
590 {
591         Material **newmatar;
592         char *newmatbits;
593
594         if (do_id_user && totcol < ob->totcol) {
595                 short i;
596                 for (i = totcol; i < ob->totcol; i++) {
597                         id_us_min((ID *)ob->mat[i]);
598                 }
599         }
600
601         if (totcol == 0) {
602                 if (ob->totcol) {
603                         MEM_freeN(ob->mat);
604                         MEM_freeN(ob->matbits);
605                         ob->mat = NULL;
606                         ob->matbits = NULL;
607                 }
608         }
609         else if (ob->totcol < totcol) {
610                 newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
611                 newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
612                 if (ob->totcol) {
613                         memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
614                         memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
615                         MEM_freeN(ob->mat);
616                         MEM_freeN(ob->matbits);
617                 }
618                 ob->mat = newmatar;
619                 ob->matbits = newmatbits;
620         }
621         /* XXX, why not realloc on shrink? - campbell */
622
623         ob->totcol = totcol;
624         if (ob->totcol && ob->actcol == 0) ob->actcol = 1;
625         if (ob->actcol > ob->totcol) ob->actcol = ob->totcol;
626
627         DEG_relations_tag_update(bmain);
628 }
629
630 void test_object_materials(Object *ob, ID *id)
631 {
632         /* make the ob mat-array same size as 'ob->data' mat-array */
633         const short *totcol;
634
635         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
636                 return;
637         }
638
639         BKE_material_resize_object(G.main, ob, *totcol, false);
640 }
641
642 void test_all_objects_materials(Main *bmain, ID *id)
643 {
644         /* make the ob mat-array same size as 'ob->data' mat-array */
645         Object *ob;
646         const short *totcol;
647
648         if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
649                 return;
650         }
651
652         BKE_main_lock(bmain);
653         for (ob = bmain->object.first; ob; ob = ob->id.next) {
654                 if (ob->data == id) {
655                         BKE_material_resize_object(bmain, ob, *totcol, false);
656                 }
657         }
658         BKE_main_unlock(bmain);
659 }
660
661 void assign_material_id(ID *id, Material *ma, short act)
662 {
663         Material *mao, **matar, ***matarar;
664         short *totcolp;
665
666         if (act > MAXMAT) return;
667         if (act < 1) act = 1;
668
669         /* this is needed for Python overrides,
670          * we just have to take care that the UI can't do this */
671 #if 0
672         /* prevent crashing when using accidentally */
673         BLI_assert(id->lib == NULL);
674         if (id->lib) return;
675 #endif
676
677         /* test arraylens */
678
679         totcolp = give_totcolp_id(id);
680         matarar = give_matarar_id(id);
681
682         if (totcolp == NULL || matarar == NULL) return;
683
684         if (act > *totcolp) {
685                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
686
687                 if (*totcolp) {
688                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
689                         MEM_freeN(*matarar);
690                 }
691
692                 *matarar = matar;
693                 *totcolp = act;
694         }
695
696         /* in data */
697         mao = (*matarar)[act - 1];
698         if (mao)
699                 id_us_min(&mao->id);
700         (*matarar)[act - 1] = ma;
701
702         if (ma)
703                 id_us_plus(&ma->id);
704
705         test_all_objects_materials(G.main, id);
706 }
707
708 void assign_material(Object *ob, Material *ma, short act, int assign_type)
709 {
710         Material *mao, **matar, ***matarar;
711         short *totcolp;
712         char bit = 0;
713
714         if (act > MAXMAT) return;
715         if (act < 1) act = 1;
716         
717         /* prevent crashing when using accidentally */
718         BLI_assert(!ID_IS_LINKED_DATABLOCK(ob));
719         if (ID_IS_LINKED_DATABLOCK(ob)) return;
720         
721         /* test arraylens */
722         
723         totcolp = give_totcolp(ob);
724         matarar = give_matarar(ob);
725         
726         if (totcolp == NULL || matarar == NULL) return;
727         
728         if (act > *totcolp) {
729                 matar = MEM_callocN(sizeof(void *) * act, "matarray1");
730
731                 if (*totcolp) {
732                         memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
733                         MEM_freeN(*matarar);
734                 }
735
736                 *matarar = matar;
737                 *totcolp = act;
738         }
739
740         if (act > ob->totcol) {
741                 /* Need more space in the material arrays */
742                 ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
743                 ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
744                 ob->totcol = act;
745         }
746
747         /* Determine the object/mesh linking */
748         if (assign_type == BKE_MAT_ASSIGN_EXISTING) {
749                 /* keep existing option (avoid confusion in scripts),
750                  * intentionally ignore userpref (default to obdata). */
751                 bit = ob->matbits[act - 1];
752         }
753         else if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
754                 /* copy from previous material */
755                 bit = ob->matbits[ob->actcol - 1];
756         }
757         else {
758                 switch (assign_type) {
759                         case BKE_MAT_ASSIGN_OBDATA:
760                                 bit = 0;
761                                 break;
762                         case BKE_MAT_ASSIGN_OBJECT:
763                                 bit = 1;
764                                 break;
765                         case BKE_MAT_ASSIGN_USERPREF:
766                         default:
767                                 bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
768                                 break;
769                 }
770         }
771         
772         /* do it */
773
774         ob->matbits[act - 1] = bit;
775         if (bit == 1) {   /* in object */
776                 mao = ob->mat[act - 1];
777                 if (mao)
778                         id_us_min(&mao->id);
779                 ob->mat[act - 1] = ma;
780                 test_object_materials(ob, ob->data);
781         }
782         else {  /* in data */
783                 mao = (*matarar)[act - 1];
784                 if (mao)
785                         id_us_min(&mao->id);
786                 (*matarar)[act - 1] = ma;
787                 test_all_objects_materials(G.main, ob->data);  /* Data may be used by several objects... */
788         }
789
790         if (ma)
791                 id_us_plus(&ma->id);
792 }
793
794
795 void BKE_material_remap_object(Object *ob, const unsigned int *remap)
796 {
797         Material ***matar = give_matarar(ob);
798         const short *totcol_p = give_totcolp(ob);
799
800         BLI_array_permute(ob->mat, ob->totcol, remap);
801
802         if (ob->matbits) {
803                 BLI_array_permute(ob->matbits, ob->totcol, remap);
804         }
805
806         if (matar) {
807                 BLI_array_permute(*matar, *totcol_p, remap);
808         }
809
810         if (ob->type == OB_MESH) {
811                 BKE_mesh_material_remap(ob->data, remap, ob->totcol);
812         }
813         else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
814                 BKE_curve_material_remap(ob->data, remap, ob->totcol);
815         }
816         else {
817                 /* add support for this object data! */
818                 BLI_assert(matar == NULL);
819         }
820 }
821
822 /**
823  * Calculate a material remapping from \a ob_src to \a ob_dst.
824  *
825  * \param remap_src_to_dst: An array the size of `ob_src->totcol`
826  * where index values are filled in which map to \a ob_dst materials.
827  */
828 void BKE_material_remap_object_calc(
829         Object *ob_dst, Object *ob_src,
830         short *remap_src_to_dst)
831 {
832         if (ob_src->totcol == 0) {
833                 return;
834         }
835
836         GHash *gh_mat_map = BLI_ghash_ptr_new_ex(__func__, ob_src->totcol);
837
838         for (int i = 0; i < ob_dst->totcol; i++) {
839                 Material *ma_src = give_current_material(ob_dst, i + 1);
840                 BLI_ghash_reinsert(gh_mat_map, ma_src, SET_INT_IN_POINTER(i), NULL, NULL);
841         }
842
843         /* setup default mapping (when materials don't match) */
844         {
845                 int i = 0;
846                 if (ob_dst->totcol >= ob_src->totcol) {
847                         for (; i < ob_src->totcol; i++) {
848                                 remap_src_to_dst[i] = i;
849                         }
850                 }
851                 else {
852                         for (; i < ob_dst->totcol; i++) {
853                                 remap_src_to_dst[i] = i;
854                         }
855                         for (; i < ob_src->totcol; i++) {
856                                 remap_src_to_dst[i] = 0;
857                         }
858                 }
859         }
860
861         for (int i = 0; i < ob_src->totcol; i++) {
862                 Material *ma_src = give_current_material(ob_src, i + 1);
863
864                 if ((i < ob_dst->totcol) && (ma_src == give_current_material(ob_dst, i + 1))) {
865                         /* when objects have exact matching materials - keep existing index */
866                 }
867                 else {
868                         void **index_src_p = BLI_ghash_lookup_p(gh_mat_map, ma_src);
869                         if (index_src_p) {
870                                 remap_src_to_dst[i] = GET_INT_FROM_POINTER(*index_src_p);
871                         }
872                 }
873         }
874
875         BLI_ghash_free(gh_mat_map, NULL, NULL);
876 }
877
878
879 /* XXX - this calls many more update calls per object then are needed, could be optimized */
880 void assign_matarar(struct Object *ob, struct Material ***matar, short totcol)
881 {
882         int actcol_orig = ob->actcol;
883         short i;
884
885         while ((ob->totcol > totcol) &&
886                BKE_object_material_slot_remove(ob))
887         {
888                 /* pass */
889         }
890
891         /* now we have the right number of slots */
892         for (i = 0; i < totcol; i++)
893                 assign_material(ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
894
895         if (actcol_orig > ob->totcol)
896                 actcol_orig = ob->totcol;
897
898         ob->actcol = actcol_orig;
899 }
900
901
902 short BKE_object_material_slot_find_index(Object *ob, Material *ma)
903 {
904         Material ***matarar;
905         short a, *totcolp;
906         
907         if (ma == NULL) return 0;
908         
909         totcolp = give_totcolp(ob);
910         matarar = give_matarar(ob);
911         
912         if (totcolp == NULL || matarar == NULL) return 0;
913         
914         for (a = 0; a < *totcolp; a++)
915                 if ((*matarar)[a] == ma)
916                         break;
917         if (a < *totcolp)
918                 return a + 1;
919         return 0;
920 }
921
922 bool BKE_object_material_slot_add(Object *ob)
923 {
924         if (ob == NULL) return false;
925         if (ob->totcol >= MAXMAT) return false;
926         
927         assign_material(ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
928         ob->actcol = ob->totcol;
929         return true;
930 }
931
932 static void do_init_render_material(Material *ma, int r_mode, float *amb)
933 {
934         MTex *mtex;
935         int a, needuv = 0, needtang = 0;
936         
937         if (ma->flarec == 0) ma->flarec = 1;
938
939         /* add all texcoflags from mtex, texco and mapto were cleared in advance */
940         for (a = 0; a < MAX_MTEX; a++) {
941                 
942                 /* separate tex switching */
943                 if (ma->septex & (1 << a)) continue;
944
945                 mtex = ma->mtex[a];
946                 if (mtex && mtex->tex && (mtex->tex->type | (mtex->tex->use_nodes && mtex->tex->nodetree) )) {
947                         
948                         ma->texco |= mtex->texco;
949                         ma->mapto |= mtex->mapto;
950
951                         /* always get derivatives for these textures */
952                         if (ELEM(mtex->tex->type, TEX_IMAGE, TEX_ENVMAP)) ma->texco |= TEXCO_OSA;
953                         else if (mtex->texflag & (MTEX_COMPAT_BUMP | MTEX_3TAP_BUMP | MTEX_5TAP_BUMP | MTEX_BICUBIC_BUMP)) ma->texco |= TEXCO_OSA;
954                         
955                         if (ma->texco & (TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM | TEXCO_STRAND | TEXCO_STRESS)) needuv = 1;
956                         else if (ma->texco & (TEXCO_GLOB | TEXCO_UV | TEXCO_OBJECT | TEXCO_SPEED)) needuv = 1;
957                         else if (ma->texco & (TEXCO_LAVECTOR | TEXCO_VIEW)) needuv = 1;
958
959                         if ((ma->mapto & MAP_NORM) && (mtex->normapspace == MTEX_NSPACE_TANGENT))
960                                 needtang = 1;
961                 }
962         }
963
964         if (needtang) ma->mode |= MA_NORMAP_TANG;
965         else ma->mode &= ~MA_NORMAP_TANG;
966         
967         if (ma->mode & (MA_VERTEXCOL | MA_VERTEXCOLP)) {
968                 needuv = 1;
969                 if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;     /* for texfaces */
970         }
971         if (needuv) ma->texco |= NEED_UV;
972         
973         /* since the raytracer doesnt recalc O structs for each ray, we have to preset them all */
974         if (r_mode & R_RAYTRACE) {
975                 if ((ma->mode & (MA_RAYMIRROR | MA_SHADOW_TRA)) || ((ma->mode & MA_TRANSP) && (ma->mode & MA_RAYTRANSP))) {
976                         ma->texco |= NEED_UV | TEXCO_ORCO | TEXCO_REFL | TEXCO_NORM;
977                         if (r_mode & R_OSA) ma->texco |= TEXCO_OSA;
978                 }
979         }
980         
981         if (amb) {
982                 ma->ambr = ma->amb * amb[0];
983                 ma->ambg = ma->amb * amb[1];
984                 ma->ambb = ma->amb * amb[2];
985         }
986
987         /* local group override */
988         if ((ma->shade_flag & MA_GROUP_LOCAL) && ma->id.lib && ma->group && ma->group->id.lib) {
989                 Group *group;
990
991                 for (group = G.main->group.first; group; group = group->id.next) {
992                         if (!ID_IS_LINKED_DATABLOCK(group) && STREQ(group->id.name, ma->group->id.name)) {
993                                 ma->group = group;
994                         }
995                 }
996         }
997 }
998
999 static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode, float *amb)
1000 {
1001         bNode *node;
1002
1003         /* parses the geom+tex nodes */
1004         ntreeShaderGetTexcoMode(ntree, r_mode, &basemat->texco, &basemat->mode_l);
1005         for (node = ntree->nodes.first; node; node = node->next) {
1006                 if (node->id) {
1007                         if (GS(node->id->name) == ID_MA) {
1008                                 Material *ma = (Material *)node->id;
1009                                 if (ma != basemat) {
1010                                         do_init_render_material(ma, r_mode, amb);
1011                                         basemat->texco |= ma->texco;
1012                                 }
1013
1014                                 basemat->mode_l |= ma->mode & ~(MA_MODE_PIPELINE | MA_SHLESS);
1015                                 basemat->mode2_l |= ma->mode2 & ~MA_MODE2_PIPELINE;
1016                                 /* basemat only considered shadeless if all node materials are too */
1017                                 if (!(ma->mode & MA_SHLESS))
1018                                         basemat->mode_l &= ~MA_SHLESS;
1019
1020                                 if (ma->strand_surfnor > 0.0f)
1021                                         basemat->mode_l |= MA_STR_SURFDIFF;
1022                         }
1023                         else if (node->type == NODE_GROUP)
1024                                 init_render_nodetree((bNodeTree *)node->id, basemat, r_mode, amb);
1025                 }
1026                 else if (node->typeinfo->type == SH_NODE_NORMAL_MAP) {
1027                         basemat->mode2_l |= MA_TANGENT_CONCRETE;
1028                         NodeShaderNormalMap *nm = node->storage;
1029                         bool taken_into_account = false;
1030                         for (int i = 0; i < basemat->nmap_tangent_names_count; i++) {
1031                                 if (STREQ(basemat->nmap_tangent_names[i], nm->uv_map)) {
1032                                         taken_into_account = true;
1033                                         break;
1034                                 }
1035                         }
1036                         if (!taken_into_account) {
1037                                 BLI_assert(basemat->nmap_tangent_names_count < MAX_MTFACE + 1);
1038                                 strcpy(basemat->nmap_tangent_names[basemat->nmap_tangent_names_count++], nm->uv_map);
1039                         }
1040                 }
1041         }
1042 }
1043
1044 void init_render_material(Material *mat, int r_mode, float *amb)
1045 {
1046         
1047         do_init_render_material(mat, r_mode, amb);
1048         
1049         if (mat->nodetree && mat->use_nodes) {
1050                 /* mode_l will take the pipeline options from the main material, and the or-ed
1051                  * result of non-pipeline options from the nodes. shadeless is an exception,
1052                  * mode_l will have it set when all node materials are shadeless. */
1053                 mat->mode_l = (mat->mode & MA_MODE_PIPELINE) | MA_SHLESS;
1054                 mat->mode2_l = mat->mode2 & MA_MODE2_PIPELINE;
1055                 mat->nmap_tangent_names_count = 0;
1056                 init_render_nodetree(mat->nodetree, mat, r_mode, amb);
1057                 
1058                 if (!mat->nodetree->execdata)
1059                         mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree);
1060         }
1061         else {
1062                 mat->mode_l = mat->mode;
1063                 mat->mode2_l = mat->mode2;
1064
1065                 if (mat->strand_surfnor > 0.0f)
1066                         mat->mode_l |= MA_STR_SURFDIFF;
1067         }
1068 }
1069
1070 void init_render_materials(Main *bmain, int r_mode, float *amb, bool do_default_material)
1071 {
1072         Material *ma;
1073         
1074         /* clear these flags before going over materials, to make sure they
1075          * are cleared only once, otherwise node materials contained in other
1076          * node materials can go wrong */
1077         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1078                 if (ma->id.us) {
1079                         ma->texco = 0;
1080                         ma->mapto = 0;
1081                 }
1082         }
1083
1084         /* two steps, first initialize, then or the flags for layers */
1085         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
1086                 /* is_used flag comes back in convertblender.c */
1087                 ma->flag &= ~MA_IS_USED;
1088                 if (ma->id.us) 
1089                         init_render_material(ma, r_mode, amb);
1090         }
1091
1092         if (do_default_material) {
1093                 init_render_material(&defmaterial, r_mode, amb);
1094         }
1095 }
1096
1097 /* only needed for nodes now */
1098 void end_render_material(Material *mat)
1099 {
1100         if (mat && mat->nodetree && mat->use_nodes) {
1101                 if (mat->nodetree->execdata)
1102                         ntreeShaderEndExecTree(mat->nodetree->execdata);
1103         }
1104 }
1105
1106 void end_render_materials(Main *bmain)
1107 {
1108         Material *ma;
1109         for (ma = bmain->mat.first; ma; ma = ma->id.next)
1110                 if (ma->id.us) 
1111                         end_render_material(ma);
1112 }
1113
1114 static bool material_in_nodetree(bNodeTree *ntree, Material *mat)
1115 {
1116         bNode *node;
1117
1118         for (node = ntree->nodes.first; node; node = node->next) {
1119                 if (node->id) {
1120                         if (GS(node->id->name) == ID_MA) {
1121                                 if (node->id == (ID *)mat) {
1122                                         return true;
1123                                 }
1124                         }
1125                         else if (node->type == NODE_GROUP) {
1126                                 if (material_in_nodetree((bNodeTree *)node->id, mat)) {
1127                                         return true;
1128                                 }
1129                         }
1130                 }
1131         }
1132
1133         return false;
1134 }
1135
1136 bool material_in_material(Material *parmat, Material *mat)
1137 {
1138         if (parmat == mat)
1139                 return true;
1140         else if (parmat->nodetree && parmat->use_nodes)
1141                 return material_in_nodetree(parmat->nodetree, mat);
1142         else
1143                 return false;
1144 }
1145
1146
1147 /* ****************** */
1148
1149 /* Update drivers for materials in a nodetree */
1150 static void material_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
1151 {
1152         bNode *node;
1153
1154         /* nodetree itself */
1155         if (ntree->adt && ntree->adt->drivers.first) {
1156                 BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
1157         }
1158         
1159         /* nodes */
1160         for (node = ntree->nodes.first; node; node = node->next) {
1161                 if (node->id) {
1162                         if (GS(node->id->name) == ID_MA) {
1163                                 material_drivers_update(scene, (Material *)node->id, ctime);
1164                         }
1165                         else if (node->type == NODE_GROUP) {
1166                                 material_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
1167                         }
1168                 }
1169         }
1170 }
1171
1172 /* Calculate all drivers for materials 
1173  * FIXME: this is really a terrible method which may result in some things being calculated
1174  * multiple times. However, without proper despgraph support for these things, we are forced
1175  * into this sort of thing...
1176  */
1177 void material_drivers_update(Scene *scene, Material *ma, float ctime)
1178 {
1179         //if (G.f & G_DEBUG)
1180         //      printf("material_drivers_update(%s, %s)\n", scene->id.name, ma->id.name);
1181         
1182         /* Prevent infinite recursion by checking (and tagging the material) as having been visited already
1183          * (see BKE_scene_update_tagged()). This assumes ma->id.tag & LIB_TAG_DOIT isn't set by anything else
1184          * in the meantime... [#32017]
1185          */
1186         if (ma->id.tag & LIB_TAG_DOIT)
1187                 return;
1188
1189         ma->id.tag |= LIB_TAG_DOIT;
1190         
1191         /* material itself */
1192         if (ma->adt && ma->adt->drivers.first) {
1193                 BKE_animsys_evaluate_animdata(scene, &ma->id, ma->adt, ctime, ADT_RECALC_DRIVERS);
1194         }
1195         
1196         /* nodes */
1197         if (ma->nodetree) {
1198                 material_node_drivers_update(scene, ma->nodetree, ctime);
1199         }
1200
1201         ma->id.tag &= ~LIB_TAG_DOIT;
1202 }
1203
1204 bool BKE_object_material_slot_remove(Object *ob)
1205 {
1206         Material *mao, ***matarar;
1207         Object *obt;
1208         short *totcolp;
1209         short a, actcol;
1210         
1211         if (ob == NULL || ob->totcol == 0) {
1212                 return false;
1213         }
1214
1215         /* this should never happen and used to crash */
1216         if (ob->actcol <= 0) {
1217                 printf("%s: invalid material index %d, report a bug!\n", __func__, ob->actcol);
1218                 BLI_assert(0);
1219                 return false;
1220         }
1221
1222         /* take a mesh/curve/mball as starting point, remove 1 index,
1223          * AND with all objects that share the ob->data
1224          * 
1225          * after that check indices in mesh/curve/mball!!!
1226          */
1227         
1228         totcolp = give_totcolp(ob);
1229         matarar = give_matarar(ob);
1230
1231         if (ELEM(NULL, matarar, *matarar)) {
1232                 return false;
1233         }
1234
1235         /* can happen on face selection in editmode */
1236         if (ob->actcol > ob->totcol) {
1237                 ob->actcol = ob->totcol;
1238         }
1239         
1240         /* we delete the actcol */
1241         mao = (*matarar)[ob->actcol - 1];
1242         if (mao)
1243                 id_us_min(&mao->id);
1244         
1245         for (a = ob->actcol; a < ob->totcol; a++)
1246                 (*matarar)[a - 1] = (*matarar)[a];
1247         (*totcolp)--;
1248         
1249         if (*totcolp == 0) {
1250                 MEM_freeN(*matarar);
1251                 *matarar = NULL;
1252         }
1253         
1254         actcol = ob->actcol;
1255         obt = G.main->object.first;
1256         while (obt) {
1257         
1258                 if (obt->data == ob->data) {
1259                         
1260                         /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
1261                         mao = obt->mat[actcol - 1];
1262                         if (mao)
1263                                 id_us_min(&mao->id);
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 (ELEM(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 static bool get_mtex_slot_valid_texpaint(struct MTex *mtex)
1294 {
1295         return (mtex && (mtex->texco == TEXCO_UV) &&
1296                 mtex->tex && (mtex->tex->type == TEX_IMAGE) &&
1297                 mtex->tex->ima);
1298 }
1299
1300 static bNode *nodetree_uv_node_recursive(bNode *node)
1301 {
1302         bNode *inode;
1303         bNodeSocket *sock;
1304         
1305         for (sock = node->inputs.first; sock; sock = sock->next) {
1306                 if (sock->link) {
1307                         inode = sock->link->fromnode;
1308                         if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1309                                 return inode;
1310                         }
1311                         else {
1312                                 return nodetree_uv_node_recursive(inode);
1313                         }
1314                 }
1315         }
1316         
1317         return NULL;
1318 }
1319
1320 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1321 {
1322         MTex **mtex;
1323         short count = 0;
1324         short index = 0, i;
1325
1326         bool use_nodes = BKE_scene_use_new_shading_nodes(scene);
1327         bool is_bi = BKE_scene_uses_blender_internal(scene) || BKE_scene_uses_blender_game(scene);
1328
1329         /* XXX, for 2.8 testing & development its useful to have non Cycles/BI engines use material nodes
1330          * In the future we may have some way to check this which each engine can define.
1331          * For now use material slots for Clay/Eevee.
1332          * - Campbell */
1333         if (!(use_nodes || is_bi)) {
1334                 is_bi = true;
1335         }
1336         
1337         if (!ma)
1338                 return;
1339
1340         if (ma->texpaintslot) {
1341                 MEM_freeN(ma->texpaintslot);
1342                 ma->tot_slots = 0;
1343                 ma->texpaintslot = NULL;
1344         }
1345
1346         if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1347                 ma->paint_active_slot = 0;
1348                 ma->paint_clone_slot = 0;
1349                 return;
1350         }
1351         
1352         if (use_nodes || ma->use_nodes) {
1353                 bNode *node, *active_node;
1354
1355                 if (!(ma->nodetree)) {
1356                         ma->paint_active_slot = 0;
1357                         ma->paint_clone_slot = 0;
1358                         return;
1359                 }
1360
1361                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1362                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id)
1363                                 count++;
1364                 }
1365
1366                 if (count == 0) {
1367                         ma->paint_active_slot = 0;
1368                         ma->paint_clone_slot = 0;
1369                         return;
1370                 }
1371                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1372
1373                 active_node = nodeGetActiveTexture(ma->nodetree);
1374
1375                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
1376                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1377                                 if (active_node == node)
1378                                         ma->paint_active_slot = index;
1379                                 ma->texpaintslot[index].ima = (Image *)node->id;
1380                                 
1381                                 /* for new renderer, we need to traverse the treeback in search of a UV node */
1382                                 if (use_nodes) {
1383                                         bNode *uvnode = nodetree_uv_node_recursive(node);
1384                                         
1385                                         if (uvnode) {
1386                                                 NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1387                                                 ma->texpaintslot[index].uvname = storage->uv_map;
1388                                                 /* set a value to index so UI knows that we have a valid pointer for the mesh */
1389                                                 ma->texpaintslot[index].index = 0;
1390                                         }
1391                                         else {
1392                                                 /* just invalidate the index here so UV map does not get displayed on the UI */
1393                                                 ma->texpaintslot[index].index = -1;
1394                                         }
1395                                 }
1396                                 else {
1397                                         ma->texpaintslot[index].index = -1;
1398                                 }
1399                                 index++;
1400                         }
1401                 }
1402         }
1403         else if (is_bi) {
1404                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1405                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1406                                 count++;
1407                         }
1408                 }
1409
1410                 if (count == 0) {
1411                         ma->paint_active_slot = 0;
1412                         ma->paint_clone_slot = 0;
1413                         return;
1414                 }
1415
1416                 ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1417
1418                 for (mtex = ma->mtex, i = 0; i < MAX_MTEX; i++, mtex++) {
1419                         if (get_mtex_slot_valid_texpaint(*mtex)) {
1420                                 ma->texpaintslot[index].ima = (*mtex)->tex->ima;
1421                                 ma->texpaintslot[index].uvname = (*mtex)->uvname;
1422                                 ma->texpaintslot[index].index = i;
1423                                 
1424                                 index++;
1425                         }
1426                 }
1427         }
1428         else {
1429                 ma->paint_active_slot = 0;
1430                 ma->paint_clone_slot = 0;
1431                 return;
1432         }       
1433
1434
1435         ma->tot_slots = count;
1436         
1437         
1438         if (ma->paint_active_slot >= count) {
1439                 ma->paint_active_slot = count - 1;
1440         }
1441
1442         if (ma->paint_clone_slot >= count) {
1443                 ma->paint_clone_slot = count - 1;
1444         }
1445
1446         return;
1447 }
1448
1449 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1450 {
1451         int i;
1452
1453         for (i = 1; i < ob->totcol + 1; i++) {
1454                 Material *ma = give_current_material(ob, i);
1455                 BKE_texpaint_slot_refresh_cache(scene, ma);
1456         }
1457 }
1458
1459
1460 /* r_col = current value, col = new value, (fac == 0) is no change */
1461 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1462 {
1463         float tmp, facm = 1.0f - fac;
1464         
1465         switch (type) {
1466                 case MA_RAMP_BLEND:
1467                         r_col[0] = facm * (r_col[0]) + fac * col[0];
1468                         r_col[1] = facm * (r_col[1]) + fac * col[1];
1469                         r_col[2] = facm * (r_col[2]) + fac * col[2];
1470                         break;
1471                 case MA_RAMP_ADD:
1472                         r_col[0] += fac * col[0];
1473                         r_col[1] += fac * col[1];
1474                         r_col[2] += fac * col[2];
1475                         break;
1476                 case MA_RAMP_MULT:
1477                         r_col[0] *= (facm + fac * col[0]);
1478                         r_col[1] *= (facm + fac * col[1]);
1479                         r_col[2] *= (facm + fac * col[2]);
1480                         break;
1481                 case MA_RAMP_SCREEN:
1482                         r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1483                         r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1484                         r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1485                         break;
1486                 case MA_RAMP_OVERLAY:
1487                         if (r_col[0] < 0.5f)
1488                                 r_col[0] *= (facm + 2.0f * fac * col[0]);
1489                         else
1490                                 r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1491                         if (r_col[1] < 0.5f)
1492                                 r_col[1] *= (facm + 2.0f * fac * col[1]);
1493                         else
1494                                 r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1495                         if (r_col[2] < 0.5f)
1496                                 r_col[2] *= (facm + 2.0f * fac * col[2]);
1497                         else
1498                                 r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1499                         break;
1500                 case MA_RAMP_SUB:
1501                         r_col[0] -= fac * col[0];
1502                         r_col[1] -= fac * col[1];
1503                         r_col[2] -= fac * col[2];
1504                         break;
1505                 case MA_RAMP_DIV:
1506                         if (col[0] != 0.0f)
1507                                 r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1508                         if (col[1] != 0.0f)
1509                                 r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1510                         if (col[2] != 0.0f)
1511                                 r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1512                         break;
1513                 case MA_RAMP_DIFF:
1514                         r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1515                         r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1516                         r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1517                         break;
1518                 case MA_RAMP_DARK:
1519                         r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1520                         r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1521                         r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1522                         break;
1523                 case MA_RAMP_LIGHT:
1524                         tmp = fac * col[0];
1525                         if (tmp > r_col[0]) r_col[0] = tmp;
1526                         tmp = fac * col[1];
1527                         if (tmp > r_col[1]) r_col[1] = tmp;
1528                         tmp = fac * col[2];
1529                         if (tmp > r_col[2]) r_col[2] = tmp;
1530                         break;
1531                 case MA_RAMP_DODGE:
1532                         if (r_col[0] != 0.0f) {
1533                                 tmp = 1.0f - fac * col[0];
1534                                 if (tmp <= 0.0f)
1535                                         r_col[0] = 1.0f;
1536                                 else if ((tmp = (r_col[0]) / tmp) > 1.0f)
1537                                         r_col[0] = 1.0f;
1538                                 else
1539                                         r_col[0] = tmp;
1540                         }
1541                         if (r_col[1] != 0.0f) {
1542                                 tmp = 1.0f - fac * col[1];
1543                                 if (tmp <= 0.0f)
1544                                         r_col[1] = 1.0f;
1545                                 else if ((tmp = (r_col[1]) / tmp) > 1.0f)
1546                                         r_col[1] = 1.0f;
1547                                 else
1548                                         r_col[1] = tmp;
1549                         }
1550                         if (r_col[2] != 0.0f) {
1551                                 tmp = 1.0f - fac * col[2];
1552                                 if (tmp <= 0.0f)
1553                                         r_col[2] = 1.0f;
1554                                 else if ((tmp = (r_col[2]) / tmp) > 1.0f)
1555                                         r_col[2] = 1.0f;
1556                                 else
1557                                         r_col[2] = tmp;
1558                         }
1559                         break;
1560                 case MA_RAMP_BURN:
1561                         tmp = facm + fac * col[0];
1562
1563                         if (tmp <= 0.0f)
1564                                 r_col[0] = 0.0f;
1565                         else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f)
1566                                 r_col[0] = 0.0f;
1567                         else if (tmp > 1.0f)
1568                                 r_col[0] = 1.0f;
1569                         else
1570                                 r_col[0] = tmp;
1571
1572                         tmp = facm + fac * col[1];
1573                         if (tmp <= 0.0f)
1574                                 r_col[1] = 0.0f;
1575                         else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f)
1576                                 r_col[1] = 0.0f;
1577                         else if (tmp > 1.0f)
1578                                 r_col[1] = 1.0f;
1579                         else
1580                                 r_col[1] = tmp;
1581
1582                         tmp = facm + fac * col[2];
1583                         if (tmp <= 0.0f)
1584                                 r_col[2] = 0.0f;
1585                         else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f)
1586                                 r_col[2] = 0.0f;
1587                         else if (tmp > 1.0f)
1588                                 r_col[2] = 1.0f;
1589                         else
1590                                 r_col[2] = tmp;
1591                         break;
1592                 case MA_RAMP_HUE:
1593                 {
1594                         float rH, rS, rV;
1595                         float colH, colS, colV;
1596                         float tmpr, tmpg, tmpb;
1597                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1598                         if (colS != 0) {
1599                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1600                                 hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1601                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1602                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1603                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1604                         }
1605                         break;
1606                 }
1607                 case MA_RAMP_SAT:
1608                 {
1609                         float rH, rS, rV;
1610                         float colH, colS, colV;
1611                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1612                         if (rS != 0) {
1613                                 rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1614                                 hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1615                         }
1616                         break;
1617                 }
1618                 case MA_RAMP_VAL:
1619                 {
1620                         float rH, rS, rV;
1621                         float colH, colS, colV;
1622                         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1623                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1624                         hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1625                         break;
1626                 }
1627                 case MA_RAMP_COLOR:
1628                 {
1629                         float rH, rS, rV;
1630                         float colH, colS, colV;
1631                         float tmpr, tmpg, tmpb;
1632                         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1633                         if (colS != 0) {
1634                                 rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1635                                 hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1636                                 r_col[0] = facm * (r_col[0]) + fac * tmpr;
1637                                 r_col[1] = facm * (r_col[1]) + fac * tmpg;
1638                                 r_col[2] = facm * (r_col[2]) + fac * tmpb;
1639                         }
1640                         break;
1641                 }
1642                 case MA_RAMP_SOFT:
1643                 {
1644                         float scr, scg, scb;
1645
1646                         /* first calculate non-fac based Screen mix */
1647                         scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1648                         scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1649                         scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1650
1651                         r_col[0] = facm * (r_col[0]) + fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1652                         r_col[1] = facm * (r_col[1]) + fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1653                         r_col[2] = facm * (r_col[2]) + fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1654                         break;
1655                 }
1656                 case MA_RAMP_LINEAR:
1657                         if (col[0] > 0.5f)
1658                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1659                         else
1660                                 r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1661                         if (col[1] > 0.5f)
1662                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1663                         else
1664                                 r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1665                         if (col[2] > 0.5f)
1666                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1667                         else
1668                                 r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1669                         break;
1670         }
1671 }
1672
1673 /**
1674  * \brief copy/paste buffer, if we had a proper py api that would be better
1675  * \note matcopybuf.nodetree does _NOT_ use ID's
1676  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1677  */
1678 static Material matcopybuf;
1679 static short matcopied = 0;
1680
1681 void clear_matcopybuf(void)
1682 {
1683         memset(&matcopybuf, 0, sizeof(Material));
1684         matcopied = 0;
1685 }
1686
1687 void free_matcopybuf(void)
1688 {
1689         int a;
1690
1691         for (a = 0; a < MAX_MTEX; a++) {
1692                 if (matcopybuf.mtex[a]) {
1693                         MEM_freeN(matcopybuf.mtex[a]);
1694                         matcopybuf.mtex[a] = NULL;
1695                 }
1696         }
1697
1698         if (matcopybuf.ramp_col) MEM_freeN(matcopybuf.ramp_col);
1699         if (matcopybuf.ramp_spec) MEM_freeN(matcopybuf.ramp_spec);
1700
1701         matcopybuf.ramp_col = NULL;
1702         matcopybuf.ramp_spec = NULL;
1703
1704         if (matcopybuf.nodetree) {
1705                 ntreeFreeTree(matcopybuf.nodetree);
1706                 MEM_freeN(matcopybuf.nodetree);
1707                 matcopybuf.nodetree = NULL;
1708         }
1709
1710         matcopied = 0;
1711 }
1712
1713 void copy_matcopybuf(Material *ma)
1714 {
1715         int a;
1716         MTex *mtex;
1717
1718         if (matcopied)
1719                 free_matcopybuf();
1720
1721         memcpy(&matcopybuf, ma, sizeof(Material));
1722         if (matcopybuf.ramp_col) matcopybuf.ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1723         if (matcopybuf.ramp_spec) matcopybuf.ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1724
1725         for (a = 0; a < MAX_MTEX; a++) {
1726                 mtex = matcopybuf.mtex[a];
1727                 if (mtex) {
1728                         matcopybuf.mtex[a] = MEM_dupallocN(mtex);
1729                 }
1730         }
1731         matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, G.main, false);
1732         matcopybuf.preview = NULL;
1733         BLI_listbase_clear(&matcopybuf.gpumaterial);
1734         /* TODO Duplicate Engine Settings and set runtime to NULL */
1735         matcopied = 1;
1736 }
1737
1738 void paste_matcopybuf(Material *ma)
1739 {
1740         int a;
1741         MTex *mtex;
1742         ID id;
1743
1744         if (matcopied == 0)
1745                 return;
1746         /* free current mat */
1747         if (ma->ramp_col) MEM_freeN(ma->ramp_col);
1748         if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
1749         for (a = 0; a < MAX_MTEX; a++) {
1750                 mtex = ma->mtex[a];
1751                 if (mtex && mtex->tex)
1752                         id_us_min(&mtex->tex->id);
1753                 if (mtex)
1754                         MEM_freeN(mtex);
1755         }
1756
1757         if (ma->nodetree) {
1758                 ntreeFreeTree(ma->nodetree);
1759                 MEM_freeN(ma->nodetree);
1760         }
1761
1762         GPU_material_free(&ma->gpumaterial);
1763
1764         id = (ma->id);
1765         memcpy(ma, &matcopybuf, sizeof(Material));
1766         (ma->id) = id;
1767
1768         if (matcopybuf.ramp_col) ma->ramp_col = MEM_dupallocN(matcopybuf.ramp_col);
1769         if (matcopybuf.ramp_spec) ma->ramp_spec = MEM_dupallocN(matcopybuf.ramp_spec);
1770
1771         for (a = 0; a < MAX_MTEX; a++) {
1772                 mtex = ma->mtex[a];
1773                 if (mtex) {
1774                         ma->mtex[a] = MEM_dupallocN(mtex);
1775                         if (mtex->tex) {
1776                                 /* first check this is in main (we may have loaded another file) [#35500] */
1777                                 if (BLI_findindex(&G.main->tex, mtex->tex) != -1) {
1778                                         id_us_plus((ID *)mtex->tex);
1779                                 }
1780                                 else {
1781                                         ma->mtex[a]->tex = NULL;
1782                                 }
1783                         }
1784                 }
1785         }
1786
1787         ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, G.main, false);
1788 }
1789
1790 struct Image *BKE_object_material_edit_image_get(Object *ob, short mat_nr)
1791 {
1792         Material *ma = give_current_material(ob, mat_nr + 1);
1793         return ma ? ma->edit_image : NULL;
1794 }
1795
1796 struct Image **BKE_object_material_edit_image_get_array(Object *ob)
1797 {
1798         Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
1799         for (int i = 0; i < ob->totcol; i++) {
1800                 image_array[i] = BKE_object_material_edit_image_get(ob, i);
1801         }
1802         return image_array;
1803 }
1804
1805 bool BKE_object_material_edit_image_set(Object *ob, short mat_nr, Image *image)
1806 {
1807         Material *ma = give_current_material(ob, mat_nr + 1);
1808         if (ma) {
1809                 /* both may be NULL */
1810                 id_us_min((ID *)ma->edit_image);
1811                 ma->edit_image = image;
1812                 id_us_plus((ID *)ma->edit_image);
1813                 return true;
1814         }
1815         return false;
1816 }
1817
1818 void BKE_material_eval(const struct EvaluationContext *UNUSED(eval_ctx), Material *material)
1819 {
1820         if (G.debug & G_DEBUG_DEPSGRAPH) {
1821                 printf("%s on %s (%p)\n", __func__, material->id.name, material);
1822         }
1823         if ((BLI_listbase_is_empty(&material->gpumaterial) == false)) {
1824                 GPU_material_uniform_buffer_tag_dirty(&material->gpumaterial);
1825         }
1826 }