CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / blenkernel / intern / texture.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 <math.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_kdopbvh.h"
32 #include "BLI_listbase.h"
33 #include "BLI_math.h"
34 #include "BLI_math_color.h"
35 #include "BLI_utildefines.h"
36
37 #include "BLT_translation.h"
38
39 #include "DNA_brush_types.h"
40 #include "DNA_color_types.h"
41 #include "DNA_defaults.h"
42 #include "DNA_key_types.h"
43 #include "DNA_linestyle_types.h"
44 #include "DNA_material_types.h"
45 #include "DNA_node_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_particle_types.h"
48
49 #include "IMB_imbuf.h"
50
51 #include "BKE_main.h"
52
53 #include "BKE_colorband.h"
54 #include "BKE_colortools.h"
55 #include "BKE_icons.h"
56 #include "BKE_idtype.h"
57 #include "BKE_image.h"
58 #include "BKE_key.h"
59 #include "BKE_lib_id.h"
60 #include "BKE_material.h"
61 #include "BKE_node.h"
62 #include "BKE_scene.h"
63 #include "BKE_texture.h"
64
65 #include "RE_shader_ext.h"
66
67 static void texture_init_data(ID *id)
68 {
69   Tex *texture = (Tex *)id;
70
71   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(texture, id));
72
73   MEMCPY_STRUCT_AFTER(texture, DNA_struct_default_get(Tex), id);
74
75   BKE_imageuser_default(&texture->iuser);
76 }
77
78 static void texture_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int flag)
79 {
80   Tex *texture_dst = (Tex *)id_dst;
81   const Tex *texture_src = (const Tex *)id_src;
82
83   /* We always need allocation of our private ID data. */
84   const int flag_private_id_data = flag & ~LIB_ID_CREATE_NO_ALLOCATE;
85
86   if (!BKE_texture_is_image_user(texture_src)) {
87     texture_dst->ima = NULL;
88   }
89
90   if (texture_dst->coba) {
91     texture_dst->coba = MEM_dupallocN(texture_dst->coba);
92   }
93   if (texture_src->nodetree) {
94     if (texture_src->nodetree->execdata) {
95       ntreeTexEndExecTree(texture_src->nodetree->execdata);
96     }
97     BKE_id_copy_ex(
98         bmain, (ID *)texture_src->nodetree, (ID **)&texture_dst->nodetree, flag_private_id_data);
99   }
100
101   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
102     BKE_previewimg_id_copy(&texture_dst->id, &texture_src->id);
103   }
104   else {
105     texture_dst->preview = NULL;
106   }
107 }
108
109 static void texture_free_data(ID *id)
110 {
111   Tex *texture = (Tex *)id;
112
113   /* is no lib link block, but texture extension */
114   if (texture->nodetree) {
115     ntreeFreeEmbeddedTree(texture->nodetree);
116     MEM_freeN(texture->nodetree);
117     texture->nodetree = NULL;
118   }
119
120   MEM_SAFE_FREE(texture->coba);
121
122   BKE_icon_id_delete((ID *)texture);
123   BKE_previewimg_free(&texture->preview);
124 }
125
126 IDTypeInfo IDType_ID_TE = {
127     .id_code = ID_TE,
128     .id_filter = FILTER_ID_TE,
129     .main_listbase_index = INDEX_ID_TE,
130     .struct_size = sizeof(Tex),
131     .name = "Texture",
132     .name_plural = "textures",
133     .translation_context = BLT_I18NCONTEXT_ID_TEXTURE,
134     .flags = 0,
135
136     .init_data = texture_init_data,
137     .copy_data = texture_copy_data,
138     .free_data = texture_free_data,
139     .make_local = NULL,
140 };
141
142 /* ****************** Mapping ******************* */
143
144 TexMapping *BKE_texture_mapping_add(int type)
145 {
146   TexMapping *texmap = MEM_callocN(sizeof(TexMapping), "TexMapping");
147
148   BKE_texture_mapping_default(texmap, type);
149
150   return texmap;
151 }
152
153 void BKE_texture_mapping_default(TexMapping *texmap, int type)
154 {
155   memset(texmap, 0, sizeof(TexMapping));
156
157   texmap->size[0] = texmap->size[1] = texmap->size[2] = 1.0f;
158   texmap->max[0] = texmap->max[1] = texmap->max[2] = 1.0f;
159   unit_m4(texmap->mat);
160
161   texmap->projx = PROJ_X;
162   texmap->projy = PROJ_Y;
163   texmap->projz = PROJ_Z;
164   texmap->mapping = MTEX_FLAT;
165   texmap->type = type;
166 }
167
168 void BKE_texture_mapping_init(TexMapping *texmap)
169 {
170   float smat[4][4], rmat[4][4], tmat[4][4], proj[4][4], size[3];
171
172   if (texmap->projx == PROJ_X && texmap->projy == PROJ_Y && texmap->projz == PROJ_Z &&
173       is_zero_v3(texmap->loc) && is_zero_v3(texmap->rot) && is_one_v3(texmap->size)) {
174     unit_m4(texmap->mat);
175
176     texmap->flag |= TEXMAP_UNIT_MATRIX;
177   }
178   else {
179     /* axis projection */
180     zero_m4(proj);
181     proj[3][3] = 1.0f;
182
183     if (texmap->projx != PROJ_N) {
184       proj[texmap->projx - 1][0] = 1.0f;
185     }
186     if (texmap->projy != PROJ_N) {
187       proj[texmap->projy - 1][1] = 1.0f;
188     }
189     if (texmap->projz != PROJ_N) {
190       proj[texmap->projz - 1][2] = 1.0f;
191     }
192
193     /* scale */
194     copy_v3_v3(size, texmap->size);
195
196     if (ELEM(texmap->type, TEXMAP_TYPE_TEXTURE, TEXMAP_TYPE_NORMAL)) {
197       /* keep matrix invertible */
198       if (fabsf(size[0]) < 1e-5f) {
199         size[0] = signf(size[0]) * 1e-5f;
200       }
201       if (fabsf(size[1]) < 1e-5f) {
202         size[1] = signf(size[1]) * 1e-5f;
203       }
204       if (fabsf(size[2]) < 1e-5f) {
205         size[2] = signf(size[2]) * 1e-5f;
206       }
207     }
208
209     size_to_mat4(smat, texmap->size);
210
211     /* rotation */
212     eul_to_mat4(rmat, texmap->rot);
213
214     /* translation */
215     unit_m4(tmat);
216     copy_v3_v3(tmat[3], texmap->loc);
217
218     if (texmap->type == TEXMAP_TYPE_TEXTURE) {
219       /* to transform a texture, the inverse transform needs
220        * to be applied to the texture coordinate */
221       mul_m4_series(texmap->mat, tmat, rmat, smat);
222       invert_m4(texmap->mat);
223     }
224     else if (texmap->type == TEXMAP_TYPE_POINT) {
225       /* forward transform */
226       mul_m4_series(texmap->mat, tmat, rmat, smat);
227     }
228     else if (texmap->type == TEXMAP_TYPE_VECTOR) {
229       /* no translation for vectors */
230       mul_m4_m4m4(texmap->mat, rmat, smat);
231     }
232     else if (texmap->type == TEXMAP_TYPE_NORMAL) {
233       /* no translation for normals, and inverse transpose */
234       mul_m4_m4m4(texmap->mat, rmat, smat);
235       invert_m4(texmap->mat);
236       transpose_m4(texmap->mat);
237     }
238
239     /* projection last */
240     mul_m4_m4m4(texmap->mat, texmap->mat, proj);
241
242     texmap->flag &= ~TEXMAP_UNIT_MATRIX;
243   }
244 }
245
246 ColorMapping *BKE_texture_colormapping_add(void)
247 {
248   ColorMapping *colormap = MEM_callocN(sizeof(ColorMapping), "ColorMapping");
249
250   BKE_texture_colormapping_default(colormap);
251
252   return colormap;
253 }
254
255 void BKE_texture_colormapping_default(ColorMapping *colormap)
256 {
257   memset(colormap, 0, sizeof(ColorMapping));
258
259   BKE_colorband_init(&colormap->coba, true);
260
261   colormap->bright = 1.0;
262   colormap->contrast = 1.0;
263   colormap->saturation = 1.0;
264
265   colormap->blend_color[0] = 0.8f;
266   colormap->blend_color[1] = 0.8f;
267   colormap->blend_color[2] = 0.8f;
268   colormap->blend_type = MA_RAMP_BLEND;
269   colormap->blend_factor = 0.0f;
270 }
271
272 /* ******************* TEX ************************ */
273
274 /* ------------------------------------------------------------------------- */
275
276 void BKE_texture_default(Tex *tex)
277 {
278   texture_init_data(&tex->id);
279 }
280
281 void BKE_texture_type_set(Tex *tex, int type)
282 {
283   tex->type = type;
284 }
285
286 /* ------------------------------------------------------------------------- */
287
288 Tex *BKE_texture_add(Main *bmain, const char *name)
289 {
290   Tex *tex;
291
292   tex = BKE_libblock_alloc(bmain, ID_TE, name, 0);
293
294   texture_init_data(&tex->id);
295
296   return tex;
297 }
298
299 /* ------------------------------------------------------------------------- */
300
301 void BKE_texture_mtex_default(MTex *mtex)
302 {
303   memcpy(mtex, DNA_struct_default_get(MTex), sizeof(*mtex));
304 }
305
306 /* ------------------------------------------------------------------------- */
307
308 MTex *BKE_texture_mtex_add(void)
309 {
310   MTex *mtex;
311
312   mtex = MEM_callocN(sizeof(MTex), "BKE_texture_mtex_add");
313
314   BKE_texture_mtex_default(mtex);
315
316   return mtex;
317 }
318
319 /* slot -1 for first free ID */
320 MTex *BKE_texture_mtex_add_id(ID *id, int slot)
321 {
322   MTex **mtex_ar;
323   short act;
324
325   give_active_mtex(id, &mtex_ar, &act);
326
327   if (mtex_ar == NULL) {
328     return NULL;
329   }
330
331   if (slot == -1) {
332     /* find first free */
333     int i;
334     for (i = 0; i < MAX_MTEX; i++) {
335       if (!mtex_ar[i]) {
336         slot = i;
337         break;
338       }
339     }
340     if (slot == -1) {
341       return NULL;
342     }
343   }
344   else {
345     /* make sure slot is valid */
346     if (slot < 0 || slot >= MAX_MTEX) {
347       return NULL;
348     }
349   }
350
351   if (mtex_ar[slot]) {
352     id_us_min((ID *)mtex_ar[slot]->tex);
353     MEM_freeN(mtex_ar[slot]);
354     mtex_ar[slot] = NULL;
355   }
356
357   mtex_ar[slot] = BKE_texture_mtex_add();
358
359   return mtex_ar[slot];
360 }
361
362 /* ------------------------------------------------------------------------- */
363
364 Tex *BKE_texture_copy(Main *bmain, const Tex *tex)
365 {
366   Tex *tex_copy;
367   BKE_id_copy(bmain, &tex->id, (ID **)&tex_copy);
368   return tex_copy;
369 }
370
371 /* texture copy without adding to main dbase */
372 Tex *BKE_texture_localize(Tex *tex)
373 {
374   /* TODO(bastien): Replace with something like:
375    *
376    *   Tex *tex_copy;
377    *   BKE_id_copy_ex(bmain, &tex->id, (ID **)&tex_copy,
378    *                  LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT,
379    *                  false);
380    *   return tex_copy;
381    *
382    * NOTE: Only possible once nested node trees are fully converted to that too. */
383
384   Tex *texn;
385
386   texn = BKE_libblock_copy_for_localize(&tex->id);
387
388   /* image texture: texture_free_data also doesn't decrease */
389
390   if (texn->coba) {
391     texn->coba = MEM_dupallocN(texn->coba);
392   }
393
394   texn->preview = NULL;
395
396   if (tex->nodetree) {
397     texn->nodetree = ntreeLocalize(tex->nodetree);
398   }
399
400   texn->id.tag |= LIB_TAG_LOCALIZED;
401
402   return texn;
403 }
404
405 /* ------------------------------------------------------------------------- */
406
407 Tex *give_current_linestyle_texture(FreestyleLineStyle *linestyle)
408 {
409   MTex *mtex = NULL;
410   Tex *tex = NULL;
411
412   if (linestyle) {
413     mtex = linestyle->mtex[(int)(linestyle->texact)];
414     if (mtex) {
415       tex = mtex->tex;
416     }
417   }
418
419   return tex;
420 }
421
422 void set_current_linestyle_texture(FreestyleLineStyle *linestyle, Tex *newtex)
423 {
424   int act = linestyle->texact;
425
426   if (linestyle->mtex[act] && linestyle->mtex[act]->tex) {
427     id_us_min(&linestyle->mtex[act]->tex->id);
428   }
429
430   if (newtex) {
431     if (!linestyle->mtex[act]) {
432       linestyle->mtex[act] = BKE_texture_mtex_add();
433       linestyle->mtex[act]->texco = TEXCO_STROKE;
434     }
435
436     linestyle->mtex[act]->tex = newtex;
437     id_us_plus(&newtex->id);
438   }
439   else if (linestyle->mtex[act]) {
440     MEM_freeN(linestyle->mtex[act]);
441     linestyle->mtex[act] = NULL;
442   }
443 }
444
445 bool give_active_mtex(ID *id, MTex ***mtex_ar, short *act)
446 {
447   switch (GS(id->name)) {
448     case ID_LS:
449       *mtex_ar = ((FreestyleLineStyle *)id)->mtex;
450       if (act) {
451         *act = (((FreestyleLineStyle *)id)->texact);
452       }
453       break;
454     case ID_PA:
455       *mtex_ar = ((ParticleSettings *)id)->mtex;
456       if (act) {
457         *act = (((ParticleSettings *)id)->texact);
458       }
459       break;
460     default:
461       *mtex_ar = NULL;
462       if (act) {
463         *act = 0;
464       }
465       return false;
466   }
467
468   return true;
469 }
470
471 void set_active_mtex(ID *id, short act)
472 {
473   if (act < 0) {
474     act = 0;
475   }
476   else if (act >= MAX_MTEX) {
477     act = MAX_MTEX - 1;
478   }
479
480   switch (GS(id->name)) {
481     case ID_LS:
482       ((FreestyleLineStyle *)id)->texact = act;
483       break;
484     case ID_PA:
485       ((ParticleSettings *)id)->texact = act;
486       break;
487     default:
488       break;
489   }
490 }
491
492 Tex *give_current_brush_texture(Brush *br)
493 {
494   return br->mtex.tex;
495 }
496
497 void set_current_brush_texture(Brush *br, Tex *newtex)
498 {
499   if (br->mtex.tex) {
500     id_us_min(&br->mtex.tex->id);
501   }
502
503   if (newtex) {
504     br->mtex.tex = newtex;
505     id_us_plus(&newtex->id);
506   }
507 }
508
509 Tex *give_current_particle_texture(ParticleSettings *part)
510 {
511   MTex *mtex = NULL;
512   Tex *tex = NULL;
513
514   if (!part) {
515     return NULL;
516   }
517
518   mtex = part->mtex[(int)(part->texact)];
519   if (mtex) {
520     tex = mtex->tex;
521   }
522
523   return tex;
524 }
525
526 void set_current_particle_texture(ParticleSettings *part, Tex *newtex)
527 {
528   int act = part->texact;
529
530   if (part->mtex[act] && part->mtex[act]->tex) {
531     id_us_min(&part->mtex[act]->tex->id);
532   }
533
534   if (newtex) {
535     if (!part->mtex[act]) {
536       part->mtex[act] = BKE_texture_mtex_add();
537       part->mtex[act]->texco = TEXCO_ORCO;
538       part->mtex[act]->blendtype = MTEX_MUL;
539     }
540
541     part->mtex[act]->tex = newtex;
542     id_us_plus(&newtex->id);
543   }
544   else if (part->mtex[act]) {
545     MEM_freeN(part->mtex[act]);
546     part->mtex[act] = NULL;
547   }
548 }
549
550 /* ------------------------------------------------------------------------- */
551
552 void BKE_texture_pointdensity_init_data(PointDensity *pd)
553 {
554   pd->flag = 0;
555   pd->radius = 0.3f;
556   pd->falloff_type = TEX_PD_FALLOFF_STD;
557   pd->falloff_softness = 2.0;
558   pd->source = TEX_PD_PSYS;
559   pd->point_tree = NULL;
560   pd->point_data = NULL;
561   pd->noise_size = 0.5f;
562   pd->noise_depth = 1;
563   pd->noise_fac = 1.0f;
564   pd->noise_influence = TEX_PD_NOISE_STATIC;
565   pd->coba = BKE_colorband_add(true);
566   pd->speed_scale = 1.0f;
567   pd->totpoints = 0;
568   pd->object = NULL;
569   pd->psys = 0;
570   pd->psys_cache_space = TEX_PD_WORLDSPACE;
571   pd->falloff_curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
572
573   pd->falloff_curve->preset = CURVE_PRESET_LINE;
574   pd->falloff_curve->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
575   BKE_curvemap_reset(pd->falloff_curve->cm,
576                      &pd->falloff_curve->clipr,
577                      pd->falloff_curve->preset,
578                      CURVEMAP_SLOPE_POSITIVE);
579   BKE_curvemapping_changed(pd->falloff_curve, false);
580 }
581
582 PointDensity *BKE_texture_pointdensity_add(void)
583 {
584   PointDensity *pd = MEM_callocN(sizeof(PointDensity), "pointdensity");
585   BKE_texture_pointdensity_init_data(pd);
586   return pd;
587 }
588
589 PointDensity *BKE_texture_pointdensity_copy(const PointDensity *pd, const int UNUSED(flag))
590 {
591   PointDensity *pdn;
592
593   pdn = MEM_dupallocN(pd);
594   pdn->point_tree = NULL;
595   pdn->point_data = NULL;
596   if (pdn->coba) {
597     pdn->coba = MEM_dupallocN(pdn->coba);
598   }
599   pdn->falloff_curve = BKE_curvemapping_copy(pdn->falloff_curve); /* can be NULL */
600   return pdn;
601 }
602
603 void BKE_texture_pointdensity_free_data(PointDensity *pd)
604 {
605   if (pd->point_tree) {
606     BLI_bvhtree_free(pd->point_tree);
607     pd->point_tree = NULL;
608   }
609   if (pd->point_data) {
610     MEM_freeN(pd->point_data);
611     pd->point_data = NULL;
612   }
613   if (pd->coba) {
614     MEM_freeN(pd->coba);
615     pd->coba = NULL;
616   }
617
618   BKE_curvemapping_free(pd->falloff_curve); /* can be NULL */
619 }
620
621 void BKE_texture_pointdensity_free(PointDensity *pd)
622 {
623   BKE_texture_pointdensity_free_data(pd);
624   MEM_freeN(pd);
625 }
626 /* ------------------------------------------------------------------------- */
627
628 /**
629  * \returns true if this texture can use its #Texture.ima (even if its NULL)
630  */
631 bool BKE_texture_is_image_user(const struct Tex *tex)
632 {
633   switch (tex->type) {
634     case TEX_IMAGE: {
635       return true;
636     }
637   }
638
639   return false;
640 }
641
642 /* ------------------------------------------------------------------------- */
643 bool BKE_texture_dependsOnTime(const struct Tex *texture)
644 {
645   if (texture->ima && BKE_image_is_animated(texture->ima)) {
646     return true;
647   }
648   else if (texture->adt) {
649     /* assume anything in adt means the texture is animated */
650     return true;
651   }
652   else if (texture->type == TEX_NOISE) {
653     /* noise always varies with time */
654     return true;
655   }
656   return false;
657 }
658
659 /* ------------------------------------------------------------------------- */
660
661 void BKE_texture_get_value_ex(const Scene *scene,
662                               Tex *texture,
663                               float *tex_co,
664                               TexResult *texres,
665                               struct ImagePool *pool,
666                               bool use_color_management)
667 {
668   int result_type;
669   bool do_color_manage = false;
670
671   if (scene && use_color_management) {
672     do_color_manage = BKE_scene_check_color_management_enabled(scene);
673   }
674
675   /* no node textures for now */
676   result_type = multitex_ext_safe(texture, tex_co, texres, pool, do_color_manage, false);
677
678   /* if the texture gave an RGB value, we assume it didn't give a valid
679    * intensity, since this is in the context of modifiers don't use perceptual color conversion.
680    * if the texture didn't give an RGB value, copy the intensity across
681    */
682   if (result_type & TEX_RGB) {
683     texres->tin = (1.0f / 3.0f) * (texres->tr + texres->tg + texres->tb);
684   }
685   else {
686     copy_v3_fl(&texres->tr, texres->tin);
687   }
688 }
689
690 void BKE_texture_get_value(
691     const Scene *scene, Tex *texture, float *tex_co, TexResult *texres, bool use_color_management)
692 {
693   BKE_texture_get_value_ex(scene, texture, tex_co, texres, NULL, use_color_management);
694 }
695
696 static void texture_nodes_fetch_images_for_pool(Tex *texture,
697                                                 bNodeTree *ntree,
698                                                 struct ImagePool *pool)
699 {
700   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
701     if (node->type == SH_NODE_TEX_IMAGE && node->id != NULL) {
702       Image *image = (Image *)node->id;
703       BKE_image_pool_acquire_ibuf(image, &texture->iuser, pool);
704     }
705     else if (node->type == NODE_GROUP && node->id != NULL) {
706       /* TODO(sergey): Do we need to control recursion here? */
707       bNodeTree *nested_tree = (bNodeTree *)node->id;
708       texture_nodes_fetch_images_for_pool(texture, nested_tree, pool);
709     }
710   }
711 }
712
713 /* Make sure all images used by texture are loaded into pool. */
714 void BKE_texture_fetch_images_for_pool(Tex *texture, struct ImagePool *pool)
715 {
716   if (texture->nodetree != NULL) {
717     texture_nodes_fetch_images_for_pool(texture, texture->nodetree, pool);
718   }
719   else {
720     if (texture->type == TEX_IMAGE) {
721       if (texture->ima != NULL) {
722         BKE_image_pool_acquire_ibuf(texture->ima, &texture->iuser, pool);
723       }
724     }
725   }
726 }