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