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