ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / material.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25 #include <math.h>
26 #include <stddef.h>
27
28 #include "CLG_log.h"
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_anim_types.h"
33 #include "DNA_collection_types.h"
34 #include "DNA_curve_types.h"
35 #include "DNA_material_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_customdata_types.h"
39 #include "DNA_gpencil_types.h"
40 #include "DNA_ID.h"
41 #include "DNA_meta_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45
46 #include "BLI_math.h"
47 #include "BLI_listbase.h"
48 #include "BLI_utildefines.h"
49 #include "BLI_array_utils.h"
50
51 #include "BKE_animsys.h"
52 #include "BKE_brush.h"
53 #include "BKE_displist.h"
54 #include "BKE_gpencil.h"
55 #include "BKE_icons.h"
56 #include "BKE_image.h"
57 #include "BKE_library.h"
58 #include "BKE_main.h"
59 #include "BKE_material.h"
60 #include "BKE_mesh.h"
61 #include "BKE_scene.h"
62 #include "BKE_node.h"
63 #include "BKE_curve.h"
64 #include "BKE_editmesh.h"
65 #include "BKE_font.h"
66
67 #include "DEG_depsgraph.h"
68 #include "DEG_depsgraph_build.h"
69
70 #include "GPU_material.h"
71
72 /* used in UI and render */
73 Material defmaterial;
74
75 static CLG_LogRef LOG = {"bke.material"};
76
77 /* called on startup, creator.c */
78 void init_def_material(void)
79 {
80   BKE_material_init(&defmaterial);
81 }
82
83 /** Free (or release) any data used by this material (does not free the material itself). */
84 void BKE_material_free(Material *ma)
85 {
86   BKE_animdata_free((ID *)ma, false);
87
88   /* Free gpu material before the ntree */
89   GPU_material_free(&ma->gpumaterial);
90
91   /* is no lib link block, but material extension */
92   if (ma->nodetree) {
93     ntreeFreeNestedTree(ma->nodetree);
94     MEM_freeN(ma->nodetree);
95     ma->nodetree = NULL;
96   }
97
98   MEM_SAFE_FREE(ma->texpaintslot);
99
100   MEM_SAFE_FREE(ma->gp_style);
101
102   BKE_icon_id_delete((ID *)ma);
103   BKE_previewimg_free(&ma->preview);
104 }
105
106 void BKE_material_init_gpencil_settings(Material *ma)
107 {
108   if ((ma) && (ma->gp_style == NULL)) {
109     ma->gp_style = MEM_callocN(sizeof(MaterialGPencilStyle), "Grease Pencil Material Settings");
110
111     MaterialGPencilStyle *gp_style = ma->gp_style;
112     /* set basic settings */
113     gp_style->stroke_rgba[3] = 1.0f;
114     gp_style->fill_rgba[3] = 1.0f;
115     gp_style->pattern_gridsize = 0.1f;
116     gp_style->gradient_radius = 0.5f;
117     ARRAY_SET_ITEMS(gp_style->mix_rgba, 1.0f, 1.0f, 1.0f, 0.2f);
118     ARRAY_SET_ITEMS(gp_style->gradient_scale, 1.0f, 1.0f);
119     ARRAY_SET_ITEMS(gp_style->texture_scale, 1.0f, 1.0f);
120     gp_style->texture_opacity = 1.0f;
121     gp_style->texture_pixsize = 100.0f;
122
123     gp_style->flag |= GP_STYLE_STROKE_SHOW;
124   }
125 }
126
127 void BKE_material_init(Material *ma)
128 {
129   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(ma, id));
130
131   ma->r = ma->g = ma->b = 0.8;
132   ma->specr = ma->specg = ma->specb = 1.0;
133   ma->a = 1.0f;
134   ma->spec = 0.5;
135
136   ma->roughness = 0.25f;
137
138   ma->pr_type = MA_SPHERE;
139
140   ma->preview = NULL;
141
142   ma->alpha_threshold = 0.5f;
143
144   ma->blend_shadow = MA_BS_SOLID;
145 }
146
147 Material *BKE_material_add(Main *bmain, const char *name)
148 {
149   Material *ma;
150
151   ma = BKE_libblock_alloc(bmain, ID_MA, name, 0);
152
153   BKE_material_init(ma);
154
155   return ma;
156 }
157
158 Material *BKE_material_add_gpencil(Main *bmain, const char *name)
159 {
160   Material *ma;
161
162   ma = BKE_material_add(bmain, name);
163
164   /* grease pencil settings */
165   if (ma != NULL) {
166     BKE_material_init_gpencil_settings(ma);
167   }
168   return ma;
169 }
170
171 /**
172  * Only copy internal data of Material ID from source to already allocated/initialized destination.
173  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
174  *
175  * WARNING! This function will not handle ID user count!
176  *
177  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
178  */
179 void BKE_material_copy_data(Main *bmain, Material *ma_dst, const Material *ma_src, const int flag)
180 {
181   if (ma_src->nodetree) {
182     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
183      *       (see BKE_libblock_copy_ex()). */
184     BKE_id_copy_ex(bmain, (ID *)ma_src->nodetree, (ID **)&ma_dst->nodetree, flag);
185   }
186
187   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
188     BKE_previewimg_id_copy(&ma_dst->id, &ma_src->id);
189   }
190   else {
191     ma_dst->preview = NULL;
192   }
193
194   if (ma_src->texpaintslot != NULL) {
195     ma_dst->texpaintslot = MEM_dupallocN(ma_src->texpaintslot);
196   }
197
198   if (ma_src->gp_style != NULL) {
199     ma_dst->gp_style = MEM_dupallocN(ma_src->gp_style);
200   }
201
202   BLI_listbase_clear(&ma_dst->gpumaterial);
203
204   /* TODO Duplicate Engine Settings and set runtime to NULL */
205 }
206
207 Material *BKE_material_copy(Main *bmain, const Material *ma)
208 {
209   Material *ma_copy;
210   BKE_id_copy(bmain, &ma->id, (ID **)&ma_copy);
211   return ma_copy;
212 }
213
214 /* XXX (see above) material copy without adding to main dbase */
215 Material *BKE_material_localize(Material *ma)
216 {
217   /* TODO(bastien): Replace with something like:
218    *
219    *   Material *ma_copy;
220    *   BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy,
221    *                  LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT,
222    *                  false);
223    *   return ma_copy;
224    *
225    * NOTE: Only possible once nested node trees are fully converted to that too. */
226
227   Material *man = BKE_libblock_copy_for_localize(&ma->id);
228
229   man->texpaintslot = NULL;
230   man->preview = NULL;
231
232   if (ma->nodetree != NULL) {
233     man->nodetree = ntreeLocalize(ma->nodetree);
234   }
235
236   if (ma->gp_style != NULL) {
237     man->gp_style = MEM_dupallocN(ma->gp_style);
238   }
239
240   BLI_listbase_clear(&man->gpumaterial);
241
242   /* TODO Duplicate Engine Settings and set runtime to NULL */
243
244   man->id.tag |= LIB_TAG_LOCALIZED;
245
246   return man;
247 }
248
249 void BKE_material_make_local(Main *bmain, Material *ma, const bool lib_local)
250 {
251   BKE_id_make_local_generic(bmain, &ma->id, true, lib_local);
252 }
253
254 Material ***give_matarar(Object *ob)
255 {
256   Mesh *me;
257   Curve *cu;
258   MetaBall *mb;
259   bGPdata *gpd;
260
261   if (ob->type == OB_MESH) {
262     me = ob->data;
263     return &(me->mat);
264   }
265   else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
266     cu = ob->data;
267     return &(cu->mat);
268   }
269   else if (ob->type == OB_MBALL) {
270     mb = ob->data;
271     return &(mb->mat);
272   }
273   else if (ob->type == OB_GPENCIL) {
274     gpd = ob->data;
275     return &(gpd->mat);
276   }
277   return NULL;
278 }
279
280 short *give_totcolp(Object *ob)
281 {
282   Mesh *me;
283   Curve *cu;
284   MetaBall *mb;
285   bGPdata *gpd;
286
287   if (ob->type == OB_MESH) {
288     me = ob->data;
289     return &(me->totcol);
290   }
291   else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
292     cu = ob->data;
293     return &(cu->totcol);
294   }
295   else if (ob->type == OB_MBALL) {
296     mb = ob->data;
297     return &(mb->totcol);
298   }
299   else if (ob->type == OB_GPENCIL) {
300     gpd = ob->data;
301     return &(gpd->totcol);
302   }
303   return NULL;
304 }
305
306 /* same as above but for ID's */
307 Material ***give_matarar_id(ID *id)
308 {
309   /* ensure we don't try get materials from non-obdata */
310   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
311
312   switch (GS(id->name)) {
313     case ID_ME:
314       return &(((Mesh *)id)->mat);
315     case ID_CU:
316       return &(((Curve *)id)->mat);
317     case ID_MB:
318       return &(((MetaBall *)id)->mat);
319     case ID_GD:
320       return &(((bGPdata *)id)->mat);
321     default:
322       break;
323   }
324   return NULL;
325 }
326
327 short *give_totcolp_id(ID *id)
328 {
329   /* ensure we don't try get materials from non-obdata */
330   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
331
332   switch (GS(id->name)) {
333     case ID_ME:
334       return &(((Mesh *)id)->totcol);
335     case ID_CU:
336       return &(((Curve *)id)->totcol);
337     case ID_MB:
338       return &(((MetaBall *)id)->totcol);
339     case ID_GD:
340       return &(((bGPdata *)id)->totcol);
341     default:
342       break;
343   }
344   return NULL;
345 }
346
347 static void material_data_index_remove_id(ID *id, short index)
348 {
349   /* ensure we don't try get materials from non-obdata */
350   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
351
352   switch (GS(id->name)) {
353     case ID_ME:
354       BKE_mesh_material_index_remove((Mesh *)id, index);
355       break;
356     case ID_CU:
357       BKE_curve_material_index_remove((Curve *)id, index);
358       break;
359     case ID_MB:
360       /* meta-elems don't have materials atm */
361       break;
362     case ID_GD:
363       BKE_gpencil_material_index_remove((bGPdata *)id, index);
364       break;
365     default:
366       break;
367   }
368 }
369
370 static void material_data_index_clear_id(ID *id)
371 {
372   /* ensure we don't try get materials from non-obdata */
373   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
374
375   switch (GS(id->name)) {
376     case ID_ME:
377       BKE_mesh_material_index_clear((Mesh *)id);
378       break;
379     case ID_CU:
380       BKE_curve_material_index_clear((Curve *)id);
381       break;
382     case ID_MB:
383       /* meta-elems don't have materials atm */
384       break;
385     default:
386       break;
387   }
388 }
389
390 void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
391 {
392   Material ***matar = give_matarar_id(id);
393   short *totcolp = give_totcolp_id(id);
394
395   if (matar == NULL) {
396     return;
397   }
398
399   if (do_id_user && totcol < (*totcolp)) {
400     short i;
401     for (i = totcol; i < (*totcolp); i++) {
402       id_us_min((ID *)(*matar)[i]);
403     }
404   }
405
406   if (totcol == 0) {
407     if (*totcolp) {
408       MEM_freeN(*matar);
409       *matar = NULL;
410     }
411   }
412   else {
413     *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
414   }
415   *totcolp = totcol;
416
417   DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
418   DEG_relations_tag_update(bmain);
419 }
420
421 void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
422 {
423   Material ***matar;
424   if ((matar = give_matarar_id(id))) {
425     short *totcol = give_totcolp_id(id);
426     Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
427     if (*totcol)
428       memcpy(mat, *matar, sizeof(void *) * (*totcol));
429     if (*matar)
430       MEM_freeN(*matar);
431
432     *matar = mat;
433     (*matar)[(*totcol)++] = ma;
434
435     id_us_plus((ID *)ma);
436     test_all_objects_materials(bmain, id);
437
438     DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
439     DEG_relations_tag_update(bmain);
440   }
441 }
442
443 Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i, bool update_data)
444 {
445   short index = (short)index_i;
446   Material *ret = NULL;
447   Material ***matar;
448   if ((matar = give_matarar_id(id))) {
449     short *totcol = give_totcolp_id(id);
450     if (index >= 0 && index < (*totcol)) {
451       ret = (*matar)[index];
452       id_us_min((ID *)ret);
453
454       if (*totcol <= 1) {
455         *totcol = 0;
456         MEM_freeN(*matar);
457         *matar = NULL;
458       }
459       else {
460         if (index + 1 != (*totcol))
461           memmove((*matar) + index,
462                   (*matar) + (index + 1),
463                   sizeof(void *) * ((*totcol) - (index + 1)));
464
465         (*totcol)--;
466         *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
467         test_all_objects_materials(bmain, id);
468       }
469
470       if (update_data) {
471         /* decrease mat_nr index */
472         material_data_index_remove_id(id, index);
473       }
474
475       DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
476       DEG_relations_tag_update(bmain);
477     }
478   }
479
480   return ret;
481 }
482
483 void BKE_material_clear_id(Main *bmain, ID *id, bool update_data)
484 {
485   Material ***matar;
486   if ((matar = give_matarar_id(id))) {
487     short *totcol = give_totcolp_id(id);
488
489     while ((*totcol)--) {
490       id_us_min((ID *)((*matar)[*totcol]));
491     }
492     *totcol = 0;
493     if (*matar) {
494       MEM_freeN(*matar);
495       *matar = NULL;
496     }
497
498     if (update_data) {
499       /* decrease mat_nr index */
500       material_data_index_clear_id(id);
501     }
502
503     DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
504     DEG_relations_tag_update(bmain);
505   }
506 }
507
508 Material **give_current_material_p(Object *ob, short act)
509 {
510   Material ***matarar, **ma_p;
511   const short *totcolp;
512
513   if (ob == NULL)
514     return NULL;
515
516   /* if object cannot have material, (totcolp == NULL) */
517   totcolp = give_totcolp(ob);
518   if (totcolp == NULL || ob->totcol == 0)
519     return NULL;
520
521   /* return NULL for invalid 'act', can happen for mesh face indices */
522   if (act > ob->totcol)
523     return NULL;
524   else if (act <= 0) {
525     if (act < 0) {
526       CLOG_ERROR(&LOG, "Negative material index!");
527     }
528     return NULL;
529   }
530
531   if (ob->matbits && ob->matbits[act - 1]) { /* in object */
532     ma_p = &ob->mat[act - 1];
533   }
534   else { /* in data */
535
536     /* check for inconsistency */
537     if (*totcolp < ob->totcol)
538       ob->totcol = *totcolp;
539     if (act > ob->totcol)
540       act = ob->totcol;
541
542     matarar = give_matarar(ob);
543
544     if (matarar && *matarar) {
545       ma_p = &(*matarar)[act - 1];
546     }
547     else {
548       ma_p = NULL;
549     }
550   }
551
552   return ma_p;
553 }
554
555 Material *give_current_material(Object *ob, short act)
556 {
557   Material **ma_p = give_current_material_p(ob, act);
558   return ma_p ? *ma_p : NULL;
559 }
560
561 MaterialGPencilStyle *BKE_material_gpencil_settings_get(Object *ob, short act)
562 {
563   Material *ma = give_current_material(ob, act);
564   if (ma != NULL) {
565     if (ma->gp_style == NULL) {
566       BKE_material_init_gpencil_settings(ma);
567     }
568
569     return ma->gp_style;
570   }
571   else {
572     return NULL;
573   }
574 }
575
576 Material *give_node_material(Material *ma)
577 {
578   if (ma && ma->use_nodes && ma->nodetree) {
579     bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
580
581     if (node)
582       return (Material *)node->id;
583   }
584
585   return NULL;
586 }
587
588 void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
589 {
590   Material **newmatar;
591   char *newmatbits;
592
593   if (do_id_user && totcol < ob->totcol) {
594     short i;
595     for (i = totcol; i < ob->totcol; i++) {
596       id_us_min((ID *)ob->mat[i]);
597     }
598   }
599
600   if (totcol == 0) {
601     if (ob->totcol) {
602       MEM_freeN(ob->mat);
603       MEM_freeN(ob->matbits);
604       ob->mat = NULL;
605       ob->matbits = NULL;
606     }
607   }
608   else if (ob->totcol < totcol) {
609     newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
610     newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
611     if (ob->totcol) {
612       memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
613       memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
614       MEM_freeN(ob->mat);
615       MEM_freeN(ob->matbits);
616     }
617     ob->mat = newmatar;
618     ob->matbits = newmatbits;
619   }
620   /* XXX, why not realloc on shrink? - campbell */
621
622   ob->totcol = totcol;
623   if (ob->totcol && ob->actcol == 0)
624     ob->actcol = 1;
625   if (ob->actcol > ob->totcol)
626     ob->actcol = ob->totcol;
627
628   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE | ID_RECALC_GEOMETRY);
629   DEG_relations_tag_update(bmain);
630 }
631
632 void test_object_materials(Main *bmain, Object *ob, ID *id)
633 {
634   /* make the ob mat-array same size as 'ob->data' mat-array */
635   const short *totcol;
636
637   if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
638     return;
639   }
640
641   BKE_material_resize_object(bmain, ob, *totcol, false);
642 }
643
644 void test_all_objects_materials(Main *bmain, ID *id)
645 {
646   /* make the ob mat-array same size as 'ob->data' mat-array */
647   Object *ob;
648   const short *totcol;
649
650   if (id == NULL || (totcol = give_totcolp_id(id)) == NULL) {
651     return;
652   }
653
654   BKE_main_lock(bmain);
655   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
656     if (ob->data == id) {
657       BKE_material_resize_object(bmain, ob, *totcol, false);
658     }
659   }
660   BKE_main_unlock(bmain);
661 }
662
663 void assign_material_id(Main *bmain, ID *id, Material *ma, short act)
664 {
665   Material *mao, **matar, ***matarar;
666   short *totcolp;
667
668   if (act > MAXMAT)
669     return;
670   if (act < 1)
671     act = 1;
672
673   /* test arraylens */
674
675   totcolp = give_totcolp_id(id);
676   matarar = give_matarar_id(id);
677
678   if (totcolp == NULL || matarar == NULL)
679     return;
680
681   if (act > *totcolp) {
682     matar = MEM_callocN(sizeof(void *) * act, "matarray1");
683
684     if (*totcolp) {
685       memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
686       MEM_freeN(*matarar);
687     }
688
689     *matarar = matar;
690     *totcolp = act;
691   }
692
693   /* in data */
694   mao = (*matarar)[act - 1];
695   if (mao)
696     id_us_min(&mao->id);
697   (*matarar)[act - 1] = ma;
698
699   if (ma)
700     id_us_plus(&ma->id);
701
702   test_all_objects_materials(bmain, id);
703 }
704
705 void assign_material(Main *bmain, Object *ob, Material *ma, short act, int assign_type)
706 {
707   Material *mao, **matar, ***matarar;
708   short *totcolp;
709   char bit = 0;
710
711   if (act > MAXMAT)
712     return;
713   if (act < 1)
714     act = 1;
715
716   /* prevent crashing when using accidentally */
717   BLI_assert(!ID_IS_LINKED(ob));
718   if (ID_IS_LINKED(ob))
719     return;
720
721   /* test arraylens */
722
723   totcolp = give_totcolp(ob);
724   matarar = give_matarar(ob);
725
726   if (totcolp == NULL || matarar == NULL)
727     return;
728
729   if (act > *totcolp) {
730     matar = MEM_callocN(sizeof(void *) * act, "matarray1");
731
732     if (*totcolp) {
733       memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
734       MEM_freeN(*matarar);
735     }
736
737     *matarar = matar;
738     *totcolp = act;
739   }
740
741   if (act > ob->totcol) {
742     /* Need more space in the material arrays */
743     ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
744     ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
745     ob->totcol = act;
746   }
747
748   /* Determine the object/mesh linking */
749   if (assign_type == BKE_MAT_ASSIGN_EXISTING) {
750     /* keep existing option (avoid confusion in scripts),
751      * intentionally ignore userpref (default to obdata). */
752     bit = ob->matbits[act - 1];
753   }
754   else if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
755     /* copy from previous material */
756     bit = ob->matbits[ob->actcol - 1];
757   }
758   else {
759     switch (assign_type) {
760       case BKE_MAT_ASSIGN_OBDATA:
761         bit = 0;
762         break;
763       case BKE_MAT_ASSIGN_OBJECT:
764         bit = 1;
765         break;
766       case BKE_MAT_ASSIGN_USERPREF:
767       default:
768         bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
769         break;
770     }
771   }
772
773   /* do it */
774
775   ob->matbits[act - 1] = bit;
776   if (bit == 1) { /* in object */
777     mao = ob->mat[act - 1];
778     if (mao)
779       id_us_min(&mao->id);
780     ob->mat[act - 1] = ma;
781     test_object_materials(bmain, ob, ob->data);
782   }
783   else { /* in data */
784     mao = (*matarar)[act - 1];
785     if (mao)
786       id_us_min(&mao->id);
787     (*matarar)[act - 1] = ma;
788     test_all_objects_materials(bmain, ob->data); /* Data may be used by several objects... */
789   }
790
791   if (ma)
792     id_us_plus(&ma->id);
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 if (ob->type == OB_GPENCIL) {
817     BKE_gpencil_material_remap(ob->data, remap, ob->totcol);
818   }
819   else {
820     /* add support for this object data! */
821     BLI_assert(matar == NULL);
822   }
823 }
824
825 /**
826  * Calculate a material remapping from \a ob_src to \a ob_dst.
827  *
828  * \param remap_src_to_dst: An array the size of `ob_src->totcol`
829  * where index values are filled in which map to \a ob_dst materials.
830  */
831 void BKE_material_remap_object_calc(Object *ob_dst, Object *ob_src, short *remap_src_to_dst)
832 {
833   if (ob_src->totcol == 0) {
834     return;
835   }
836
837   GHash *gh_mat_map = BLI_ghash_ptr_new_ex(__func__, ob_src->totcol);
838
839   for (int i = 0; i < ob_dst->totcol; i++) {
840     Material *ma_src = give_current_material(ob_dst, i + 1);
841     BLI_ghash_reinsert(gh_mat_map, ma_src, POINTER_FROM_INT(i), NULL, NULL);
842   }
843
844   /* setup default mapping (when materials don't match) */
845   {
846     int i = 0;
847     if (ob_dst->totcol >= ob_src->totcol) {
848       for (; i < ob_src->totcol; i++) {
849         remap_src_to_dst[i] = i;
850       }
851     }
852     else {
853       for (; i < ob_dst->totcol; i++) {
854         remap_src_to_dst[i] = i;
855       }
856       for (; i < ob_src->totcol; i++) {
857         remap_src_to_dst[i] = 0;
858       }
859     }
860   }
861
862   for (int i = 0; i < ob_src->totcol; i++) {
863     Material *ma_src = give_current_material(ob_src, i + 1);
864
865     if ((i < ob_dst->totcol) && (ma_src == give_current_material(ob_dst, i + 1))) {
866       /* when objects have exact matching materials - keep existing index */
867     }
868     else {
869       void **index_src_p = BLI_ghash_lookup_p(gh_mat_map, ma_src);
870       if (index_src_p) {
871         remap_src_to_dst[i] = POINTER_AS_INT(*index_src_p);
872       }
873     }
874   }
875
876   BLI_ghash_free(gh_mat_map, NULL, NULL);
877 }
878
879 /* XXX - this calls many more update calls per object then are needed, could be optimized */
880 void assign_matarar(Main *bmain, struct Object *ob, struct Material ***matar, short totcol)
881 {
882   int actcol_orig = ob->actcol;
883   short i;
884
885   while ((ob->totcol > totcol) && BKE_object_material_slot_remove(bmain, ob)) {
886     /* pass */
887   }
888
889   /* now we have the right number of slots */
890   for (i = 0; i < totcol; i++)
891     assign_material(bmain, ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
892
893   if (actcol_orig > ob->totcol)
894     actcol_orig = ob->totcol;
895
896   ob->actcol = actcol_orig;
897 }
898
899 short BKE_object_material_slot_find_index(Object *ob, Material *ma)
900 {
901   Material ***matarar;
902   short a, *totcolp;
903
904   if (ma == NULL)
905     return 0;
906
907   totcolp = give_totcolp(ob);
908   matarar = give_matarar(ob);
909
910   if (totcolp == NULL || matarar == NULL)
911     return 0;
912
913   for (a = 0; a < *totcolp; a++)
914     if ((*matarar)[a] == ma)
915       break;
916   if (a < *totcolp)
917     return a + 1;
918   return 0;
919 }
920
921 bool BKE_object_material_slot_add(Main *bmain, Object *ob)
922 {
923   if (ob == NULL)
924     return false;
925   if (ob->totcol >= MAXMAT)
926     return false;
927
928   assign_material(bmain, ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
929   ob->actcol = ob->totcol;
930   return true;
931 }
932
933 /* ****************** */
934
935 bool BKE_object_material_slot_remove(Main *bmain, Object *ob)
936 {
937   Material *mao, ***matarar;
938   short *totcolp;
939   short a, actcol;
940
941   if (ob == NULL || ob->totcol == 0) {
942     return false;
943   }
944
945   /* this should never happen and used to crash */
946   if (ob->actcol <= 0) {
947     CLOG_ERROR(&LOG, "invalid material index %d, report a bug!", ob->actcol);
948     BLI_assert(0);
949     return false;
950   }
951
952   /* take a mesh/curve/mball as starting point, remove 1 index,
953    * AND with all objects that share the ob->data
954    *
955    * after that check indices in mesh/curve/mball!!!
956    */
957
958   totcolp = give_totcolp(ob);
959   matarar = give_matarar(ob);
960
961   if (ELEM(NULL, matarar, *matarar)) {
962     return false;
963   }
964
965   /* can happen on face selection in editmode */
966   if (ob->actcol > ob->totcol) {
967     ob->actcol = ob->totcol;
968   }
969
970   /* we delete the actcol */
971   mao = (*matarar)[ob->actcol - 1];
972   if (mao)
973     id_us_min(&mao->id);
974
975   for (a = ob->actcol; a < ob->totcol; a++)
976     (*matarar)[a - 1] = (*matarar)[a];
977   (*totcolp)--;
978
979   if (*totcolp == 0) {
980     MEM_freeN(*matarar);
981     *matarar = NULL;
982   }
983
984   actcol = ob->actcol;
985
986   for (Object *obt = bmain->objects.first; obt; obt = obt->id.next) {
987     if (obt->data == ob->data) {
988       /* Can happen when object material lists are used, see: T52953 */
989       if (actcol > obt->totcol) {
990         continue;
991       }
992       /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
993       mao = obt->mat[actcol - 1];
994       if (mao)
995         id_us_min(&mao->id);
996
997       for (a = actcol; a < obt->totcol; a++) {
998         obt->mat[a - 1] = obt->mat[a];
999         obt->matbits[a - 1] = obt->matbits[a];
1000       }
1001       obt->totcol--;
1002       if (obt->actcol > obt->totcol)
1003         obt->actcol = obt->totcol;
1004
1005       if (obt->totcol == 0) {
1006         MEM_freeN(obt->mat);
1007         MEM_freeN(obt->matbits);
1008         obt->mat = NULL;
1009         obt->matbits = NULL;
1010       }
1011     }
1012   }
1013
1014   /* check indices from mesh */
1015   if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_GPENCIL)) {
1016     material_data_index_remove_id((ID *)ob->data, actcol - 1);
1017     if (ob->runtime.curve_cache) {
1018       BKE_displist_free(&ob->runtime.curve_cache->disp);
1019     }
1020   }
1021
1022   return true;
1023 }
1024
1025 static bNode *nodetree_uv_node_recursive(bNode *node)
1026 {
1027   bNode *inode;
1028   bNodeSocket *sock;
1029
1030   for (sock = node->inputs.first; sock; sock = sock->next) {
1031     if (sock->link) {
1032       inode = sock->link->fromnode;
1033       if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1034         return inode;
1035       }
1036       else {
1037         return nodetree_uv_node_recursive(inode);
1038       }
1039     }
1040   }
1041
1042   return NULL;
1043 }
1044
1045 static int count_texture_nodes_recursive(bNodeTree *nodetree)
1046 {
1047   int tex_nodes = 0;
1048
1049   for (bNode *node = nodetree->nodes.first; node; node = node->next) {
1050     if (node->typeinfo->nclass == NODE_CLASS_TEXTURE &&
1051         node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1052       tex_nodes++;
1053     }
1054     else if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
1055       /* recurse into the node group and see if it contains any textures */
1056       tex_nodes += count_texture_nodes_recursive((bNodeTree *)node->id);
1057     }
1058   }
1059
1060   return tex_nodes;
1061 }
1062
1063 static void fill_texpaint_slots_recursive(bNodeTree *nodetree,
1064                                           bNode *active_node,
1065                                           Material *ma,
1066                                           int *index)
1067 {
1068   for (bNode *node = nodetree->nodes.first; node; node = node->next) {
1069     if (node->typeinfo->nclass == NODE_CLASS_TEXTURE &&
1070         node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1071       if (active_node == node) {
1072         ma->paint_active_slot = *index;
1073       }
1074
1075       ma->texpaintslot[*index].ima = (Image *)node->id;
1076       ma->texpaintslot[*index].interp = ((NodeTexImage *)node->storage)->interpolation;
1077
1078       /* for new renderer, we need to traverse the treeback in search of a UV node */
1079       bNode *uvnode = nodetree_uv_node_recursive(node);
1080
1081       if (uvnode) {
1082         NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1083         ma->texpaintslot[*index].uvname = storage->uv_map;
1084         /* set a value to index so UI knows that we have a valid pointer for the mesh */
1085         ma->texpaintslot[*index].valid = true;
1086       }
1087       else {
1088         /* just invalidate the index here so UV map does not get displayed on the UI */
1089         ma->texpaintslot[*index].valid = false;
1090       }
1091       (*index)++;
1092     }
1093     else if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
1094       /* recurse into the node group and see if it contains any textures */
1095       fill_texpaint_slots_recursive((bNodeTree *)node->id, active_node, ma, index);
1096     }
1097   }
1098 }
1099
1100 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1101 {
1102   int count = 0;
1103   int index = 0;
1104
1105   if (!ma)
1106     return;
1107
1108   /* COW needed when adding texture slot on an object with no materials. */
1109   DEG_id_tag_update(&ma->id, ID_RECALC_SHADING | ID_RECALC_COPY_ON_WRITE);
1110
1111   if (ma->texpaintslot) {
1112     MEM_freeN(ma->texpaintslot);
1113     ma->tot_slots = 0;
1114     ma->texpaintslot = NULL;
1115   }
1116
1117   if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1118     ma->paint_active_slot = 0;
1119     ma->paint_clone_slot = 0;
1120     return;
1121   }
1122
1123   if (!(ma->nodetree)) {
1124     ma->paint_active_slot = 0;
1125     ma->paint_clone_slot = 0;
1126     return;
1127   }
1128
1129   count = count_texture_nodes_recursive(ma->nodetree);
1130
1131   if (count == 0) {
1132     ma->paint_active_slot = 0;
1133     ma->paint_clone_slot = 0;
1134     return;
1135   }
1136
1137   ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1138
1139   bNode *active_node = nodeGetActiveTexture(ma->nodetree);
1140
1141   fill_texpaint_slots_recursive(ma->nodetree, active_node, ma, &index);
1142
1143   ma->tot_slots = count;
1144
1145   if (ma->paint_active_slot >= count) {
1146     ma->paint_active_slot = count - 1;
1147   }
1148
1149   if (ma->paint_clone_slot >= count) {
1150     ma->paint_clone_slot = count - 1;
1151   }
1152
1153   return;
1154 }
1155
1156 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1157 {
1158   int i;
1159
1160   for (i = 1; i < ob->totcol + 1; i++) {
1161     Material *ma = give_current_material(ob, i);
1162     BKE_texpaint_slot_refresh_cache(scene, ma);
1163   }
1164 }
1165
1166 /* r_col = current value, col = new value, (fac == 0) is no change */
1167 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1168 {
1169   float tmp, facm = 1.0f - fac;
1170
1171   switch (type) {
1172     case MA_RAMP_BLEND:
1173       r_col[0] = facm * (r_col[0]) + fac * col[0];
1174       r_col[1] = facm * (r_col[1]) + fac * col[1];
1175       r_col[2] = facm * (r_col[2]) + fac * col[2];
1176       break;
1177     case MA_RAMP_ADD:
1178       r_col[0] += fac * col[0];
1179       r_col[1] += fac * col[1];
1180       r_col[2] += fac * col[2];
1181       break;
1182     case MA_RAMP_MULT:
1183       r_col[0] *= (facm + fac * col[0]);
1184       r_col[1] *= (facm + fac * col[1]);
1185       r_col[2] *= (facm + fac * col[2]);
1186       break;
1187     case MA_RAMP_SCREEN:
1188       r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1189       r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1190       r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1191       break;
1192     case MA_RAMP_OVERLAY:
1193       if (r_col[0] < 0.5f)
1194         r_col[0] *= (facm + 2.0f * fac * col[0]);
1195       else
1196         r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1197       if (r_col[1] < 0.5f)
1198         r_col[1] *= (facm + 2.0f * fac * col[1]);
1199       else
1200         r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1201       if (r_col[2] < 0.5f)
1202         r_col[2] *= (facm + 2.0f * fac * col[2]);
1203       else
1204         r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1205       break;
1206     case MA_RAMP_SUB:
1207       r_col[0] -= fac * col[0];
1208       r_col[1] -= fac * col[1];
1209       r_col[2] -= fac * col[2];
1210       break;
1211     case MA_RAMP_DIV:
1212       if (col[0] != 0.0f)
1213         r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1214       if (col[1] != 0.0f)
1215         r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1216       if (col[2] != 0.0f)
1217         r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1218       break;
1219     case MA_RAMP_DIFF:
1220       r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1221       r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1222       r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1223       break;
1224     case MA_RAMP_DARK:
1225       r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1226       r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1227       r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1228       break;
1229     case MA_RAMP_LIGHT:
1230       tmp = fac * col[0];
1231       if (tmp > r_col[0])
1232         r_col[0] = tmp;
1233       tmp = fac * col[1];
1234       if (tmp > r_col[1])
1235         r_col[1] = tmp;
1236       tmp = fac * col[2];
1237       if (tmp > r_col[2])
1238         r_col[2] = tmp;
1239       break;
1240     case MA_RAMP_DODGE:
1241       if (r_col[0] != 0.0f) {
1242         tmp = 1.0f - fac * col[0];
1243         if (tmp <= 0.0f)
1244           r_col[0] = 1.0f;
1245         else if ((tmp = (r_col[0]) / tmp) > 1.0f)
1246           r_col[0] = 1.0f;
1247         else
1248           r_col[0] = tmp;
1249       }
1250       if (r_col[1] != 0.0f) {
1251         tmp = 1.0f - fac * col[1];
1252         if (tmp <= 0.0f)
1253           r_col[1] = 1.0f;
1254         else if ((tmp = (r_col[1]) / tmp) > 1.0f)
1255           r_col[1] = 1.0f;
1256         else
1257           r_col[1] = tmp;
1258       }
1259       if (r_col[2] != 0.0f) {
1260         tmp = 1.0f - fac * col[2];
1261         if (tmp <= 0.0f)
1262           r_col[2] = 1.0f;
1263         else if ((tmp = (r_col[2]) / tmp) > 1.0f)
1264           r_col[2] = 1.0f;
1265         else
1266           r_col[2] = tmp;
1267       }
1268       break;
1269     case MA_RAMP_BURN:
1270       tmp = facm + fac * col[0];
1271
1272       if (tmp <= 0.0f)
1273         r_col[0] = 0.0f;
1274       else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f)
1275         r_col[0] = 0.0f;
1276       else if (tmp > 1.0f)
1277         r_col[0] = 1.0f;
1278       else
1279         r_col[0] = tmp;
1280
1281       tmp = facm + fac * col[1];
1282       if (tmp <= 0.0f)
1283         r_col[1] = 0.0f;
1284       else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f)
1285         r_col[1] = 0.0f;
1286       else if (tmp > 1.0f)
1287         r_col[1] = 1.0f;
1288       else
1289         r_col[1] = tmp;
1290
1291       tmp = facm + fac * col[2];
1292       if (tmp <= 0.0f)
1293         r_col[2] = 0.0f;
1294       else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f)
1295         r_col[2] = 0.0f;
1296       else if (tmp > 1.0f)
1297         r_col[2] = 1.0f;
1298       else
1299         r_col[2] = tmp;
1300       break;
1301     case MA_RAMP_HUE: {
1302       float rH, rS, rV;
1303       float colH, colS, colV;
1304       float tmpr, tmpg, tmpb;
1305       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1306       if (colS != 0) {
1307         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1308         hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1309         r_col[0] = facm * (r_col[0]) + fac * tmpr;
1310         r_col[1] = facm * (r_col[1]) + fac * tmpg;
1311         r_col[2] = facm * (r_col[2]) + fac * tmpb;
1312       }
1313       break;
1314     }
1315     case MA_RAMP_SAT: {
1316       float rH, rS, rV;
1317       float colH, colS, colV;
1318       rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1319       if (rS != 0) {
1320         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1321         hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1322       }
1323       break;
1324     }
1325     case MA_RAMP_VAL: {
1326       float rH, rS, rV;
1327       float colH, colS, colV;
1328       rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1329       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1330       hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1331       break;
1332     }
1333     case MA_RAMP_COLOR: {
1334       float rH, rS, rV;
1335       float colH, colS, colV;
1336       float tmpr, tmpg, tmpb;
1337       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1338       if (colS != 0) {
1339         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1340         hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1341         r_col[0] = facm * (r_col[0]) + fac * tmpr;
1342         r_col[1] = facm * (r_col[1]) + fac * tmpg;
1343         r_col[2] = facm * (r_col[2]) + fac * tmpb;
1344       }
1345       break;
1346     }
1347     case MA_RAMP_SOFT: {
1348       float scr, scg, scb;
1349
1350       /* first calculate non-fac based Screen mix */
1351       scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1352       scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1353       scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1354
1355       r_col[0] = facm * (r_col[0]) +
1356                  fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1357       r_col[1] = facm * (r_col[1]) +
1358                  fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1359       r_col[2] = facm * (r_col[2]) +
1360                  fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1361       break;
1362     }
1363     case MA_RAMP_LINEAR:
1364       if (col[0] > 0.5f)
1365         r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1366       else
1367         r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1368       if (col[1] > 0.5f)
1369         r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1370       else
1371         r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1372       if (col[2] > 0.5f)
1373         r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1374       else
1375         r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1376       break;
1377   }
1378 }
1379
1380 /**
1381  * \brief copy/paste buffer, if we had a proper py api that would be better
1382  * \note matcopybuf.nodetree does _NOT_ use ID's
1383  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1384  */
1385 static Material matcopybuf;
1386 static short matcopied = 0;
1387
1388 void clear_matcopybuf(void)
1389 {
1390   memset(&matcopybuf, 0, sizeof(Material));
1391   matcopied = 0;
1392 }
1393
1394 void free_matcopybuf(void)
1395 {
1396   if (matcopybuf.nodetree) {
1397     ntreeFreeLocalTree(matcopybuf.nodetree);
1398     MEM_freeN(matcopybuf.nodetree);
1399     matcopybuf.nodetree = NULL;
1400   }
1401
1402   matcopied = 0;
1403 }
1404
1405 void copy_matcopybuf(Main *bmain, Material *ma)
1406 {
1407   if (matcopied)
1408     free_matcopybuf();
1409
1410   memcpy(&matcopybuf, ma, sizeof(Material));
1411
1412   if (ma->nodetree != NULL) {
1413     matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, bmain, false);
1414   }
1415
1416   matcopybuf.preview = NULL;
1417   BLI_listbase_clear(&matcopybuf.gpumaterial);
1418   /* TODO Duplicate Engine Settings and set runtime to NULL */
1419   matcopied = 1;
1420 }
1421
1422 void paste_matcopybuf(Main *bmain, Material *ma)
1423 {
1424   ID id;
1425
1426   if (matcopied == 0)
1427     return;
1428
1429   /* Free gpu material before the ntree */
1430   GPU_material_free(&ma->gpumaterial);
1431
1432   if (ma->nodetree) {
1433     ntreeFreeNestedTree(ma->nodetree);
1434     MEM_freeN(ma->nodetree);
1435   }
1436
1437   id = (ma->id);
1438   memcpy(ma, &matcopybuf, sizeof(Material));
1439   (ma->id) = id;
1440
1441   if (matcopybuf.nodetree != NULL) {
1442     ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, bmain, false);
1443   }
1444 }
1445
1446 void BKE_material_eval(struct Depsgraph *depsgraph, Material *material)
1447 {
1448   DEG_debug_print_eval(depsgraph, __func__, material->id.name, material);
1449   GPU_material_free(&material->gpumaterial);
1450 }