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