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