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