Cleanup: Rename 'make local' functions to new scheme.
[blender-staging.git] / source / blender / blenkernel / intern / material.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25 #include <math.h>
26 #include <stddef.h>
27
28 #include "CLG_log.h"
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_anim_types.h"
33 #include "DNA_collection_types.h"
34 #include "DNA_curve_types.h"
35 #include "DNA_material_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_customdata_types.h"
39 #include "DNA_gpencil_types.h"
40 #include "DNA_ID.h"
41 #include "DNA_meta_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_defaults.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_lib_id.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 #include "NOD_shader.h"
74
75 static CLG_LogRef LOG = {"bke.material"};
76
77 /** Free (or release) any data used by this material (does not free the material itself). */
78 void BKE_material_free(Material *ma)
79 {
80   BKE_animdata_free((ID *)ma, false);
81
82   /* Free gpu material before the ntree */
83   GPU_material_free(&ma->gpumaterial);
84
85   /* is no lib link block, but material extension */
86   if (ma->nodetree) {
87     ntreeFreeNestedTree(ma->nodetree);
88     MEM_freeN(ma->nodetree);
89     ma->nodetree = NULL;
90   }
91
92   MEM_SAFE_FREE(ma->texpaintslot);
93
94   MEM_SAFE_FREE(ma->gp_style);
95
96   BKE_icon_id_delete((ID *)ma);
97   BKE_previewimg_free(&ma->preview);
98 }
99
100 void BKE_gpencil_material_attr_init(Material *ma)
101 {
102   if ((ma) && (ma->gp_style == NULL)) {
103     ma->gp_style = MEM_callocN(sizeof(MaterialGPencilStyle), "Grease Pencil Material Settings");
104
105     MaterialGPencilStyle *gp_style = ma->gp_style;
106     /* set basic settings */
107     gp_style->stroke_rgba[3] = 1.0f;
108     gp_style->fill_rgba[3] = 1.0f;
109     gp_style->pattern_gridsize = 0.1f;
110     gp_style->gradient_radius = 0.5f;
111     ARRAY_SET_ITEMS(gp_style->mix_rgba, 1.0f, 1.0f, 1.0f, 0.2f);
112     ARRAY_SET_ITEMS(gp_style->gradient_scale, 1.0f, 1.0f);
113     ARRAY_SET_ITEMS(gp_style->texture_scale, 1.0f, 1.0f);
114     gp_style->texture_opacity = 1.0f;
115     gp_style->texture_pixsize = 100.0f;
116
117     gp_style->flag |= GP_STYLE_STROKE_SHOW;
118   }
119 }
120
121 void BKE_material_init(Material *ma)
122 {
123   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(ma, id));
124
125   MEMCPY_STRUCT_AFTER(ma, DNA_struct_default_get(Material), id);
126 }
127
128 Material *BKE_material_add(Main *bmain, const char *name)
129 {
130   Material *ma;
131
132   ma = BKE_libblock_alloc(bmain, ID_MA, name, 0);
133
134   BKE_material_init(ma);
135
136   return ma;
137 }
138
139 Material *BKE_gpencil_material_add(Main *bmain, const char *name)
140 {
141   Material *ma;
142
143   ma = BKE_material_add(bmain, name);
144
145   /* grease pencil settings */
146   if (ma != NULL) {
147     BKE_gpencil_material_attr_init(ma);
148   }
149   return ma;
150 }
151
152 /**
153  * Only copy internal data of Material ID from source
154  * to already allocated/initialized destination.
155  * You probably never want to use that directly,
156  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
157  *
158  * WARNING! This function will not handle ID user count!
159  *
160  * \param flag: Copying options (see BKE_lib_id.h's LIB_ID_COPY_... flags for more).
161  */
162 void BKE_material_copy_data(Main *bmain, Material *ma_dst, const Material *ma_src, const int flag)
163 {
164   /* We always need allocation of our private ID data. */
165   const int flag_private_id_data = flag & ~LIB_ID_CREATE_NO_ALLOCATE;
166
167   if (ma_src->nodetree) {
168     BKE_id_copy_ex(bmain, (ID *)ma_src->nodetree, (ID **)&ma_dst->nodetree, flag_private_id_data);
169   }
170
171   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
172     BKE_previewimg_id_copy(&ma_dst->id, &ma_src->id);
173   }
174   else {
175     ma_dst->preview = NULL;
176   }
177
178   if (ma_src->texpaintslot != NULL) {
179     ma_dst->texpaintslot = MEM_dupallocN(ma_src->texpaintslot);
180   }
181
182   if (ma_src->gp_style != NULL) {
183     ma_dst->gp_style = MEM_dupallocN(ma_src->gp_style);
184   }
185
186   BLI_listbase_clear(&ma_dst->gpumaterial);
187
188   /* TODO Duplicate Engine Settings and set runtime to NULL */
189 }
190
191 Material *BKE_material_copy(Main *bmain, const Material *ma)
192 {
193   Material *ma_copy;
194   BKE_id_copy(bmain, &ma->id, (ID **)&ma_copy);
195   return ma_copy;
196 }
197
198 /* XXX (see above) material copy without adding to main dbase */
199 Material *BKE_material_localize(Material *ma)
200 {
201   /* TODO(bastien): Replace with something like:
202    *
203    *   Material *ma_copy;
204    *   BKE_id_copy_ex(bmain, &ma->id, (ID **)&ma_copy,
205    *                  LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT,
206    *                  false);
207    *   return ma_copy;
208    *
209    * NOTE: Only possible once nested node trees are fully converted to that too. */
210
211   Material *man = BKE_libblock_copy_for_localize(&ma->id);
212
213   man->texpaintslot = NULL;
214   man->preview = NULL;
215
216   if (ma->nodetree != NULL) {
217     man->nodetree = ntreeLocalize(ma->nodetree);
218   }
219
220   if (ma->gp_style != NULL) {
221     man->gp_style = MEM_dupallocN(ma->gp_style);
222   }
223
224   BLI_listbase_clear(&man->gpumaterial);
225
226   /* TODO Duplicate Engine Settings and set runtime to NULL */
227
228   man->id.tag |= LIB_TAG_LOCALIZED;
229
230   return man;
231 }
232
233 void BKE_material_make_local(Main *bmain, Material *ma, const bool lib_local)
234 {
235   BKE_lib_id_make_local_generic(bmain, &ma->id, true, lib_local);
236 }
237
238 Material ***BKE_object_material_array(Object *ob)
239 {
240   Mesh *me;
241   Curve *cu;
242   MetaBall *mb;
243   bGPdata *gpd;
244
245   if (ob->type == OB_MESH) {
246     me = ob->data;
247     return &(me->mat);
248   }
249   else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
250     cu = ob->data;
251     return &(cu->mat);
252   }
253   else if (ob->type == OB_MBALL) {
254     mb = ob->data;
255     return &(mb->mat);
256   }
257   else if (ob->type == OB_GPENCIL) {
258     gpd = ob->data;
259     return &(gpd->mat);
260   }
261   return NULL;
262 }
263
264 short *BKE_object_material_num(Object *ob)
265 {
266   Mesh *me;
267   Curve *cu;
268   MetaBall *mb;
269   bGPdata *gpd;
270
271   if (ob->type == OB_MESH) {
272     me = ob->data;
273     return &(me->totcol);
274   }
275   else if (ELEM(ob->type, OB_CURVE, OB_FONT, OB_SURF)) {
276     cu = ob->data;
277     return &(cu->totcol);
278   }
279   else if (ob->type == OB_MBALL) {
280     mb = ob->data;
281     return &(mb->totcol);
282   }
283   else if (ob->type == OB_GPENCIL) {
284     gpd = ob->data;
285     return &(gpd->totcol);
286   }
287   return NULL;
288 }
289
290 /* same as above but for ID's */
291 Material ***BKE_id_material_array(ID *id)
292 {
293   /* ensure we don't try get materials from non-obdata */
294   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
295
296   switch (GS(id->name)) {
297     case ID_ME:
298       return &(((Mesh *)id)->mat);
299     case ID_CU:
300       return &(((Curve *)id)->mat);
301     case ID_MB:
302       return &(((MetaBall *)id)->mat);
303     case ID_GD:
304       return &(((bGPdata *)id)->mat);
305     default:
306       break;
307   }
308   return NULL;
309 }
310
311 short *BKE_id_material_num(ID *id)
312 {
313   /* ensure we don't try get materials from non-obdata */
314   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
315
316   switch (GS(id->name)) {
317     case ID_ME:
318       return &(((Mesh *)id)->totcol);
319     case ID_CU:
320       return &(((Curve *)id)->totcol);
321     case ID_MB:
322       return &(((MetaBall *)id)->totcol);
323     case ID_GD:
324       return &(((bGPdata *)id)->totcol);
325     default:
326       break;
327   }
328   return NULL;
329 }
330
331 static void material_data_index_remove_id(ID *id, short index)
332 {
333   /* ensure we don't try get materials from non-obdata */
334   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
335
336   switch (GS(id->name)) {
337     case ID_ME:
338       BKE_mesh_material_index_remove((Mesh *)id, index);
339       break;
340     case ID_CU:
341       BKE_curve_material_index_remove((Curve *)id, index);
342       break;
343     case ID_MB:
344       /* meta-elems don't have materials atm */
345       break;
346     default:
347       break;
348   }
349 }
350
351 bool BKE_object_material_slot_used(ID *id, short actcol)
352 {
353   /* ensure we don't try get materials from non-obdata */
354   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
355
356   switch (GS(id->name)) {
357     case ID_ME:
358       return BKE_mesh_material_index_used((Mesh *)id, actcol - 1);
359     case ID_CU:
360       return BKE_curve_material_index_used((Curve *)id, actcol - 1);
361     case ID_MB:
362       /* meta-elems don't have materials atm */
363       return false;
364     case ID_GD:
365       return BKE_gpencil_material_index_used((bGPdata *)id, actcol - 1);
366     default:
367       return false;
368   }
369 }
370
371 static void material_data_index_clear_id(ID *id)
372 {
373   /* ensure we don't try get materials from non-obdata */
374   BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
375
376   switch (GS(id->name)) {
377     case ID_ME:
378       BKE_mesh_material_index_clear((Mesh *)id);
379       break;
380     case ID_CU:
381       BKE_curve_material_index_clear((Curve *)id);
382       break;
383     case ID_MB:
384       /* meta-elems don't have materials atm */
385       break;
386     default:
387       break;
388   }
389 }
390
391 void BKE_material_resize_id(Main *bmain, ID *id, short totcol, bool do_id_user)
392 {
393   Material ***matar = BKE_id_material_array(id);
394   short *totcolp = BKE_id_material_num(id);
395
396   if (matar == NULL) {
397     return;
398   }
399
400   if (do_id_user && totcol < (*totcolp)) {
401     short i;
402     for (i = totcol; i < (*totcolp); i++) {
403       id_us_min((ID *)(*matar)[i]);
404     }
405   }
406
407   if (totcol == 0) {
408     if (*totcolp) {
409       MEM_freeN(*matar);
410       *matar = NULL;
411     }
412   }
413   else {
414     *matar = MEM_recallocN(*matar, sizeof(void *) * totcol);
415   }
416   *totcolp = totcol;
417
418   DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
419   DEG_relations_tag_update(bmain);
420 }
421
422 void BKE_material_append_id(Main *bmain, ID *id, Material *ma)
423 {
424   Material ***matar;
425   if ((matar = BKE_id_material_array(id))) {
426     short *totcol = BKE_id_material_num(id);
427     Material **mat = MEM_callocN(sizeof(void *) * ((*totcol) + 1), "newmatar");
428     if (*totcol) {
429       memcpy(mat, *matar, sizeof(void *) * (*totcol));
430     }
431     if (*matar) {
432       MEM_freeN(*matar);
433     }
434
435     *matar = mat;
436     (*matar)[(*totcol)++] = ma;
437
438     id_us_plus((ID *)ma);
439     BKE_objects_materials_test_all(bmain, id);
440
441     DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
442     DEG_relations_tag_update(bmain);
443   }
444 }
445
446 Material *BKE_material_pop_id(Main *bmain, ID *id, int index_i)
447 {
448   short index = (short)index_i;
449   Material *ret = NULL;
450   Material ***matar;
451   if ((matar = BKE_id_material_array(id))) {
452     short *totcol = BKE_id_material_num(id);
453     if (index >= 0 && index < (*totcol)) {
454       ret = (*matar)[index];
455       id_us_min((ID *)ret);
456
457       if (*totcol <= 1) {
458         *totcol = 0;
459         MEM_freeN(*matar);
460         *matar = NULL;
461       }
462       else {
463         if (index + 1 != (*totcol)) {
464           memmove((*matar) + index,
465                   (*matar) + (index + 1),
466                   sizeof(void *) * ((*totcol) - (index + 1)));
467         }
468
469         (*totcol)--;
470         *matar = MEM_reallocN(*matar, sizeof(void *) * (*totcol));
471         BKE_objects_materials_test_all(bmain, id);
472       }
473
474       material_data_index_remove_id(id, index);
475
476       DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
477       DEG_relations_tag_update(bmain);
478     }
479   }
480
481   return ret;
482 }
483
484 void BKE_material_clear_id(Main *bmain, ID *id)
485 {
486   Material ***matar;
487   if ((matar = BKE_id_material_array(id))) {
488     short *totcol = BKE_id_material_num(id);
489
490     while ((*totcol)--) {
491       id_us_min((ID *)((*matar)[*totcol]));
492     }
493     *totcol = 0;
494     if (*matar) {
495       MEM_freeN(*matar);
496       *matar = NULL;
497     }
498
499     BKE_objects_materials_test_all(bmain, id);
500     material_data_index_clear_id(id);
501
502     DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
503     DEG_relations_tag_update(bmain);
504   }
505 }
506
507 Material **BKE_object_material_get_p(Object *ob, short act)
508 {
509   Material ***matarar, **ma_p;
510   const short *totcolp;
511
512   if (ob == NULL) {
513     return NULL;
514   }
515
516   /* if object cannot have material, (totcolp == NULL) */
517   totcolp = BKE_object_material_num(ob);
518   if (totcolp == NULL || ob->totcol == 0) {
519     return NULL;
520   }
521
522   /* return NULL for invalid 'act', can happen for mesh face indices */
523   if (act > ob->totcol) {
524     return NULL;
525   }
526   else if (act <= 0) {
527     if (act < 0) {
528       CLOG_ERROR(&LOG, "Negative material index!");
529     }
530     return NULL;
531   }
532
533   if (ob->matbits && ob->matbits[act - 1]) { /* in object */
534     ma_p = &ob->mat[act - 1];
535   }
536   else { /* in data */
537
538     /* check for inconsistency */
539     if (*totcolp < ob->totcol) {
540       ob->totcol = *totcolp;
541     }
542     if (act > ob->totcol) {
543       act = ob->totcol;
544     }
545
546     matarar = BKE_object_material_array(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 *BKE_object_material_get(Object *ob, short act)
560 {
561   Material **ma_p = BKE_object_material_get_p(ob, act);
562   return ma_p ? *ma_p : NULL;
563 }
564
565 Material *BKE_gpencil_material(Object *ob, short act)
566 {
567   Material *ma = BKE_object_material_get(ob, act);
568   if (ma != NULL) {
569     return ma;
570   }
571   else {
572     return BKE_material_default_gpencil();
573   }
574 }
575
576 MaterialGPencilStyle *BKE_gpencil_material_settings(Object *ob, short act)
577 {
578   Material *ma = BKE_object_material_get(ob, act);
579   if (ma != NULL) {
580     if (ma->gp_style == NULL) {
581       BKE_gpencil_material_attr_init(ma);
582     }
583
584     return ma->gp_style;
585   }
586   else {
587     return BKE_material_default_gpencil()->gp_style;
588   }
589 }
590
591 void BKE_material_resize_object(Main *bmain, Object *ob, const short totcol, bool do_id_user)
592 {
593   Material **newmatar;
594   char *newmatbits;
595
596   if (do_id_user && totcol < ob->totcol) {
597     short i;
598     for (i = totcol; i < ob->totcol; i++) {
599       id_us_min((ID *)ob->mat[i]);
600     }
601   }
602
603   if (totcol == 0) {
604     if (ob->totcol) {
605       MEM_freeN(ob->mat);
606       MEM_freeN(ob->matbits);
607       ob->mat = NULL;
608       ob->matbits = NULL;
609     }
610   }
611   else if (ob->totcol < totcol) {
612     newmatar = MEM_callocN(sizeof(void *) * totcol, "newmatar");
613     newmatbits = MEM_callocN(sizeof(char) * totcol, "newmatbits");
614     if (ob->totcol) {
615       memcpy(newmatar, ob->mat, sizeof(void *) * ob->totcol);
616       memcpy(newmatbits, ob->matbits, sizeof(char) * ob->totcol);
617       MEM_freeN(ob->mat);
618       MEM_freeN(ob->matbits);
619     }
620     ob->mat = newmatar;
621     ob->matbits = newmatbits;
622   }
623   /* XXX, why not realloc on shrink? - campbell */
624
625   ob->totcol = totcol;
626   if (ob->totcol && ob->actcol == 0) {
627     ob->actcol = 1;
628   }
629   if (ob->actcol > ob->totcol) {
630     ob->actcol = ob->totcol;
631   }
632
633   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE | ID_RECALC_GEOMETRY);
634   DEG_relations_tag_update(bmain);
635 }
636
637 void BKE_object_materials_test(Main *bmain, Object *ob, ID *id)
638 {
639   /* make the ob mat-array same size as 'ob->data' mat-array */
640   const short *totcol;
641
642   if (id == NULL || (totcol = BKE_id_material_num(id)) == NULL) {
643     return;
644   }
645
646   BKE_material_resize_object(bmain, ob, *totcol, false);
647 }
648
649 void BKE_objects_materials_test_all(Main *bmain, ID *id)
650 {
651   /* make the ob mat-array same size as 'ob->data' mat-array */
652   Object *ob;
653   const short *totcol;
654
655   if (id == NULL || (totcol = BKE_id_material_num(id)) == NULL) {
656     return;
657   }
658
659   BKE_main_lock(bmain);
660   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
661     if (ob->data == id) {
662       BKE_material_resize_object(bmain, ob, *totcol, false);
663     }
664   }
665   BKE_main_unlock(bmain);
666 }
667
668 void BKE_id_material_assign(Main *bmain, ID *id, Material *ma, short act)
669 {
670   Material *mao, **matar, ***matarar;
671   short *totcolp;
672
673   if (act > MAXMAT) {
674     return;
675   }
676   if (act < 1) {
677     act = 1;
678   }
679
680   /* test arraylens */
681
682   totcolp = BKE_id_material_num(id);
683   matarar = BKE_id_material_array(id);
684
685   if (totcolp == NULL || matarar == NULL) {
686     return;
687   }
688
689   if (act > *totcolp) {
690     matar = MEM_callocN(sizeof(void *) * act, "matarray1");
691
692     if (*totcolp) {
693       memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
694       MEM_freeN(*matarar);
695     }
696
697     *matarar = matar;
698     *totcolp = act;
699   }
700
701   /* in data */
702   mao = (*matarar)[act - 1];
703   if (mao) {
704     id_us_min(&mao->id);
705   }
706   (*matarar)[act - 1] = ma;
707
708   if (ma) {
709     id_us_plus(&ma->id);
710   }
711
712   BKE_objects_materials_test_all(bmain, id);
713 }
714
715 void BKE_object_material_assign(Main *bmain, Object *ob, Material *ma, short act, int assign_type)
716 {
717   Material *mao, **matar, ***matarar;
718   short *totcolp;
719   char bit = 0;
720
721   if (act > MAXMAT) {
722     return;
723   }
724   if (act < 1) {
725     act = 1;
726   }
727
728   /* prevent crashing when using accidentally */
729   BLI_assert(!ID_IS_LINKED(ob));
730   if (ID_IS_LINKED(ob)) {
731     return;
732   }
733
734   /* test arraylens */
735
736   totcolp = BKE_object_material_num(ob);
737   matarar = BKE_object_material_array(ob);
738
739   if (totcolp == NULL || matarar == NULL) {
740     return;
741   }
742
743   if (act > *totcolp) {
744     matar = MEM_callocN(sizeof(void *) * act, "matarray1");
745
746     if (*totcolp) {
747       memcpy(matar, *matarar, sizeof(void *) * (*totcolp));
748       MEM_freeN(*matarar);
749     }
750
751     *matarar = matar;
752     *totcolp = act;
753   }
754
755   if (act > ob->totcol) {
756     /* Need more space in the material arrays */
757     ob->mat = MEM_recallocN_id(ob->mat, sizeof(void *) * act, "matarray2");
758     ob->matbits = MEM_recallocN_id(ob->matbits, sizeof(char) * act, "matbits1");
759     ob->totcol = act;
760   }
761
762   /* Determine the object/mesh linking */
763   if (assign_type == BKE_MAT_ASSIGN_EXISTING) {
764     /* keep existing option (avoid confusion in scripts),
765      * intentionally ignore userpref (default to obdata). */
766     bit = ob->matbits[act - 1];
767   }
768   else if (assign_type == BKE_MAT_ASSIGN_USERPREF && ob->totcol && ob->actcol) {
769     /* copy from previous material */
770     bit = ob->matbits[ob->actcol - 1];
771   }
772   else {
773     switch (assign_type) {
774       case BKE_MAT_ASSIGN_OBDATA:
775         bit = 0;
776         break;
777       case BKE_MAT_ASSIGN_OBJECT:
778         bit = 1;
779         break;
780       case BKE_MAT_ASSIGN_USERPREF:
781       default:
782         bit = (U.flag & USER_MAT_ON_OB) ? 1 : 0;
783         break;
784     }
785   }
786
787   /* do it */
788
789   ob->matbits[act - 1] = bit;
790   if (bit == 1) { /* in object */
791     mao = ob->mat[act - 1];
792     if (mao) {
793       id_us_min(&mao->id);
794     }
795     ob->mat[act - 1] = ma;
796     BKE_object_materials_test(bmain, ob, ob->data);
797   }
798   else { /* in data */
799     mao = (*matarar)[act - 1];
800     if (mao) {
801       id_us_min(&mao->id);
802     }
803     (*matarar)[act - 1] = ma;
804     BKE_objects_materials_test_all(bmain, ob->data); /* Data may be used by several objects... */
805   }
806
807   if (ma) {
808     id_us_plus(&ma->id);
809   }
810 }
811
812 void BKE_material_remap_object(Object *ob, const unsigned int *remap)
813 {
814   Material ***matar = BKE_object_material_array(ob);
815   const short *totcol_p = BKE_object_material_num(ob);
816
817   BLI_array_permute(ob->mat, ob->totcol, remap);
818
819   if (ob->matbits) {
820     BLI_array_permute(ob->matbits, ob->totcol, remap);
821   }
822
823   if (matar) {
824     BLI_array_permute(*matar, *totcol_p, remap);
825   }
826
827   if (ob->type == OB_MESH) {
828     BKE_mesh_material_remap(ob->data, remap, ob->totcol);
829   }
830   else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
831     BKE_curve_material_remap(ob->data, remap, ob->totcol);
832   }
833   else if (ob->type == OB_GPENCIL) {
834     BKE_gpencil_material_remap(ob->data, remap, ob->totcol);
835   }
836   else {
837     /* add support for this object data! */
838     BLI_assert(matar == NULL);
839   }
840 }
841
842 /**
843  * Calculate a material remapping from \a ob_src to \a ob_dst.
844  *
845  * \param remap_src_to_dst: An array the size of `ob_src->totcol`
846  * where index values are filled in which map to \a ob_dst materials.
847  */
848 void BKE_material_remap_object_calc(Object *ob_dst, Object *ob_src, short *remap_src_to_dst)
849 {
850   if (ob_src->totcol == 0) {
851     return;
852   }
853
854   GHash *gh_mat_map = BLI_ghash_ptr_new_ex(__func__, ob_src->totcol);
855
856   for (int i = 0; i < ob_dst->totcol; i++) {
857     Material *ma_src = BKE_object_material_get(ob_dst, i + 1);
858     BLI_ghash_reinsert(gh_mat_map, ma_src, POINTER_FROM_INT(i), NULL, NULL);
859   }
860
861   /* setup default mapping (when materials don't match) */
862   {
863     int i = 0;
864     if (ob_dst->totcol >= ob_src->totcol) {
865       for (; i < ob_src->totcol; i++) {
866         remap_src_to_dst[i] = i;
867       }
868     }
869     else {
870       for (; i < ob_dst->totcol; i++) {
871         remap_src_to_dst[i] = i;
872       }
873       for (; i < ob_src->totcol; i++) {
874         remap_src_to_dst[i] = 0;
875       }
876     }
877   }
878
879   for (int i = 0; i < ob_src->totcol; i++) {
880     Material *ma_src = BKE_object_material_get(ob_src, i + 1);
881
882     if ((i < ob_dst->totcol) && (ma_src == BKE_object_material_get(ob_dst, i + 1))) {
883       /* when objects have exact matching materials - keep existing index */
884     }
885     else {
886       void **index_src_p = BLI_ghash_lookup_p(gh_mat_map, ma_src);
887       if (index_src_p) {
888         remap_src_to_dst[i] = POINTER_AS_INT(*index_src_p);
889       }
890     }
891   }
892
893   BLI_ghash_free(gh_mat_map, NULL, NULL);
894 }
895
896 /* XXX - this calls many more update calls per object then are needed, could be optimized */
897 void BKE_object_material_array_assign(Main *bmain,
898                                       struct Object *ob,
899                                       struct Material ***matar,
900                                       short totcol)
901 {
902   int actcol_orig = ob->actcol;
903   short i;
904
905   while ((ob->totcol > totcol) && BKE_object_material_slot_remove(bmain, ob)) {
906     /* pass */
907   }
908
909   /* now we have the right number of slots */
910   for (i = 0; i < totcol; i++) {
911     BKE_object_material_assign(bmain, ob, (*matar)[i], i + 1, BKE_MAT_ASSIGN_USERPREF);
912   }
913
914   if (actcol_orig > ob->totcol) {
915     actcol_orig = ob->totcol;
916   }
917
918   ob->actcol = actcol_orig;
919 }
920
921 short BKE_object_material_slot_find_index(Object *ob, Material *ma)
922 {
923   Material ***matarar;
924   short a, *totcolp;
925
926   if (ma == NULL) {
927     return 0;
928   }
929
930   totcolp = BKE_object_material_num(ob);
931   matarar = BKE_object_material_array(ob);
932
933   if (totcolp == NULL || matarar == NULL) {
934     return 0;
935   }
936
937   for (a = 0; a < *totcolp; a++) {
938     if ((*matarar)[a] == ma) {
939       break;
940     }
941   }
942   if (a < *totcolp) {
943     return a + 1;
944   }
945   return 0;
946 }
947
948 bool BKE_object_material_slot_add(Main *bmain, Object *ob)
949 {
950   if (ob == NULL) {
951     return false;
952   }
953   if (ob->totcol >= MAXMAT) {
954     return false;
955   }
956
957   BKE_object_material_assign(bmain, ob, NULL, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
958   ob->actcol = ob->totcol;
959   return true;
960 }
961
962 /* ****************** */
963
964 bool BKE_object_material_slot_remove(Main *bmain, Object *ob)
965 {
966   Material *mao, ***matarar;
967   short *totcolp;
968   short a, actcol;
969
970   if (ob == NULL || ob->totcol == 0) {
971     return false;
972   }
973
974   /* this should never happen and used to crash */
975   if (ob->actcol <= 0) {
976     CLOG_ERROR(&LOG, "invalid material index %d, report a bug!", ob->actcol);
977     BLI_assert(0);
978     return false;
979   }
980
981   /* take a mesh/curve/mball as starting point, remove 1 index,
982    * AND with all objects that share the ob->data
983    *
984    * after that check indices in mesh/curve/mball!!!
985    */
986
987   totcolp = BKE_object_material_num(ob);
988   matarar = BKE_object_material_array(ob);
989
990   if (ELEM(NULL, matarar, *matarar)) {
991     return false;
992   }
993
994   /* can happen on face selection in editmode */
995   if (ob->actcol > ob->totcol) {
996     ob->actcol = ob->totcol;
997   }
998
999   /* we delete the actcol */
1000   mao = (*matarar)[ob->actcol - 1];
1001   if (mao) {
1002     id_us_min(&mao->id);
1003   }
1004
1005   for (a = ob->actcol; a < ob->totcol; a++) {
1006     (*matarar)[a - 1] = (*matarar)[a];
1007   }
1008   (*totcolp)--;
1009
1010   if (*totcolp == 0) {
1011     MEM_freeN(*matarar);
1012     *matarar = NULL;
1013   }
1014
1015   actcol = ob->actcol;
1016
1017   for (Object *obt = bmain->objects.first; obt; obt = obt->id.next) {
1018     if (obt->data == ob->data) {
1019       /* Can happen when object material lists are used, see: T52953 */
1020       if (actcol > obt->totcol) {
1021         continue;
1022       }
1023       /* WATCH IT: do not use actcol from ob or from obt (can become zero) */
1024       mao = obt->mat[actcol - 1];
1025       if (mao) {
1026         id_us_min(&mao->id);
1027       }
1028
1029       for (a = actcol; a < obt->totcol; a++) {
1030         obt->mat[a - 1] = obt->mat[a];
1031         obt->matbits[a - 1] = obt->matbits[a];
1032       }
1033       obt->totcol--;
1034       if (obt->actcol > obt->totcol) {
1035         obt->actcol = obt->totcol;
1036       }
1037
1038       if (obt->totcol == 0) {
1039         MEM_freeN(obt->mat);
1040         MEM_freeN(obt->matbits);
1041         obt->mat = NULL;
1042         obt->matbits = NULL;
1043       }
1044     }
1045   }
1046
1047   /* check indices from mesh */
1048   if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT)) {
1049     material_data_index_remove_id((ID *)ob->data, actcol - 1);
1050     if (ob->runtime.curve_cache) {
1051       BKE_displist_free(&ob->runtime.curve_cache->disp);
1052     }
1053   }
1054   /* check indices from gpencil */
1055   else if (ob->type == OB_GPENCIL) {
1056     BKE_gpencil_material_index_reassign((bGPdata *)ob->data, ob->totcol, actcol - 1);
1057   }
1058
1059   return true;
1060 }
1061
1062 static bNode *nodetree_uv_node_recursive(bNode *node)
1063 {
1064   bNode *inode;
1065   bNodeSocket *sock;
1066
1067   for (sock = node->inputs.first; sock; sock = sock->next) {
1068     if (sock->link) {
1069       inode = sock->link->fromnode;
1070       if (inode->typeinfo->nclass == NODE_CLASS_INPUT && inode->typeinfo->type == SH_NODE_UVMAP) {
1071         return inode;
1072       }
1073       else {
1074         return nodetree_uv_node_recursive(inode);
1075       }
1076     }
1077   }
1078
1079   return NULL;
1080 }
1081
1082 typedef bool (*ForEachTexNodeCallback)(bNode *node, void *userdata);
1083 static bool ntree_foreach_texnode_recursive(bNodeTree *nodetree,
1084                                             ForEachTexNodeCallback callback,
1085                                             void *userdata)
1086 {
1087   for (bNode *node = nodetree->nodes.first; node; node = node->next) {
1088     if (node->typeinfo->nclass == NODE_CLASS_TEXTURE &&
1089         node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
1090       if (!callback(node, userdata)) {
1091         return false;
1092       }
1093     }
1094     else if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
1095       /* recurse into the node group and see if it contains any textures */
1096       if (!ntree_foreach_texnode_recursive((bNodeTree *)node->id, callback, userdata)) {
1097         return false;
1098       }
1099     }
1100   }
1101   return true;
1102 }
1103
1104 static bool count_texture_nodes_cb(bNode *UNUSED(node), void *userdata)
1105 {
1106   (*((int *)userdata))++;
1107   return true;
1108 }
1109
1110 static int count_texture_nodes_recursive(bNodeTree *nodetree)
1111 {
1112   int tex_nodes = 0;
1113   ntree_foreach_texnode_recursive(nodetree, count_texture_nodes_cb, &tex_nodes);
1114
1115   return tex_nodes;
1116 }
1117
1118 struct FillTexPaintSlotsData {
1119   bNode *active_node;
1120   Material *ma;
1121   int index;
1122   int slot_len;
1123 };
1124
1125 static bool fill_texpaint_slots_cb(bNode *node, void *userdata)
1126 {
1127   struct FillTexPaintSlotsData *fill_data = userdata;
1128
1129   Material *ma = fill_data->ma;
1130   int index = fill_data->index;
1131   fill_data->index++;
1132
1133   if (fill_data->active_node == node) {
1134     ma->paint_active_slot = index;
1135   }
1136
1137   ma->texpaintslot[index].ima = (Image *)node->id;
1138   ma->texpaintslot[index].interp = ((NodeTexImage *)node->storage)->interpolation;
1139
1140   /* for new renderer, we need to traverse the treeback in search of a UV node */
1141   bNode *uvnode = nodetree_uv_node_recursive(node);
1142
1143   if (uvnode) {
1144     NodeShaderUVMap *storage = (NodeShaderUVMap *)uvnode->storage;
1145     ma->texpaintslot[index].uvname = storage->uv_map;
1146     /* set a value to index so UI knows that we have a valid pointer for the mesh */
1147     ma->texpaintslot[index].valid = true;
1148   }
1149   else {
1150     /* just invalidate the index here so UV map does not get displayed on the UI */
1151     ma->texpaintslot[index].valid = false;
1152   }
1153
1154   return fill_data->index != fill_data->slot_len;
1155 }
1156
1157 static void fill_texpaint_slots_recursive(bNodeTree *nodetree,
1158                                           bNode *active_node,
1159                                           Material *ma,
1160                                           int slot_len)
1161 {
1162   struct FillTexPaintSlotsData fill_data = {active_node, ma, 0, slot_len};
1163   ntree_foreach_texnode_recursive(nodetree, fill_texpaint_slots_cb, &fill_data);
1164 }
1165
1166 void BKE_texpaint_slot_refresh_cache(Scene *scene, Material *ma)
1167 {
1168   int count = 0;
1169
1170   if (!ma) {
1171     return;
1172   }
1173
1174   /* COW needed when adding texture slot on an object with no materials. */
1175   DEG_id_tag_update(&ma->id, ID_RECALC_SHADING | ID_RECALC_COPY_ON_WRITE);
1176
1177   if (ma->texpaintslot) {
1178     MEM_freeN(ma->texpaintslot);
1179     ma->tot_slots = 0;
1180     ma->texpaintslot = NULL;
1181   }
1182
1183   if (scene->toolsettings->imapaint.mode == IMAGEPAINT_MODE_IMAGE) {
1184     ma->paint_active_slot = 0;
1185     ma->paint_clone_slot = 0;
1186     return;
1187   }
1188
1189   if (!(ma->nodetree)) {
1190     ma->paint_active_slot = 0;
1191     ma->paint_clone_slot = 0;
1192     return;
1193   }
1194
1195   count = count_texture_nodes_recursive(ma->nodetree);
1196
1197   if (count == 0) {
1198     ma->paint_active_slot = 0;
1199     ma->paint_clone_slot = 0;
1200     return;
1201   }
1202
1203   ma->texpaintslot = MEM_callocN(sizeof(*ma->texpaintslot) * count, "texpaint_slots");
1204
1205   bNode *active_node = nodeGetActiveTexture(ma->nodetree);
1206
1207   fill_texpaint_slots_recursive(ma->nodetree, active_node, ma, count);
1208
1209   ma->tot_slots = count;
1210
1211   if (ma->paint_active_slot >= count) {
1212     ma->paint_active_slot = count - 1;
1213   }
1214
1215   if (ma->paint_clone_slot >= count) {
1216     ma->paint_clone_slot = count - 1;
1217   }
1218
1219   return;
1220 }
1221
1222 void BKE_texpaint_slots_refresh_object(Scene *scene, struct Object *ob)
1223 {
1224   int i;
1225
1226   for (i = 1; i < ob->totcol + 1; i++) {
1227     Material *ma = BKE_object_material_get(ob, i);
1228     BKE_texpaint_slot_refresh_cache(scene, ma);
1229   }
1230 }
1231
1232 struct FindTexPaintNodeData {
1233   bNode *node;
1234   short iter_index;
1235   short index;
1236 };
1237
1238 static bool texpaint_slot_node_find_cb(bNode *node, void *userdata)
1239 {
1240   struct FindTexPaintNodeData *find_data = userdata;
1241   if (find_data->iter_index++ == find_data->index) {
1242     find_data->node = node;
1243     return false;
1244   }
1245
1246   return true;
1247 }
1248
1249 bNode *BKE_texpaint_slot_material_find_node(Material *ma, short texpaint_slot)
1250 {
1251   struct FindTexPaintNodeData find_data = {NULL, 0, texpaint_slot};
1252   ntree_foreach_texnode_recursive(ma->nodetree, texpaint_slot_node_find_cb, &find_data);
1253
1254   return find_data.node;
1255 }
1256
1257 /* r_col = current value, col = new value, (fac == 0) is no change */
1258 void ramp_blend(int type, float r_col[3], const float fac, const float col[3])
1259 {
1260   float tmp, facm = 1.0f - fac;
1261
1262   switch (type) {
1263     case MA_RAMP_BLEND:
1264       r_col[0] = facm * (r_col[0]) + fac * col[0];
1265       r_col[1] = facm * (r_col[1]) + fac * col[1];
1266       r_col[2] = facm * (r_col[2]) + fac * col[2];
1267       break;
1268     case MA_RAMP_ADD:
1269       r_col[0] += fac * col[0];
1270       r_col[1] += fac * col[1];
1271       r_col[2] += fac * col[2];
1272       break;
1273     case MA_RAMP_MULT:
1274       r_col[0] *= (facm + fac * col[0]);
1275       r_col[1] *= (facm + fac * col[1]);
1276       r_col[2] *= (facm + fac * col[2]);
1277       break;
1278     case MA_RAMP_SCREEN:
1279       r_col[0] = 1.0f - (facm + fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1280       r_col[1] = 1.0f - (facm + fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1281       r_col[2] = 1.0f - (facm + fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1282       break;
1283     case MA_RAMP_OVERLAY:
1284       if (r_col[0] < 0.5f) {
1285         r_col[0] *= (facm + 2.0f * fac * col[0]);
1286       }
1287       else {
1288         r_col[0] = 1.0f - (facm + 2.0f * fac * (1.0f - col[0])) * (1.0f - r_col[0]);
1289       }
1290       if (r_col[1] < 0.5f) {
1291         r_col[1] *= (facm + 2.0f * fac * col[1]);
1292       }
1293       else {
1294         r_col[1] = 1.0f - (facm + 2.0f * fac * (1.0f - col[1])) * (1.0f - r_col[1]);
1295       }
1296       if (r_col[2] < 0.5f) {
1297         r_col[2] *= (facm + 2.0f * fac * col[2]);
1298       }
1299       else {
1300         r_col[2] = 1.0f - (facm + 2.0f * fac * (1.0f - col[2])) * (1.0f - r_col[2]);
1301       }
1302       break;
1303     case MA_RAMP_SUB:
1304       r_col[0] -= fac * col[0];
1305       r_col[1] -= fac * col[1];
1306       r_col[2] -= fac * col[2];
1307       break;
1308     case MA_RAMP_DIV:
1309       if (col[0] != 0.0f) {
1310         r_col[0] = facm * (r_col[0]) + fac * (r_col[0]) / col[0];
1311       }
1312       if (col[1] != 0.0f) {
1313         r_col[1] = facm * (r_col[1]) + fac * (r_col[1]) / col[1];
1314       }
1315       if (col[2] != 0.0f) {
1316         r_col[2] = facm * (r_col[2]) + fac * (r_col[2]) / col[2];
1317       }
1318       break;
1319     case MA_RAMP_DIFF:
1320       r_col[0] = facm * (r_col[0]) + fac * fabsf(r_col[0] - col[0]);
1321       r_col[1] = facm * (r_col[1]) + fac * fabsf(r_col[1] - col[1]);
1322       r_col[2] = facm * (r_col[2]) + fac * fabsf(r_col[2] - col[2]);
1323       break;
1324     case MA_RAMP_DARK:
1325       r_col[0] = min_ff(r_col[0], col[0]) * fac + r_col[0] * facm;
1326       r_col[1] = min_ff(r_col[1], col[1]) * fac + r_col[1] * facm;
1327       r_col[2] = min_ff(r_col[2], col[2]) * fac + r_col[2] * facm;
1328       break;
1329     case MA_RAMP_LIGHT:
1330       tmp = fac * col[0];
1331       if (tmp > r_col[0]) {
1332         r_col[0] = tmp;
1333       }
1334       tmp = fac * col[1];
1335       if (tmp > r_col[1]) {
1336         r_col[1] = tmp;
1337       }
1338       tmp = fac * col[2];
1339       if (tmp > r_col[2]) {
1340         r_col[2] = tmp;
1341       }
1342       break;
1343     case MA_RAMP_DODGE:
1344       if (r_col[0] != 0.0f) {
1345         tmp = 1.0f - fac * col[0];
1346         if (tmp <= 0.0f) {
1347           r_col[0] = 1.0f;
1348         }
1349         else if ((tmp = (r_col[0]) / tmp) > 1.0f) {
1350           r_col[0] = 1.0f;
1351         }
1352         else {
1353           r_col[0] = tmp;
1354         }
1355       }
1356       if (r_col[1] != 0.0f) {
1357         tmp = 1.0f - fac * col[1];
1358         if (tmp <= 0.0f) {
1359           r_col[1] = 1.0f;
1360         }
1361         else if ((tmp = (r_col[1]) / tmp) > 1.0f) {
1362           r_col[1] = 1.0f;
1363         }
1364         else {
1365           r_col[1] = tmp;
1366         }
1367       }
1368       if (r_col[2] != 0.0f) {
1369         tmp = 1.0f - fac * col[2];
1370         if (tmp <= 0.0f) {
1371           r_col[2] = 1.0f;
1372         }
1373         else if ((tmp = (r_col[2]) / tmp) > 1.0f) {
1374           r_col[2] = 1.0f;
1375         }
1376         else {
1377           r_col[2] = tmp;
1378         }
1379       }
1380       break;
1381     case MA_RAMP_BURN:
1382       tmp = facm + fac * col[0];
1383
1384       if (tmp <= 0.0f) {
1385         r_col[0] = 0.0f;
1386       }
1387       else if ((tmp = (1.0f - (1.0f - (r_col[0])) / tmp)) < 0.0f) {
1388         r_col[0] = 0.0f;
1389       }
1390       else if (tmp > 1.0f) {
1391         r_col[0] = 1.0f;
1392       }
1393       else {
1394         r_col[0] = tmp;
1395       }
1396
1397       tmp = facm + fac * col[1];
1398       if (tmp <= 0.0f) {
1399         r_col[1] = 0.0f;
1400       }
1401       else if ((tmp = (1.0f - (1.0f - (r_col[1])) / tmp)) < 0.0f) {
1402         r_col[1] = 0.0f;
1403       }
1404       else if (tmp > 1.0f) {
1405         r_col[1] = 1.0f;
1406       }
1407       else {
1408         r_col[1] = tmp;
1409       }
1410
1411       tmp = facm + fac * col[2];
1412       if (tmp <= 0.0f) {
1413         r_col[2] = 0.0f;
1414       }
1415       else if ((tmp = (1.0f - (1.0f - (r_col[2])) / tmp)) < 0.0f) {
1416         r_col[2] = 0.0f;
1417       }
1418       else if (tmp > 1.0f) {
1419         r_col[2] = 1.0f;
1420       }
1421       else {
1422         r_col[2] = tmp;
1423       }
1424       break;
1425     case MA_RAMP_HUE: {
1426       float rH, rS, rV;
1427       float colH, colS, colV;
1428       float tmpr, tmpg, tmpb;
1429       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1430       if (colS != 0) {
1431         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1432         hsv_to_rgb(colH, rS, rV, &tmpr, &tmpg, &tmpb);
1433         r_col[0] = facm * (r_col[0]) + fac * tmpr;
1434         r_col[1] = facm * (r_col[1]) + fac * tmpg;
1435         r_col[2] = facm * (r_col[2]) + fac * tmpb;
1436       }
1437       break;
1438     }
1439     case MA_RAMP_SAT: {
1440       float rH, rS, rV;
1441       float colH, colS, colV;
1442       rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1443       if (rS != 0) {
1444         rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1445         hsv_to_rgb(rH, (facm * rS + fac * colS), rV, r_col + 0, r_col + 1, r_col + 2);
1446       }
1447       break;
1448     }
1449     case MA_RAMP_VAL: {
1450       float rH, rS, rV;
1451       float colH, colS, colV;
1452       rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1453       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1454       hsv_to_rgb(rH, rS, (facm * rV + fac * colV), r_col + 0, r_col + 1, r_col + 2);
1455       break;
1456     }
1457     case MA_RAMP_COLOR: {
1458       float rH, rS, rV;
1459       float colH, colS, colV;
1460       float tmpr, tmpg, tmpb;
1461       rgb_to_hsv(col[0], col[1], col[2], &colH, &colS, &colV);
1462       if (colS != 0) {
1463         rgb_to_hsv(r_col[0], r_col[1], r_col[2], &rH, &rS, &rV);
1464         hsv_to_rgb(colH, colS, rV, &tmpr, &tmpg, &tmpb);
1465         r_col[0] = facm * (r_col[0]) + fac * tmpr;
1466         r_col[1] = facm * (r_col[1]) + fac * tmpg;
1467         r_col[2] = facm * (r_col[2]) + fac * tmpb;
1468       }
1469       break;
1470     }
1471     case MA_RAMP_SOFT: {
1472       float scr, scg, scb;
1473
1474       /* first calculate non-fac based Screen mix */
1475       scr = 1.0f - (1.0f - col[0]) * (1.0f - r_col[0]);
1476       scg = 1.0f - (1.0f - col[1]) * (1.0f - r_col[1]);
1477       scb = 1.0f - (1.0f - col[2]) * (1.0f - r_col[2]);
1478
1479       r_col[0] = facm * (r_col[0]) +
1480                  fac * (((1.0f - r_col[0]) * col[0] * (r_col[0])) + (r_col[0] * scr));
1481       r_col[1] = facm * (r_col[1]) +
1482                  fac * (((1.0f - r_col[1]) * col[1] * (r_col[1])) + (r_col[1] * scg));
1483       r_col[2] = facm * (r_col[2]) +
1484                  fac * (((1.0f - r_col[2]) * col[2] * (r_col[2])) + (r_col[2] * scb));
1485       break;
1486     }
1487     case MA_RAMP_LINEAR:
1488       if (col[0] > 0.5f) {
1489         r_col[0] = r_col[0] + fac * (2.0f * (col[0] - 0.5f));
1490       }
1491       else {
1492         r_col[0] = r_col[0] + fac * (2.0f * (col[0]) - 1.0f);
1493       }
1494       if (col[1] > 0.5f) {
1495         r_col[1] = r_col[1] + fac * (2.0f * (col[1] - 0.5f));
1496       }
1497       else {
1498         r_col[1] = r_col[1] + fac * (2.0f * (col[1]) - 1.0f);
1499       }
1500       if (col[2] > 0.5f) {
1501         r_col[2] = r_col[2] + fac * (2.0f * (col[2] - 0.5f));
1502       }
1503       else {
1504         r_col[2] = r_col[2] + fac * (2.0f * (col[2]) - 1.0f);
1505       }
1506       break;
1507   }
1508 }
1509
1510 /**
1511  * \brief copy/paste buffer, if we had a proper py api that would be better
1512  * \note matcopybuf.nodetree does _NOT_ use ID's
1513  * \todo matcopybuf.nodetree's  node->id's are NOT validated, this will crash!
1514  */
1515 static Material matcopybuf;
1516 static short matcopied = 0;
1517
1518 void BKE_material_copybuf_clear(void)
1519 {
1520   memset(&matcopybuf, 0, sizeof(Material));
1521   matcopied = 0;
1522 }
1523
1524 void BKE_material_copybuf_free(void)
1525 {
1526   if (matcopybuf.nodetree) {
1527     ntreeFreeLocalTree(matcopybuf.nodetree);
1528     MEM_freeN(matcopybuf.nodetree);
1529     matcopybuf.nodetree = NULL;
1530   }
1531
1532   matcopied = 0;
1533 }
1534
1535 void BKE_material_copybuf_copy(Main *bmain, Material *ma)
1536 {
1537   if (matcopied) {
1538     BKE_material_copybuf_free();
1539   }
1540
1541   memcpy(&matcopybuf, ma, sizeof(Material));
1542
1543   if (ma->nodetree != NULL) {
1544     matcopybuf.nodetree = ntreeCopyTree_ex(ma->nodetree, bmain, false);
1545   }
1546
1547   matcopybuf.preview = NULL;
1548   BLI_listbase_clear(&matcopybuf.gpumaterial);
1549   /* TODO Duplicate Engine Settings and set runtime to NULL */
1550   matcopied = 1;
1551 }
1552
1553 void BKE_material_copybuf_paste(Main *bmain, Material *ma)
1554 {
1555   ID id;
1556
1557   if (matcopied == 0) {
1558     return;
1559   }
1560
1561   /* Free gpu material before the ntree */
1562   GPU_material_free(&ma->gpumaterial);
1563
1564   if (ma->nodetree) {
1565     ntreeFreeNestedTree(ma->nodetree);
1566     MEM_freeN(ma->nodetree);
1567   }
1568
1569   id = (ma->id);
1570   memcpy(ma, &matcopybuf, sizeof(Material));
1571   (ma->id) = id;
1572
1573   if (matcopybuf.nodetree != NULL) {
1574     ma->nodetree = ntreeCopyTree_ex(matcopybuf.nodetree, bmain, false);
1575   }
1576 }
1577
1578 void BKE_material_eval(struct Depsgraph *depsgraph, Material *material)
1579 {
1580   DEG_debug_print_eval(depsgraph, __func__, material->id.name, material);
1581   GPU_material_free(&material->gpumaterial);
1582 }
1583
1584 /* Default Materials
1585  *
1586  * Used for rendering when objects have no materials assigned, and initializing
1587  * default shader nodes. */
1588
1589 static Material default_material_empty;
1590 static Material default_material_surface;
1591 static Material default_material_volume;
1592 static Material default_material_gpencil;
1593
1594 static Material *default_materials[] = {&default_material_empty,
1595                                         &default_material_surface,
1596                                         &default_material_volume,
1597                                         &default_material_gpencil,
1598                                         NULL};
1599
1600 static void material_default_gpencil_init(Material *ma)
1601 {
1602   strcpy(ma->id.name, "MADefault GPencil");
1603   BKE_gpencil_material_attr_init(ma);
1604   add_v3_fl(&ma->gp_style->stroke_rgba[0], 0.6f);
1605 }
1606
1607 static void material_default_surface_init(Material *ma)
1608 {
1609   bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1610   ma->nodetree = ntree;
1611   ma->use_nodes = true;
1612
1613   bNode *principled = nodeAddStaticNode(NULL, ntree, SH_NODE_BSDF_PRINCIPLED);
1614   bNodeSocket *base_color = nodeFindSocket(principled, SOCK_IN, "Base Color");
1615   copy_v3_v3(((bNodeSocketValueRGBA *)base_color->default_value)->value, &ma->r);
1616
1617   bNode *output = nodeAddStaticNode(NULL, ntree, SH_NODE_OUTPUT_MATERIAL);
1618
1619   nodeAddLink(ntree,
1620               principled,
1621               nodeFindSocket(principled, SOCK_OUT, "BSDF"),
1622               output,
1623               nodeFindSocket(output, SOCK_IN, "Surface"));
1624
1625   principled->locx = 10.0f;
1626   principled->locy = 300.0f;
1627   output->locx = 300.0f;
1628   output->locy = 300.0f;
1629
1630   nodeSetActive(ntree, output);
1631 }
1632
1633 static void material_default_volume_init(Material *ma)
1634 {
1635   bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1636   ma->nodetree = ntree;
1637   ma->use_nodes = true;
1638
1639   bNode *principled = nodeAddStaticNode(NULL, ntree, SH_NODE_VOLUME_PRINCIPLED);
1640   bNode *output = nodeAddStaticNode(NULL, ntree, SH_NODE_OUTPUT_MATERIAL);
1641
1642   nodeAddLink(ntree,
1643               principled,
1644               nodeFindSocket(principled, SOCK_OUT, "Volume"),
1645               output,
1646               nodeFindSocket(output, SOCK_IN, "Volume"));
1647
1648   principled->locx = 10.0f;
1649   principled->locy = 300.0f;
1650   output->locx = 300.0f;
1651   output->locy = 300.0f;
1652
1653   nodeSetActive(ntree, output);
1654 }
1655
1656 Material *BKE_material_default_empty(void)
1657 {
1658   return &default_material_empty;
1659 }
1660
1661 Material *BKE_material_default_surface(void)
1662 {
1663   return &default_material_surface;
1664 }
1665
1666 Material *BKE_material_default_volume(void)
1667 {
1668   return &default_material_volume;
1669 }
1670
1671 Material *BKE_material_default_gpencil(void)
1672 {
1673   return &default_material_gpencil;
1674 }
1675
1676 void BKE_material_defaults_free_gpu(void)
1677 {
1678   for (int i = 0; default_materials[i]; i++) {
1679     Material *ma = default_materials[i];
1680     if (ma->gpumaterial.first) {
1681       GPU_material_free(&ma->gpumaterial);
1682     }
1683   }
1684 }
1685
1686 /* Module functions called on startup and exit. */
1687
1688 void BKE_materials_init(void)
1689 {
1690   for (int i = 0; default_materials[i]; i++) {
1691     BKE_material_init(default_materials[i]);
1692   }
1693
1694   material_default_surface_init(&default_material_surface);
1695   material_default_volume_init(&default_material_volume);
1696   material_default_gpencil_init(&default_material_gpencil);
1697 }
1698
1699 void BKE_materials_exit(void)
1700 {
1701   for (int i = 0; default_materials[i]; i++) {
1702     BKE_material_free(default_materials[i]);
1703   }
1704 }