Cleanup: style, use braces for blenkernel
[blender.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 <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <math.h>
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_math.h"
32 #include "BLI_kdopbvh.h"
33 #include "BLI_utildefines.h"
34 #include "BLI_math_color.h"
35
36 #include "DNA_key_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_material_types.h"
39 #include "DNA_brush_types.h"
40 #include "DNA_node_types.h"
41 #include "DNA_color_types.h"
42 #include "DNA_particle_types.h"
43 #include "DNA_linestyle_types.h"
44
45 #include "IMB_imbuf.h"
46
47 #include "BKE_main.h"
48
49 #include "BKE_colorband.h"
50 #include "BKE_library.h"
51 #include "BKE_image.h"
52 #include "BKE_material.h"
53 #include "BKE_texture.h"
54 #include "BKE_key.h"
55 #include "BKE_icons.h"
56 #include "BKE_node.h"
57 #include "BKE_animsys.h"
58 #include "BKE_colortools.h"
59 #include "BKE_scene.h"
60
61 #include "RE_shader_ext.h"
62
63 /* ****************** Mapping ******************* */
64
65 TexMapping *BKE_texture_mapping_add(int type)
66 {
67   TexMapping *texmap = MEM_callocN(sizeof(TexMapping), "TexMapping");
68
69   BKE_texture_mapping_default(texmap, type);
70
71   return texmap;
72 }
73
74 void BKE_texture_mapping_default(TexMapping *texmap, int type)
75 {
76   memset(texmap, 0, sizeof(TexMapping));
77
78   texmap->size[0] = texmap->size[1] = texmap->size[2] = 1.0f;
79   texmap->max[0] = texmap->max[1] = texmap->max[2] = 1.0f;
80   unit_m4(texmap->mat);
81
82   texmap->projx = PROJ_X;
83   texmap->projy = PROJ_Y;
84   texmap->projz = PROJ_Z;
85   texmap->mapping = MTEX_FLAT;
86   texmap->type = type;
87 }
88
89 void BKE_texture_mapping_init(TexMapping *texmap)
90 {
91   float smat[4][4], rmat[4][4], tmat[4][4], proj[4][4], size[3];
92
93   if (texmap->projx == PROJ_X && texmap->projy == PROJ_Y && texmap->projz == PROJ_Z &&
94       is_zero_v3(texmap->loc) && is_zero_v3(texmap->rot) && is_one_v3(texmap->size)) {
95     unit_m4(texmap->mat);
96
97     texmap->flag |= TEXMAP_UNIT_MATRIX;
98   }
99   else {
100     /* axis projection */
101     zero_m4(proj);
102     proj[3][3] = 1.0f;
103
104     if (texmap->projx != PROJ_N) {
105       proj[texmap->projx - 1][0] = 1.0f;
106     }
107     if (texmap->projy != PROJ_N) {
108       proj[texmap->projy - 1][1] = 1.0f;
109     }
110     if (texmap->projz != PROJ_N) {
111       proj[texmap->projz - 1][2] = 1.0f;
112     }
113
114     /* scale */
115     copy_v3_v3(size, texmap->size);
116
117     if (ELEM(texmap->type, TEXMAP_TYPE_TEXTURE, TEXMAP_TYPE_NORMAL)) {
118       /* keep matrix invertible */
119       if (fabsf(size[0]) < 1e-5f) {
120         size[0] = signf(size[0]) * 1e-5f;
121       }
122       if (fabsf(size[1]) < 1e-5f) {
123         size[1] = signf(size[1]) * 1e-5f;
124       }
125       if (fabsf(size[2]) < 1e-5f) {
126         size[2] = signf(size[2]) * 1e-5f;
127       }
128     }
129
130     size_to_mat4(smat, texmap->size);
131
132     /* rotation */
133     eul_to_mat4(rmat, texmap->rot);
134
135     /* translation */
136     unit_m4(tmat);
137     copy_v3_v3(tmat[3], texmap->loc);
138
139     if (texmap->type == TEXMAP_TYPE_TEXTURE) {
140       /* to transform a texture, the inverse transform needs
141        * to be applied to the texture coordinate */
142       mul_m4_series(texmap->mat, tmat, rmat, smat);
143       invert_m4(texmap->mat);
144     }
145     else if (texmap->type == TEXMAP_TYPE_POINT) {
146       /* forward transform */
147       mul_m4_series(texmap->mat, tmat, rmat, smat);
148     }
149     else if (texmap->type == TEXMAP_TYPE_VECTOR) {
150       /* no translation for vectors */
151       mul_m4_m4m4(texmap->mat, rmat, smat);
152     }
153     else if (texmap->type == TEXMAP_TYPE_NORMAL) {
154       /* no translation for normals, and inverse transpose */
155       mul_m4_m4m4(texmap->mat, rmat, smat);
156       invert_m4(texmap->mat);
157       transpose_m4(texmap->mat);
158     }
159
160     /* projection last */
161     mul_m4_m4m4(texmap->mat, texmap->mat, proj);
162
163     texmap->flag &= ~TEXMAP_UNIT_MATRIX;
164   }
165 }
166
167 ColorMapping *BKE_texture_colormapping_add(void)
168 {
169   ColorMapping *colormap = MEM_callocN(sizeof(ColorMapping), "ColorMapping");
170
171   BKE_texture_colormapping_default(colormap);
172
173   return colormap;
174 }
175
176 void BKE_texture_colormapping_default(ColorMapping *colormap)
177 {
178   memset(colormap, 0, sizeof(ColorMapping));
179
180   BKE_colorband_init(&colormap->coba, true);
181
182   colormap->bright = 1.0;
183   colormap->contrast = 1.0;
184   colormap->saturation = 1.0;
185
186   colormap->blend_color[0] = 0.8f;
187   colormap->blend_color[1] = 0.8f;
188   colormap->blend_color[2] = 0.8f;
189   colormap->blend_type = MA_RAMP_BLEND;
190   colormap->blend_factor = 0.0f;
191 }
192
193 /* ******************* TEX ************************ */
194
195 /** Free (or release) any data used by this texture (does not free the texure itself). */
196 void BKE_texture_free(Tex *tex)
197 {
198   BKE_animdata_free((ID *)tex, false);
199
200   /* is no lib link block, but texture extension */
201   if (tex->nodetree) {
202     ntreeFreeNestedTree(tex->nodetree);
203     MEM_freeN(tex->nodetree);
204     tex->nodetree = NULL;
205   }
206
207   MEM_SAFE_FREE(tex->coba);
208
209   BKE_icon_id_delete((ID *)tex);
210   BKE_previewimg_free(&tex->preview);
211 }
212
213 /* ------------------------------------------------------------------------- */
214
215 void BKE_texture_default(Tex *tex)
216 {
217   /* BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(tex, id)); */ /* Not here, can be called with some pointers set. :/ */
218
219   tex->type = TEX_IMAGE;
220   tex->ima = NULL;
221   tex->stype = 0;
222   tex->flag = TEX_CHECKER_ODD;
223   tex->imaflag = TEX_INTERPOL | TEX_MIPMAP | TEX_USEALPHA;
224   tex->extend = TEX_REPEAT;
225   tex->cropxmin = tex->cropymin = 0.0;
226   tex->cropxmax = tex->cropymax = 1.0;
227   tex->texfilter = TXF_EWA;
228   tex->afmax = 8;
229   tex->xrepeat = tex->yrepeat = 1;
230   tex->sfra = 1;
231   tex->frames = 0;
232   tex->offset = 0;
233   tex->noisesize = 0.25;
234   tex->noisedepth = 2;
235   tex->turbul = 5.0;
236   tex->nabla = 0.025;  // also in do_versions
237   tex->bright = 1.0;
238   tex->contrast = 1.0;
239   tex->saturation = 1.0;
240   tex->filtersize = 1.0;
241   tex->rfac = 1.0;
242   tex->gfac = 1.0;
243   tex->bfac = 1.0;
244   /* newnoise: init. */
245   tex->noisebasis = 0;
246   tex->noisebasis2 = 0;
247   /* musgrave */
248   tex->mg_H = 1.0;
249   tex->mg_lacunarity = 2.0;
250   tex->mg_octaves = 2.0;
251   tex->mg_offset = 1.0;
252   tex->mg_gain = 1.0;
253   tex->ns_outscale = 1.0;
254   /* distnoise */
255   tex->dist_amount = 1.0;
256   /* voronoi */
257   tex->vn_w1 = 1.0;
258   tex->vn_w2 = tex->vn_w3 = tex->vn_w4 = 0.0;
259   tex->vn_mexp = 2.5;
260   tex->vn_distm = 0;
261   tex->vn_coltype = 0;
262
263   BKE_imageuser_default(&tex->iuser);
264
265   tex->preview = NULL;
266 }
267
268 void BKE_texture_type_set(Tex *tex, int type)
269 {
270   tex->type = type;
271 }
272
273 /* ------------------------------------------------------------------------- */
274
275 Tex *BKE_texture_add(Main *bmain, const char *name)
276 {
277   Tex *tex;
278
279   tex = BKE_libblock_alloc(bmain, ID_TE, name, 0);
280
281   BKE_texture_default(tex);
282
283   return tex;
284 }
285
286 /* ------------------------------------------------------------------------- */
287
288 void BKE_texture_mtex_default(MTex *mtex)
289 {
290   mtex->texco = TEXCO_UV;
291   mtex->mapto = MAP_COL;
292   mtex->object = NULL;
293   mtex->projx = PROJ_X;
294   mtex->projy = PROJ_Y;
295   mtex->projz = PROJ_Z;
296   mtex->mapping = MTEX_FLAT;
297   mtex->ofs[0] = 0.0;
298   mtex->ofs[1] = 0.0;
299   mtex->ofs[2] = 0.0;
300   mtex->size[0] = 1.0;
301   mtex->size[1] = 1.0;
302   mtex->size[2] = 1.0;
303   mtex->tex = NULL;
304   mtex->colormodel = 0;
305   mtex->r = 1.0;
306   mtex->g = 0.0;
307   mtex->b = 1.0;
308   mtex->k = 1.0;
309   mtex->def_var = 1.0;
310   mtex->blendtype = MTEX_BLEND;
311   mtex->colfac = 1.0;
312   mtex->norfac = 1.0;
313   mtex->varfac = 1.0;
314   mtex->dispfac = 0.2;
315   mtex->colspecfac = 1.0f;
316   mtex->mirrfac = 1.0f;
317   mtex->alphafac = 1.0f;
318   mtex->difffac = 1.0f;
319   mtex->specfac = 1.0f;
320   mtex->emitfac = 1.0f;
321   mtex->hardfac = 1.0f;
322   mtex->raymirrfac = 1.0f;
323   mtex->translfac = 1.0f;
324   mtex->ambfac = 1.0f;
325   mtex->colemitfac = 1.0f;
326   mtex->colreflfac = 1.0f;
327   mtex->coltransfac = 1.0f;
328   mtex->densfac = 1.0f;
329   mtex->scatterfac = 1.0f;
330   mtex->reflfac = 1.0f;
331   mtex->shadowfac = 1.0f;
332   mtex->zenupfac = 1.0f;
333   mtex->zendownfac = 1.0f;
334   mtex->blendfac = 1.0f;
335   mtex->timefac = 1.0f;
336   mtex->lengthfac = 1.0f;
337   mtex->clumpfac = 1.0f;
338   mtex->kinkfac = 1.0f;
339   mtex->kinkampfac = 1.0f;
340   mtex->roughfac = 1.0f;
341   mtex->twistfac = 1.0f;
342   mtex->padensfac = 1.0f;
343   mtex->lifefac = 1.0f;
344   mtex->sizefac = 1.0f;
345   mtex->ivelfac = 1.0f;
346   mtex->dampfac = 1.0f;
347   mtex->gravityfac = 1.0f;
348   mtex->fieldfac = 1.0f;
349   mtex->normapspace = MTEX_NSPACE_TANGENT;
350   mtex->brush_map_mode = MTEX_MAP_MODE_TILED;
351   mtex->random_angle = 2.0f * (float)M_PI;
352   mtex->brush_angle_mode = 0;
353 }
354
355 /* ------------------------------------------------------------------------- */
356
357 MTex *BKE_texture_mtex_add(void)
358 {
359   MTex *mtex;
360
361   mtex = MEM_callocN(sizeof(MTex), "BKE_texture_mtex_add");
362
363   BKE_texture_mtex_default(mtex);
364
365   return mtex;
366 }
367
368 /* slot -1 for first free ID */
369 MTex *BKE_texture_mtex_add_id(ID *id, int slot)
370 {
371   MTex **mtex_ar;
372   short act;
373
374   give_active_mtex(id, &mtex_ar, &act);
375
376   if (mtex_ar == NULL) {
377     return NULL;
378   }
379
380   if (slot == -1) {
381     /* find first free */
382     int i;
383     for (i = 0; i < MAX_MTEX; i++) {
384       if (!mtex_ar[i]) {
385         slot = i;
386         break;
387       }
388     }
389     if (slot == -1) {
390       return NULL;
391     }
392   }
393   else {
394     /* make sure slot is valid */
395     if (slot < 0 || slot >= MAX_MTEX) {
396       return NULL;
397     }
398   }
399
400   if (mtex_ar[slot]) {
401     id_us_min((ID *)mtex_ar[slot]->tex);
402     MEM_freeN(mtex_ar[slot]);
403     mtex_ar[slot] = NULL;
404   }
405
406   mtex_ar[slot] = BKE_texture_mtex_add();
407
408   return mtex_ar[slot];
409 }
410
411 /* ------------------------------------------------------------------------- */
412
413 /**
414  * Only copy internal data of Texture ID from source to already allocated/initialized destination.
415  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
416  *
417  * WARNING! This function will not handle ID user count!
418  *
419  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
420  */
421 void BKE_texture_copy_data(Main *bmain, Tex *tex_dst, const Tex *tex_src, const int flag)
422 {
423   if (!BKE_texture_is_image_user(tex_src)) {
424     tex_dst->ima = NULL;
425   }
426
427   if (tex_dst->coba) {
428     tex_dst->coba = MEM_dupallocN(tex_dst->coba);
429   }
430   if (tex_src->nodetree) {
431     if (tex_src->nodetree->execdata) {
432       ntreeTexEndExecTree(tex_src->nodetree->execdata);
433     }
434     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
435      *       (see BKE_libblock_copy_ex()). */
436     BKE_id_copy_ex(bmain, (ID *)tex_src->nodetree, (ID **)&tex_dst->nodetree, flag);
437   }
438
439   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
440     BKE_previewimg_id_copy(&tex_dst->id, &tex_src->id);
441   }
442   else {
443     tex_dst->preview = NULL;
444   }
445 }
446
447 Tex *BKE_texture_copy(Main *bmain, const Tex *tex)
448 {
449   Tex *tex_copy;
450   BKE_id_copy(bmain, &tex->id, (ID **)&tex_copy);
451   return tex_copy;
452 }
453
454 /* texture copy without adding to main dbase */
455 Tex *BKE_texture_localize(Tex *tex)
456 {
457   /* TODO(bastien): Replace with something like:
458    *
459    *   Tex *tex_copy;
460    *   BKE_id_copy_ex(bmain, &tex->id, (ID **)&tex_copy,
461    *                  LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT,
462    *                  false);
463    *   return tex_copy;
464    *
465    * NOTE: Only possible once nested node trees are fully converted to that too. */
466
467   Tex *texn;
468
469   texn = BKE_libblock_copy_for_localize(&tex->id);
470
471   /* image texture: BKE_texture_free also doesn't decrease */
472
473   if (texn->coba) {
474     texn->coba = MEM_dupallocN(texn->coba);
475   }
476
477   texn->preview = NULL;
478
479   if (tex->nodetree) {
480     texn->nodetree = ntreeLocalize(tex->nodetree);
481   }
482
483   texn->id.tag |= LIB_TAG_LOCALIZED;
484
485   return texn;
486 }
487
488 /* ------------------------------------------------------------------------- */
489
490 void BKE_texture_make_local(Main *bmain, Tex *tex, const bool lib_local)
491 {
492   BKE_id_make_local_generic(bmain, &tex->id, true, lib_local);
493 }
494
495 Tex *give_current_linestyle_texture(FreestyleLineStyle *linestyle)
496 {
497   MTex *mtex = NULL;
498   Tex *tex = NULL;
499
500   if (linestyle) {
501     mtex = linestyle->mtex[(int)(linestyle->texact)];
502     if (mtex) {
503       tex = mtex->tex;
504     }
505   }
506
507   return tex;
508 }
509
510 void set_current_linestyle_texture(FreestyleLineStyle *linestyle, Tex *newtex)
511 {
512   int act = linestyle->texact;
513
514   if (linestyle->mtex[act] && linestyle->mtex[act]->tex) {
515     id_us_min(&linestyle->mtex[act]->tex->id);
516   }
517
518   if (newtex) {
519     if (!linestyle->mtex[act]) {
520       linestyle->mtex[act] = BKE_texture_mtex_add();
521       linestyle->mtex[act]->texco = TEXCO_STROKE;
522     }
523
524     linestyle->mtex[act]->tex = newtex;
525     id_us_plus(&newtex->id);
526   }
527   else if (linestyle->mtex[act]) {
528     MEM_freeN(linestyle->mtex[act]);
529     linestyle->mtex[act] = NULL;
530   }
531 }
532
533 bool give_active_mtex(ID *id, MTex ***mtex_ar, short *act)
534 {
535   switch (GS(id->name)) {
536     case ID_LS:
537       *mtex_ar = ((FreestyleLineStyle *)id)->mtex;
538       if (act) {
539         *act = (((FreestyleLineStyle *)id)->texact);
540       }
541       break;
542     case ID_PA:
543       *mtex_ar = ((ParticleSettings *)id)->mtex;
544       if (act) {
545         *act = (((ParticleSettings *)id)->texact);
546       }
547       break;
548     default:
549       *mtex_ar = NULL;
550       if (act) {
551         *act = 0;
552       }
553       return false;
554   }
555
556   return true;
557 }
558
559 void set_active_mtex(ID *id, short act)
560 {
561   if (act < 0) {
562     act = 0;
563   }
564   else if (act >= MAX_MTEX) {
565     act = MAX_MTEX - 1;
566   }
567
568   switch (GS(id->name)) {
569     case ID_LS:
570       ((FreestyleLineStyle *)id)->texact = act;
571       break;
572     case ID_PA:
573       ((ParticleSettings *)id)->texact = act;
574       break;
575     default:
576       break;
577   }
578 }
579
580 Tex *give_current_brush_texture(Brush *br)
581 {
582   return br->mtex.tex;
583 }
584
585 void set_current_brush_texture(Brush *br, Tex *newtex)
586 {
587   if (br->mtex.tex) {
588     id_us_min(&br->mtex.tex->id);
589   }
590
591   if (newtex) {
592     br->mtex.tex = newtex;
593     id_us_plus(&newtex->id);
594   }
595 }
596
597 Tex *give_current_particle_texture(ParticleSettings *part)
598 {
599   MTex *mtex = NULL;
600   Tex *tex = NULL;
601
602   if (!part) {
603     return NULL;
604   }
605
606   mtex = part->mtex[(int)(part->texact)];
607   if (mtex) {
608     tex = mtex->tex;
609   }
610
611   return tex;
612 }
613
614 void set_current_particle_texture(ParticleSettings *part, Tex *newtex)
615 {
616   int act = part->texact;
617
618   if (part->mtex[act] && part->mtex[act]->tex) {
619     id_us_min(&part->mtex[act]->tex->id);
620   }
621
622   if (newtex) {
623     if (!part->mtex[act]) {
624       part->mtex[act] = BKE_texture_mtex_add();
625       part->mtex[act]->texco = TEXCO_ORCO;
626       part->mtex[act]->blendtype = MTEX_MUL;
627     }
628
629     part->mtex[act]->tex = newtex;
630     id_us_plus(&newtex->id);
631   }
632   else if (part->mtex[act]) {
633     MEM_freeN(part->mtex[act]);
634     part->mtex[act] = NULL;
635   }
636 }
637
638 /* ------------------------------------------------------------------------- */
639
640 void BKE_texture_pointdensity_init_data(PointDensity *pd)
641 {
642   pd->flag = 0;
643   pd->radius = 0.3f;
644   pd->falloff_type = TEX_PD_FALLOFF_STD;
645   pd->falloff_softness = 2.0;
646   pd->source = TEX_PD_PSYS;
647   pd->point_tree = NULL;
648   pd->point_data = NULL;
649   pd->noise_size = 0.5f;
650   pd->noise_depth = 1;
651   pd->noise_fac = 1.0f;
652   pd->noise_influence = TEX_PD_NOISE_STATIC;
653   pd->coba = BKE_colorband_add(true);
654   pd->speed_scale = 1.0f;
655   pd->totpoints = 0;
656   pd->object = NULL;
657   pd->psys = 0;
658   pd->psys_cache_space = TEX_PD_WORLDSPACE;
659   pd->falloff_curve = curvemapping_add(1, 0, 0, 1, 1);
660
661   pd->falloff_curve->preset = CURVE_PRESET_LINE;
662   pd->falloff_curve->cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
663   curvemap_reset(pd->falloff_curve->cm,
664                  &pd->falloff_curve->clipr,
665                  pd->falloff_curve->preset,
666                  CURVEMAP_SLOPE_POSITIVE);
667   curvemapping_changed(pd->falloff_curve, false);
668 }
669
670 PointDensity *BKE_texture_pointdensity_add(void)
671 {
672   PointDensity *pd = MEM_callocN(sizeof(PointDensity), "pointdensity");
673   BKE_texture_pointdensity_init_data(pd);
674   return pd;
675 }
676
677 PointDensity *BKE_texture_pointdensity_copy(const PointDensity *pd, const int UNUSED(flag))
678 {
679   PointDensity *pdn;
680
681   pdn = MEM_dupallocN(pd);
682   pdn->point_tree = NULL;
683   pdn->point_data = NULL;
684   if (pdn->coba) {
685     pdn->coba = MEM_dupallocN(pdn->coba);
686   }
687   pdn->falloff_curve = curvemapping_copy(pdn->falloff_curve); /* can be NULL */
688   return pdn;
689 }
690
691 void BKE_texture_pointdensity_free_data(PointDensity *pd)
692 {
693   if (pd->point_tree) {
694     BLI_bvhtree_free(pd->point_tree);
695     pd->point_tree = NULL;
696   }
697   if (pd->point_data) {
698     MEM_freeN(pd->point_data);
699     pd->point_data = NULL;
700   }
701   if (pd->coba) {
702     MEM_freeN(pd->coba);
703     pd->coba = NULL;
704   }
705
706   curvemapping_free(pd->falloff_curve); /* can be NULL */
707 }
708
709 void BKE_texture_pointdensity_free(PointDensity *pd)
710 {
711   BKE_texture_pointdensity_free_data(pd);
712   MEM_freeN(pd);
713 }
714 /* ------------------------------------------------------------------------- */
715
716 /**
717  * \returns true if this texture can use its #Texture.ima (even if its NULL)
718  */
719 bool BKE_texture_is_image_user(const struct Tex *tex)
720 {
721   switch (tex->type) {
722     case TEX_IMAGE: {
723       return true;
724     }
725   }
726
727   return false;
728 }
729
730 /* ------------------------------------------------------------------------- */
731 bool BKE_texture_dependsOnTime(const struct Tex *texture)
732 {
733   if (texture->ima && BKE_image_is_animated(texture->ima)) {
734     return true;
735   }
736   else if (texture->adt) {
737     /* assume anything in adt means the texture is animated */
738     return true;
739   }
740   else if (texture->type == TEX_NOISE) {
741     /* noise always varies with time */
742     return true;
743   }
744   return false;
745 }
746
747 /* ------------------------------------------------------------------------- */
748
749 void BKE_texture_get_value_ex(const Scene *scene,
750                               Tex *texture,
751                               float *tex_co,
752                               TexResult *texres,
753                               struct ImagePool *pool,
754                               bool use_color_management)
755 {
756   int result_type;
757   bool do_color_manage = false;
758
759   if (scene && use_color_management) {
760     do_color_manage = BKE_scene_check_color_management_enabled(scene);
761   }
762
763   /* no node textures for now */
764   result_type = multitex_ext_safe(texture, tex_co, texres, pool, do_color_manage, false);
765
766   /* if the texture gave an RGB value, we assume it didn't give a valid
767    * intensity, since this is in the context of modifiers don't use perceptual color conversion.
768    * if the texture didn't give an RGB value, copy the intensity across
769    */
770   if (result_type & TEX_RGB) {
771     texres->tin = (1.0f / 3.0f) * (texres->tr + texres->tg + texres->tb);
772   }
773   else {
774     copy_v3_fl(&texres->tr, texres->tin);
775   }
776 }
777
778 void BKE_texture_get_value(
779     const Scene *scene, Tex *texture, float *tex_co, TexResult *texres, bool use_color_management)
780 {
781   BKE_texture_get_value_ex(scene, texture, tex_co, texres, NULL, use_color_management);
782 }
783
784 static void texture_nodes_fetch_images_for_pool(Tex *texture,
785                                                 bNodeTree *ntree,
786                                                 struct ImagePool *pool)
787 {
788   for (bNode *node = ntree->nodes.first; node; node = node->next) {
789     if (node->type == SH_NODE_TEX_IMAGE && node->id != NULL) {
790       Image *image = (Image *)node->id;
791       BKE_image_pool_acquire_ibuf(image, &texture->iuser, pool);
792     }
793     else if (node->type == NODE_GROUP && node->id != NULL) {
794       /* TODO(sergey): Do we need to control recursion here? */
795       bNodeTree *nested_tree = (bNodeTree *)node->id;
796       texture_nodes_fetch_images_for_pool(texture, nested_tree, pool);
797     }
798   }
799 }
800
801 /* Make sure all images used by texture are loaded into pool. */
802 void BKE_texture_fetch_images_for_pool(Tex *texture, struct ImagePool *pool)
803 {
804   if (texture->nodetree != NULL) {
805     texture_nodes_fetch_images_for_pool(texture, texture->nodetree, pool);
806   }
807   else {
808     if (texture->type == TEX_IMAGE) {
809       if (texture->ima != NULL) {
810         BKE_image_pool_acquire_ibuf(texture->ima, &texture->iuser, pool);
811       }
812     }
813   }
814 }