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