Fix T53032: Image sequence works bad with Displace modifier
[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_lamp_types.h"
48 #include "DNA_material_types.h"
49 #include "DNA_world_types.h"
50 #include "DNA_brush_types.h"
51 #include "DNA_node_types.h"
52 #include "DNA_color_types.h"
53 #include "DNA_particle_types.h"
54 #include "DNA_linestyle_types.h"
55
56 #include "IMB_imbuf.h"
57
58 #include "BKE_global.h"
59 #include "BKE_main.h"
60
61 #include "BKE_colorband.h"
62 #include "BKE_library.h"
63 #include "BKE_library_query.h"
64 #include "BKE_library_remap.h"
65 #include "BKE_image.h"
66 #include "BKE_material.h"
67 #include "BKE_texture.h"
68 #include "BKE_key.h"
69 #include "BKE_icons.h"
70 #include "BKE_node.h"
71 #include "BKE_animsys.h"
72 #include "BKE_colortools.h"
73 #include "BKE_scene.h"
74
75 #include "RE_shader_ext.h"
76
77 /* ****************** Mapping ******************* */
78
79 TexMapping *BKE_texture_mapping_add(int type)
80 {
81         TexMapping *texmap = MEM_callocN(sizeof(TexMapping), "TexMapping");
82         
83         BKE_texture_mapping_default(texmap, type);
84         
85         return texmap;
86 }
87
88 void BKE_texture_mapping_default(TexMapping *texmap, int type)
89 {
90         memset(texmap, 0, sizeof(TexMapping));
91
92         texmap->size[0] = texmap->size[1] = texmap->size[2] = 1.0f;
93         texmap->max[0] = texmap->max[1] = texmap->max[2] = 1.0f;
94         unit_m4(texmap->mat);
95
96         texmap->projx = PROJ_X;
97         texmap->projy = PROJ_Y;
98         texmap->projz = PROJ_Z;
99         texmap->mapping = MTEX_FLAT;
100         texmap->type = type;
101 }
102
103 void BKE_texture_mapping_init(TexMapping *texmap)
104 {
105         float smat[4][4], rmat[4][4], tmat[4][4], proj[4][4], size[3];
106
107         if (texmap->projx == PROJ_X && texmap->projy == PROJ_Y && texmap->projz == PROJ_Z &&
108             is_zero_v3(texmap->loc) && is_zero_v3(texmap->rot) && is_one_v3(texmap->size))
109         {
110                 unit_m4(texmap->mat);
111
112                 texmap->flag |= TEXMAP_UNIT_MATRIX;
113         }
114         else {
115                 /* axis projection */
116                 zero_m4(proj);
117                 proj[3][3] = 1.0f;
118
119                 if (texmap->projx != PROJ_N)
120                         proj[texmap->projx - 1][0] = 1.0f;
121                 if (texmap->projy != PROJ_N)
122                         proj[texmap->projy - 1][1] = 1.0f;
123                 if (texmap->projz != PROJ_N)
124                         proj[texmap->projz - 1][2] = 1.0f;
125
126                 /* scale */
127                 copy_v3_v3(size, texmap->size);
128
129                 if (ELEM(texmap->type, TEXMAP_TYPE_TEXTURE, TEXMAP_TYPE_NORMAL)) {
130                         /* keep matrix invertible */
131                         if (fabsf(size[0]) < 1e-5f)
132                                 size[0] = signf(size[0]) * 1e-5f;
133                         if (fabsf(size[1]) < 1e-5f)
134                                 size[1] = signf(size[1]) * 1e-5f;
135                         if (fabsf(size[2]) < 1e-5f)
136                                 size[2] = signf(size[2]) * 1e-5f;
137                 }
138                 
139                 size_to_mat4(smat, texmap->size);
140
141                 /* rotation */
142                 eul_to_mat4(rmat, texmap->rot);
143
144                 /* translation */
145                 unit_m4(tmat);
146                 copy_v3_v3(tmat[3], texmap->loc);
147
148                 if (texmap->type == TEXMAP_TYPE_TEXTURE) {
149                         /* to transform a texture, the inverse transform needs
150                          * to be applied to the texture coordinate */
151                         mul_m4_series(texmap->mat, tmat, rmat, smat);
152                         invert_m4(texmap->mat);
153                 }
154                 else if (texmap->type == TEXMAP_TYPE_POINT) {
155                         /* forward transform */
156                         mul_m4_series(texmap->mat, tmat, rmat, smat);
157                 }
158                 else if (texmap->type == TEXMAP_TYPE_VECTOR) {
159                         /* no translation for vectors */
160                         mul_m4_m4m4(texmap->mat, rmat, smat);
161                 }
162                 else if (texmap->type == TEXMAP_TYPE_NORMAL) {
163                         /* no translation for normals, and inverse transpose */
164                         mul_m4_m4m4(texmap->mat, rmat, smat);
165                         invert_m4(texmap->mat);
166                         transpose_m4(texmap->mat);
167                 }
168
169                 /* projection last */
170                 mul_m4_m4m4(texmap->mat, texmap->mat, proj);
171
172                 texmap->flag &= ~TEXMAP_UNIT_MATRIX;
173         }
174 }
175
176 ColorMapping *BKE_texture_colormapping_add(void)
177 {
178         ColorMapping *colormap = MEM_callocN(sizeof(ColorMapping), "ColorMapping");
179         
180         BKE_texture_colormapping_default(colormap);
181         
182         return colormap;
183 }
184
185 void BKE_texture_colormapping_default(ColorMapping *colormap)
186 {
187         memset(colormap, 0, sizeof(ColorMapping));
188
189         BKE_colorband_init(&colormap->coba, true);
190
191         colormap->bright = 1.0;
192         colormap->contrast = 1.0;
193         colormap->saturation = 1.0;
194
195         colormap->blend_color[0] = 0.8f;
196         colormap->blend_color[1] = 0.8f;
197         colormap->blend_color[2] = 0.8f;
198         colormap->blend_type = MA_RAMP_BLEND;
199         colormap->blend_factor = 0.0f;
200 }
201
202 /* ******************* TEX ************************ */
203
204 /** Free (or release) any data used by this texture (does not free the texure itself). */
205 void BKE_texture_free(Tex *tex)
206 {
207         BKE_animdata_free((ID *)tex, false);
208
209         /* is no lib link block, but texture extension */
210         if (tex->nodetree) {
211                 ntreeFreeTree(tex->nodetree);
212                 MEM_freeN(tex->nodetree);
213                 tex->nodetree = NULL;
214         }
215
216         MEM_SAFE_FREE(tex->coba);
217         if (tex->env) {
218                 BKE_texture_envmap_free(tex->env);
219                 tex->env = NULL;
220         }
221         if (tex->pd) {
222                 BKE_texture_pointdensity_free(tex->pd);
223                 tex->pd = NULL;
224         }
225         if (tex->vd) {
226                 BKE_texture_voxeldata_free(tex->vd);
227                 tex->vd = NULL;
228         }
229         if (tex->ot) {
230                 BKE_texture_ocean_free(tex->ot);
231                 tex->ot = NULL;
232         }
233         
234         BKE_icon_id_delete((ID *)tex);
235         BKE_previewimg_free(&tex->preview);
236 }
237
238 /* ------------------------------------------------------------------------- */
239
240 void BKE_texture_default(Tex *tex)
241 {
242         /* BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(tex, id)); */  /* Not here, can be called with some pointers set. :/ */
243
244         tex->type = TEX_IMAGE;
245         tex->ima = NULL;
246         tex->stype = 0;
247         tex->flag = TEX_CHECKER_ODD;
248         tex->imaflag = TEX_INTERPOL | TEX_MIPMAP | TEX_USEALPHA;
249         tex->extend = TEX_REPEAT;
250         tex->cropxmin = tex->cropymin = 0.0;
251         tex->cropxmax = tex->cropymax = 1.0;
252         tex->texfilter = TXF_EWA;
253         tex->afmax = 8;
254         tex->xrepeat = tex->yrepeat = 1;
255         tex->fie_ima = 2;
256         tex->sfra = 1;
257         tex->frames = 0;
258         tex->offset = 0;
259         tex->noisesize = 0.25;
260         tex->noisedepth = 2;
261         tex->turbul = 5.0;
262         tex->nabla = 0.025;  // also in do_versions
263         tex->bright = 1.0;
264         tex->contrast = 1.0;
265         tex->saturation = 1.0;
266         tex->filtersize = 1.0;
267         tex->rfac = 1.0;
268         tex->gfac = 1.0;
269         tex->bfac = 1.0;
270         /* newnoise: init. */
271         tex->noisebasis = 0;
272         tex->noisebasis2 = 0;
273         /* musgrave */
274         tex->mg_H = 1.0;
275         tex->mg_lacunarity = 2.0;
276         tex->mg_octaves = 2.0;
277         tex->mg_offset = 1.0;
278         tex->mg_gain = 1.0;
279         tex->ns_outscale = 1.0;
280         /* distnoise */
281         tex->dist_amount = 1.0;
282         /* voronoi */
283         tex->vn_w1 = 1.0;
284         tex->vn_w2 = tex->vn_w3 = tex->vn_w4 = 0.0;
285         tex->vn_mexp = 2.5;
286         tex->vn_distm = 0;
287         tex->vn_coltype = 0;
288
289         if (tex->env) {
290                 tex->env->stype = ENV_ANIM;
291                 tex->env->clipsta = 0.1;
292                 tex->env->clipend = 100;
293                 tex->env->cuberes = 512;
294                 tex->env->depth = 0;
295         }
296
297         if (tex->pd) {
298                 tex->pd->radius = 0.3f;
299                 tex->pd->falloff_type = TEX_PD_FALLOFF_STD;
300         }
301         
302         if (tex->vd) {
303                 tex->vd->resol[0] = tex->vd->resol[1] = tex->vd->resol[2] = 0;
304                 tex->vd->interp_type = TEX_VD_LINEAR;
305                 tex->vd->file_format = TEX_VD_SMOKE;
306         }
307         
308         if (tex->ot) {
309                 tex->ot->output = TEX_OCN_DISPLACEMENT;
310                 tex->ot->object = NULL;
311         }
312         
313         tex->iuser.fie_ima = 2;
314         tex->iuser.ok = 1;
315         tex->iuser.frames = 100;
316         tex->iuser.sfra = 1;
317         
318         tex->preview = NULL;
319 }
320
321 void BKE_texture_type_set(Tex *tex, int type)
322 {
323         switch (type) {
324                         
325                 case TEX_VOXELDATA:
326                         if (tex->vd == NULL)
327                                 tex->vd = BKE_texture_voxeldata_add();
328                         break;
329                 case TEX_POINTDENSITY:
330                         if (tex->pd == NULL)
331                                 tex->pd = BKE_texture_pointdensity_add();
332                         break;
333                 case TEX_ENVMAP:
334                         if (tex->env == NULL)
335                                 tex->env = BKE_texture_envmap_add();
336                         break;
337                 case TEX_OCEAN:
338                         if (tex->ot == NULL)
339                                 tex->ot = BKE_texture_ocean_add();
340                         break;
341         }
342         
343         tex->type = type;
344 }
345
346 /* ------------------------------------------------------------------------- */
347
348 Tex *BKE_texture_add(Main *bmain, const char *name)
349 {
350         Tex *tex;
351
352         tex = BKE_libblock_alloc(bmain, ID_TE, name, 0);
353         
354         BKE_texture_default(tex);
355         
356         return tex;
357 }
358
359 /* ------------------------------------------------------------------------- */
360
361 void BKE_texture_mtex_default(MTex *mtex)
362 {
363         mtex->texco = TEXCO_UV;
364         mtex->mapto = MAP_COL;
365         mtex->object = NULL;
366         mtex->projx = PROJ_X;
367         mtex->projy = PROJ_Y;
368         mtex->projz = PROJ_Z;
369         mtex->mapping = MTEX_FLAT;
370         mtex->ofs[0] = 0.0;
371         mtex->ofs[1] = 0.0;
372         mtex->ofs[2] = 0.0;
373         mtex->size[0] = 1.0;
374         mtex->size[1] = 1.0;
375         mtex->size[2] = 1.0;
376         mtex->tex = NULL;
377         mtex->texflag = MTEX_3TAP_BUMP | MTEX_BUMP_OBJECTSPACE | MTEX_MAPTO_BOUNDS;
378         mtex->colormodel = 0;
379         mtex->r = 1.0;
380         mtex->g = 0.0;
381         mtex->b = 1.0;
382         mtex->k = 1.0;
383         mtex->def_var = 1.0;
384         mtex->blendtype = MTEX_BLEND;
385         mtex->colfac = 1.0;
386         mtex->norfac = 1.0;
387         mtex->varfac = 1.0;
388         mtex->dispfac = 0.2;
389         mtex->colspecfac = 1.0f;
390         mtex->mirrfac = 1.0f;
391         mtex->alphafac = 1.0f;
392         mtex->difffac = 1.0f;
393         mtex->specfac = 1.0f;
394         mtex->emitfac = 1.0f;
395         mtex->hardfac = 1.0f;
396         mtex->raymirrfac = 1.0f;
397         mtex->translfac = 1.0f;
398         mtex->ambfac = 1.0f;
399         mtex->colemitfac = 1.0f;
400         mtex->colreflfac = 1.0f;
401         mtex->coltransfac = 1.0f;
402         mtex->densfac = 1.0f;
403         mtex->scatterfac = 1.0f;
404         mtex->reflfac = 1.0f;
405         mtex->shadowfac = 1.0f;
406         mtex->zenupfac = 1.0f;
407         mtex->zendownfac = 1.0f;
408         mtex->blendfac = 1.0f;
409         mtex->timefac = 1.0f;
410         mtex->lengthfac = 1.0f;
411         mtex->clumpfac = 1.0f;
412         mtex->kinkfac = 1.0f;
413         mtex->kinkampfac = 1.0f;
414         mtex->roughfac = 1.0f;
415         mtex->twistfac = 1.0f;
416         mtex->padensfac = 1.0f;
417         mtex->lifefac = 1.0f;
418         mtex->sizefac = 1.0f;
419         mtex->ivelfac = 1.0f;
420         mtex->dampfac = 1.0f;
421         mtex->gravityfac = 1.0f;
422         mtex->fieldfac = 1.0f;
423         mtex->normapspace = MTEX_NSPACE_TANGENT;
424         mtex->brush_map_mode = MTEX_MAP_MODE_TILED;
425         mtex->random_angle = 2.0f * (float)M_PI;
426         mtex->brush_angle_mode = 0;
427 }
428
429
430 /* ------------------------------------------------------------------------- */
431
432 MTex *BKE_texture_mtex_add(void)
433 {
434         MTex *mtex;
435         
436         mtex = MEM_callocN(sizeof(MTex), "BKE_texture_mtex_add");
437         
438         BKE_texture_mtex_default(mtex);
439         
440         return mtex;
441 }
442
443 /* slot -1 for first free ID */
444 MTex *BKE_texture_mtex_add_id(ID *id, int slot)
445 {
446         MTex **mtex_ar;
447         short act;
448
449         give_active_mtex(id, &mtex_ar, &act);
450
451         if (mtex_ar == NULL) {
452                 return NULL;
453         }
454         
455         if (slot == -1) {
456                 /* find first free */
457                 int i;
458                 for (i = 0; i < MAX_MTEX; i++) {
459                         if (!mtex_ar[i]) {
460                                 slot = i;
461                                 break;
462                         }
463                 }
464                 if (slot == -1) {
465                         return NULL;
466                 }
467         }
468         else {
469                 /* make sure slot is valid */
470                 if (slot < 0 || slot >= MAX_MTEX) {
471                         return NULL;
472                 }
473         }
474
475         if (mtex_ar[slot]) {
476                 id_us_min((ID *)mtex_ar[slot]->tex);
477                 MEM_freeN(mtex_ar[slot]);
478                 mtex_ar[slot] = NULL;
479         }
480         else if (GS(id->name) == ID_MA) {
481                 /* Reset this slot's ON/OFF toggle, for materials, when slot was empty. */
482                 ((Material *)id)->septex &= ~(1 << slot);
483         }
484
485         mtex_ar[slot] = BKE_texture_mtex_add();
486
487         return mtex_ar[slot];
488 }
489
490 /* ------------------------------------------------------------------------- */
491
492 /**
493  * Only copy internal data of Texture ID from source to already allocated/initialized destination.
494  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
495  *
496  * WARNING! This function will not handle ID user count!
497  *
498  * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
499  */
500 void BKE_texture_copy_data(Main *bmain, Tex *tex_dst, const Tex *tex_src, const int flag)
501 {
502         /* We never handle usercount here for own data. */
503         const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
504
505         if (!BKE_texture_is_image_user(tex_src)) {
506                 tex_dst->ima = NULL;
507         }
508
509         if (tex_dst->coba) {
510                 tex_dst->coba = MEM_dupallocN(tex_dst->coba);
511         }
512         if (tex_dst->env) {
513                 tex_dst->env = BKE_texture_envmap_copy(tex_dst->env, flag_subdata);
514         }
515         if (tex_dst->pd) {
516                 tex_dst->pd = BKE_texture_pointdensity_copy(tex_dst->pd, flag_subdata);
517         }
518         if (tex_dst->vd) {
519                 tex_dst->vd = MEM_dupallocN(tex_dst->vd);
520         }
521         if (tex_dst->ot) {
522                 tex_dst->ot = BKE_texture_ocean_copy(tex_dst->ot, flag_subdata);
523         }
524
525         if (tex_src->nodetree) {
526                 if (tex_src->nodetree->execdata) {
527                         ntreeTexEndExecTree(tex_src->nodetree->execdata);
528                 }
529                 /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
530                  *       (see BKE_libblock_copy_ex()). */
531                 BKE_id_copy_ex(bmain, (ID *)tex_src->nodetree, (ID **)&tex_dst->nodetree, flag, false);
532         }
533
534         if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
535                 BKE_previewimg_id_copy(&tex_dst->id, &tex_src->id);
536         }
537         else {
538                 tex_dst->preview = NULL;
539         }
540 }
541
542 Tex *BKE_texture_copy(Main *bmain, const Tex *tex)
543 {
544         Tex *tex_copy;
545         BKE_id_copy_ex(bmain, &tex->id, (ID **)&tex_copy, 0, false);
546         return tex_copy;
547 }
548
549 /* texture copy without adding to main dbase */
550 Tex *BKE_texture_localize(Tex *tex)
551 {
552         /* TODO replace with something like
553          *      Tex *tex_copy;
554          *      BKE_id_copy_ex(bmain, &tex->id, (ID **)&tex_copy, LIB_ID_COPY_NO_MAIN | LIB_ID_COPY_NO_PREVIEW | LIB_ID_COPY_NO_USER_REFCOUNT, false);
555          *      return tex_copy;
556          *
557          * ... Once f*** nodes are fully converted to that too :( */
558
559         Tex *texn;
560         
561         texn = BKE_libblock_copy_nolib(&tex->id, false);
562         
563         /* image texture: BKE_texture_free also doesn't decrease */
564         
565         if (texn->coba) texn->coba = MEM_dupallocN(texn->coba);
566         if (texn->env) {
567                 texn->env = BKE_texture_envmap_copy(texn->env, LIB_ID_CREATE_NO_USER_REFCOUNT);
568                 id_us_min(&texn->env->ima->id);
569         }
570         if (texn->pd) texn->pd = BKE_texture_pointdensity_copy(texn->pd, LIB_ID_CREATE_NO_USER_REFCOUNT);
571         if (texn->vd) {
572                 texn->vd = MEM_dupallocN(texn->vd);
573                 if (texn->vd->dataset)
574                         texn->vd->dataset = MEM_dupallocN(texn->vd->dataset);
575         }
576         if (texn->ot) {
577                 texn->ot = BKE_texture_ocean_copy(tex->ot, LIB_ID_CREATE_NO_USER_REFCOUNT);
578         }
579         
580         texn->preview = NULL;
581         
582         if (tex->nodetree) {
583                 texn->nodetree = ntreeLocalize(tex->nodetree);
584         }
585         
586         return texn;
587 }
588
589
590 /* ------------------------------------------------------------------------- */
591
592 void BKE_texture_make_local(Main *bmain, Tex *tex, const bool lib_local)
593 {
594         BKE_id_make_local_generic(bmain, &tex->id, true, lib_local);
595 }
596
597 Tex *give_current_object_texture(Object *ob)
598 {
599         Material *ma, *node_ma;
600         Tex *tex = NULL;
601         
602         if (ob == NULL) return NULL;
603         if (ob->totcol == 0 && !(ob->type == OB_LAMP)) return NULL;
604         
605         if (ob->type == OB_LAMP) {
606                 tex = give_current_lamp_texture(ob->data);
607         }
608         else {
609                 ma = give_current_material(ob, ob->actcol);
610
611                 if ((node_ma = give_node_material(ma)))
612                         ma = node_ma;
613
614                 tex = give_current_material_texture(ma);
615         }
616         
617         return tex;
618 }
619
620 Tex *give_current_lamp_texture(Lamp *la)
621 {
622         MTex *mtex = NULL;
623         Tex *tex = NULL;
624
625         if (la) {
626                 mtex = la->mtex[(int)(la->texact)];
627                 if (mtex) tex = mtex->tex;
628         }
629
630         return tex;
631 }
632
633 void set_current_lamp_texture(Lamp *la, Tex *newtex)
634 {
635         int act = la->texact;
636
637         if (la->mtex[act] && la->mtex[act]->tex)
638                 id_us_min(&la->mtex[act]->tex->id);
639
640         if (newtex) {
641                 if (!la->mtex[act]) {
642                         la->mtex[act] = BKE_texture_mtex_add();
643                         la->mtex[act]->texco = TEXCO_GLOB;
644                 }
645                 
646                 la->mtex[act]->tex = newtex;
647                 id_us_plus(&newtex->id);
648         }
649         else if (la->mtex[act]) {
650                 MEM_freeN(la->mtex[act]);
651                 la->mtex[act] = NULL;
652         }
653 }
654
655 Tex *give_current_linestyle_texture(FreestyleLineStyle *linestyle)
656 {
657         MTex *mtex = NULL;
658         Tex *tex = NULL;
659
660         if (linestyle) {
661                 mtex = linestyle->mtex[(int)(linestyle->texact)];
662                 if (mtex) tex = mtex->tex;
663         }
664
665         return tex;
666 }
667
668 void set_current_linestyle_texture(FreestyleLineStyle *linestyle, Tex *newtex)
669 {
670         int act = linestyle->texact;
671
672         if (linestyle->mtex[act] && linestyle->mtex[act]->tex)
673                 id_us_min(&linestyle->mtex[act]->tex->id);
674
675         if (newtex) {
676                 if (!linestyle->mtex[act]) {
677                         linestyle->mtex[act] = BKE_texture_mtex_add();
678                         linestyle->mtex[act]->texco = TEXCO_STROKE;
679                 }
680
681                 linestyle->mtex[act]->tex = newtex;
682                 id_us_plus(&newtex->id);
683         }
684         else if (linestyle->mtex[act]) {
685                 MEM_freeN(linestyle->mtex[act]);
686                 linestyle->mtex[act] = NULL;
687         }
688 }
689
690 bNode *give_current_material_texture_node(Material *ma)
691 {
692         if (ma && ma->use_nodes && ma->nodetree)
693                 return nodeGetActiveID(ma->nodetree, ID_TE);
694         
695         return NULL;
696 }
697
698 Tex *give_current_material_texture(Material *ma)
699 {
700         MTex *mtex = NULL;
701         Tex *tex = NULL;
702         bNode *node;
703         
704         if (ma && ma->use_nodes && ma->nodetree) {
705                 /* first check texture, then material, this works together
706                  * with a hack that clears the active ID flag for textures on
707                  * making a material node active */
708                 node = nodeGetActiveID(ma->nodetree, ID_TE);
709
710                 if (node) {
711                         tex = (Tex *)node->id;
712                         ma = NULL;
713                 }
714         }
715
716         if (ma) {
717                 mtex = ma->mtex[(int)(ma->texact)];
718                 if (mtex) tex = mtex->tex;
719         }
720         
721         return tex;
722 }
723
724 bool give_active_mtex(ID *id, MTex ***mtex_ar, short *act)
725 {
726         switch (GS(id->name)) {
727                 case ID_MA:
728                         *mtex_ar =       ((Material *)id)->mtex;
729                         if (act) *act =  (((Material *)id)->texact);
730                         break;
731                 case ID_WO:
732                         *mtex_ar =       ((World *)id)->mtex;
733                         if (act) *act =  (((World *)id)->texact);
734                         break;
735                 case ID_LA:
736                         *mtex_ar =       ((Lamp *)id)->mtex;
737                         if (act) *act =  (((Lamp *)id)->texact);
738                         break;
739                 case ID_LS:
740                         *mtex_ar =       ((FreestyleLineStyle *)id)->mtex;
741                         if (act) *act =  (((FreestyleLineStyle *)id)->texact);
742                         break;
743                 case ID_PA:
744                         *mtex_ar =       ((ParticleSettings *)id)->mtex;
745                         if (act) *act =  (((ParticleSettings *)id)->texact);
746                         break;
747                 default:
748                         *mtex_ar = NULL;
749                         if (act) *act =  0;
750                         return false;
751         }
752
753         return true;
754 }
755
756 void set_active_mtex(ID *id, short act)
757 {
758         if (act < 0) act = 0;
759         else if (act >= MAX_MTEX) act = MAX_MTEX - 1;
760
761         switch (GS(id->name)) {
762                 case ID_MA:
763                         ((Material *)id)->texact = act;
764                         break;
765                 case ID_WO:
766                         ((World *)id)->texact = act;
767                         break;
768                 case ID_LA:
769                         ((Lamp *)id)->texact = act;
770                         break;
771                 case ID_LS:
772                         ((FreestyleLineStyle *)id)->texact = act;
773                         break;
774                 case ID_PA:
775                         ((ParticleSettings *)id)->texact = act;
776                         break;
777                 default:
778                         break;
779         }
780 }
781
782 void set_current_material_texture(Material *ma, Tex *newtex)
783 {
784         Tex *tex = NULL;
785         bNode *node;
786
787         if ((ma->use_nodes && ma->nodetree) &&
788             (node = nodeGetActiveID(ma->nodetree, ID_TE)))
789         {
790                 tex = (Tex *)node->id;
791                 id_us_min(&tex->id);
792                 if (newtex) {
793                         node->id = &newtex->id;
794                         id_us_plus(&newtex->id);
795                 }
796                 else {
797                         node->id = NULL;
798                 }
799         }
800         else {
801                 int act = (int)ma->texact;
802
803                 tex = (ma->mtex[act]) ? ma->mtex[act]->tex : NULL;
804                 id_us_min(&tex->id);
805
806                 if (newtex) {
807                         if (!ma->mtex[act]) {
808                                 ma->mtex[act] = BKE_texture_mtex_add();
809                                 /* Reset this slot's ON/OFF toggle, for materials, when slot was empty. */
810                                 ma->septex &= ~(1 << act);
811                                 /* For volumes the default UV texture coordinates are not available. */
812                                 if (ma->material_type == MA_TYPE_VOLUME) {
813                                         ma->mtex[act]->texco = TEXCO_ORCO;
814                                 }
815                         }
816                         
817                         ma->mtex[act]->tex = newtex;
818                         id_us_plus(&newtex->id);
819                 }
820                 else if (ma->mtex[act]) {
821                         MEM_freeN(ma->mtex[act]);
822                         ma->mtex[act] = NULL;
823                 }
824         }
825 }
826
827 bool has_current_material_texture(Material *ma)
828 {
829         bNode *node;
830
831         if (ma && ma->use_nodes && ma->nodetree) {
832                 node = nodeGetActiveID(ma->nodetree, ID_TE);
833
834                 if (node)
835                         return true;
836         }
837
838         return (ma != NULL);
839 }
840
841 Tex *give_current_world_texture(World *world)
842 {
843         MTex *mtex = NULL;
844         Tex *tex = NULL;
845         
846         if (!world) return NULL;
847         
848         mtex = world->mtex[(int)(world->texact)];
849         if (mtex) tex = mtex->tex;
850         
851         return tex;
852 }
853
854 void set_current_world_texture(World *wo, Tex *newtex)
855 {
856         int act = wo->texact;
857
858         if (wo->mtex[act] && wo->mtex[act]->tex)
859                 id_us_min(&wo->mtex[act]->tex->id);
860
861         if (newtex) {
862                 if (!wo->mtex[act]) {
863                         wo->mtex[act] = BKE_texture_mtex_add();
864                         wo->mtex[act]->texco = TEXCO_VIEW;
865                 }
866                 
867                 wo->mtex[act]->tex = newtex;
868                 id_us_plus(&newtex->id);
869         }
870         else if (wo->mtex[act]) {
871                 MEM_freeN(wo->mtex[act]);
872                 wo->mtex[act] = NULL;
873         }
874 }
875
876 Tex *give_current_brush_texture(Brush *br)
877 {
878         return br->mtex.tex;
879 }
880
881 void set_current_brush_texture(Brush *br, Tex *newtex)
882 {
883         if (br->mtex.tex)
884                 id_us_min(&br->mtex.tex->id);
885
886         if (newtex) {
887                 br->mtex.tex = newtex;
888                 id_us_plus(&newtex->id);
889         }
890 }
891
892 Tex *give_current_particle_texture(ParticleSettings *part)
893 {
894         MTex *mtex = NULL;
895         Tex *tex = NULL;
896         
897         if (!part) return NULL;
898         
899         mtex = part->mtex[(int)(part->texact)];
900         if (mtex) tex = mtex->tex;
901         
902         return tex;
903 }
904
905 void set_current_particle_texture(ParticleSettings *part, Tex *newtex)
906 {
907         int act = part->texact;
908
909         if (part->mtex[act] && part->mtex[act]->tex)
910                 id_us_min(&part->mtex[act]->tex->id);
911
912         if (newtex) {
913                 if (!part->mtex[act]) {
914                         part->mtex[act] = BKE_texture_mtex_add();
915                         part->mtex[act]->texco = TEXCO_ORCO;
916                         part->mtex[act]->blendtype = MTEX_MUL;
917                 }
918                 
919                 part->mtex[act]->tex = newtex;
920                 id_us_plus(&newtex->id);
921         }
922         else if (part->mtex[act]) {
923                 MEM_freeN(part->mtex[act]);
924                 part->mtex[act] = NULL;
925         }
926 }
927
928 /* ------------------------------------------------------------------------- */
929
930 EnvMap *BKE_texture_envmap_add(void)
931 {
932         EnvMap *env;
933         
934         env = MEM_callocN(sizeof(EnvMap), "envmap");
935         env->type = ENV_CUBE;
936         env->stype = ENV_ANIM;
937         env->clipsta = 0.1;
938         env->clipend = 100.0;
939         env->cuberes = 512;
940         env->viewscale = 0.5;
941         
942         return env;
943
944
945 /* ------------------------------------------------------------------------- */
946
947 EnvMap *BKE_texture_envmap_copy(const EnvMap *env, const int flag)
948 {
949         EnvMap *envn;
950         int a;
951         
952         envn = MEM_dupallocN(env);
953         envn->ok = 0;
954         for (a = 0; a < 6; a++) {
955                 envn->cube[a] = NULL;
956         }
957         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
958                 id_us_plus((ID *)envn->ima);
959         }
960
961         return envn;
962 }
963
964 /* ------------------------------------------------------------------------- */
965
966 void BKE_texture_envmap_free_data(EnvMap *env)
967 {
968         unsigned int part;
969         
970         for (part = 0; part < 6; part++) {
971                 if (env->cube[part])
972                         IMB_freeImBuf(env->cube[part]);
973                 env->cube[part] = NULL;
974         }
975         env->ok = 0;
976 }
977
978 /* ------------------------------------------------------------------------- */
979
980 void BKE_texture_envmap_free(EnvMap *env)
981 {
982         
983         BKE_texture_envmap_free_data(env);
984         MEM_freeN(env);
985         
986 }
987
988 /* ------------------------------------------------------------------------- */
989
990 void BKE_texture_pointdensity_init_data(PointDensity *pd)
991 {
992         pd->flag = 0;
993         pd->radius = 0.3f;
994         pd->falloff_type = TEX_PD_FALLOFF_STD;
995         pd->falloff_softness = 2.0;
996         pd->source = TEX_PD_PSYS;
997         pd->point_tree = NULL;
998         pd->point_data = NULL;
999         pd->noise_size = 0.5f;
1000         pd->noise_depth = 1;
1001         pd->noise_fac = 1.0f;
1002         pd->noise_influence = TEX_PD_NOISE_STATIC;
1003         pd->coba = BKE_colorband_add(true);
1004         pd->speed_scale = 1.0f;
1005         pd->totpoints = 0;
1006         pd->object = NULL;
1007         pd->psys = 0;
1008         pd->psys_cache_space = TEX_PD_WORLDSPACE;
1009         pd->falloff_curve = curvemapping_add(1, 0, 0, 1, 1);
1010
1011         pd->falloff_curve->preset = CURVE_PRESET_LINE;
1012         pd->falloff_curve->cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1013         curvemap_reset(pd->falloff_curve->cm, &pd->falloff_curve->clipr, pd->falloff_curve->preset, CURVEMAP_SLOPE_POSITIVE);
1014         curvemapping_changed(pd->falloff_curve, false);
1015 }
1016
1017 PointDensity *BKE_texture_pointdensity_add(void)
1018 {
1019         PointDensity *pd = MEM_callocN(sizeof(PointDensity), "pointdensity");
1020         BKE_texture_pointdensity_init_data(pd);
1021         return pd;
1022
1023
1024 PointDensity *BKE_texture_pointdensity_copy(const PointDensity *pd, const int UNUSED(flag))
1025 {
1026         PointDensity *pdn;
1027
1028         pdn = MEM_dupallocN(pd);
1029         pdn->point_tree = NULL;
1030         pdn->point_data = NULL;
1031         if (pdn->coba) {
1032                 pdn->coba = MEM_dupallocN(pdn->coba);
1033         }
1034         pdn->falloff_curve = curvemapping_copy(pdn->falloff_curve); /* can be NULL */
1035         return pdn;
1036 }
1037
1038 void BKE_texture_pointdensity_free_data(PointDensity *pd)
1039 {
1040         if (pd->point_tree) {
1041                 BLI_bvhtree_free(pd->point_tree);
1042                 pd->point_tree = NULL;
1043         }
1044         if (pd->point_data) {
1045                 MEM_freeN(pd->point_data);
1046                 pd->point_data = NULL;
1047         }
1048         if (pd->coba) {
1049                 MEM_freeN(pd->coba);
1050                 pd->coba = NULL;
1051         }
1052
1053         curvemapping_free(pd->falloff_curve); /* can be NULL */
1054 }
1055
1056 void BKE_texture_pointdensity_free(PointDensity *pd)
1057 {
1058         BKE_texture_pointdensity_free_data(pd);
1059         MEM_freeN(pd);
1060 }
1061
1062 /* ------------------------------------------------------------------------- */
1063
1064 void BKE_texture_voxeldata_free_data(VoxelData *vd)
1065 {
1066         if (vd->dataset) {
1067                 MEM_freeN(vd->dataset);
1068                 vd->dataset = NULL;
1069         }
1070
1071 }
1072  
1073 void BKE_texture_voxeldata_free(VoxelData *vd)
1074 {
1075         BKE_texture_voxeldata_free_data(vd);
1076         MEM_freeN(vd);
1077 }
1078  
1079 VoxelData *BKE_texture_voxeldata_add(void)
1080 {
1081         VoxelData *vd;
1082
1083         vd = MEM_callocN(sizeof(VoxelData), "voxeldata");
1084         vd->dataset = NULL;
1085         vd->resol[0] = vd->resol[1] = vd->resol[2] = 1;
1086         vd->interp_type = TEX_VD_LINEAR;
1087         vd->file_format = TEX_VD_SMOKE;
1088         vd->int_multiplier = 1.0;
1089         vd->extend = TEX_CLIP;
1090         vd->object = NULL;
1091         vd->cachedframe = -1;
1092         vd->ok = 0;
1093         
1094         return vd;
1095 }
1096  
1097 VoxelData *BKE_texture_voxeldata_copy(VoxelData *vd)
1098 {
1099         VoxelData *vdn;
1100
1101         vdn = MEM_dupallocN(vd);
1102         vdn->dataset = NULL;
1103
1104         return vdn;
1105 }
1106
1107 /* ------------------------------------------------------------------------- */
1108
1109 OceanTex *BKE_texture_ocean_add(void)
1110 {
1111         OceanTex *ot;
1112         
1113         ot = MEM_callocN(sizeof(struct OceanTex), "ocean texture");
1114         ot->output = TEX_OCN_DISPLACEMENT;
1115         ot->object = NULL;
1116         
1117         return ot;
1118 }
1119
1120 OceanTex *BKE_texture_ocean_copy(const OceanTex *ot, const int UNUSED(flag))
1121 {
1122         OceanTex *otn = MEM_dupallocN(ot);
1123         
1124         return otn;
1125 }
1126
1127 void BKE_texture_ocean_free(struct OceanTex *ot)
1128 {
1129         MEM_freeN(ot);
1130 }
1131
1132 /**
1133  * \returns true if this texture can use its #Texture.ima (even if its NULL)
1134  */
1135 bool BKE_texture_is_image_user(const struct Tex *tex)
1136 {
1137         switch (tex->type) {
1138                 case TEX_IMAGE:
1139                 {
1140                         return true;
1141                 }
1142                 case TEX_ENVMAP:
1143                 {
1144                         if (tex->env) {
1145                                 if (tex->env->stype == ENV_LOAD) {
1146                                         return true;
1147                                 }
1148                         }
1149                         break;
1150                 }
1151         }
1152
1153         return false;
1154 }
1155
1156 /* ------------------------------------------------------------------------- */
1157 bool BKE_texture_dependsOnTime(const struct Tex *texture)
1158 {
1159         if (texture->ima && BKE_image_is_animated(texture->ima)) {
1160                 return true;
1161         }
1162         else if (texture->adt) {
1163                 /* assume anything in adt means the texture is animated */
1164                 return true;
1165         }
1166         else if (texture->type == TEX_NOISE) {
1167                 /* noise always varies with time */
1168                 return true;
1169         }
1170         return false;
1171 }
1172
1173 /* ------------------------------------------------------------------------- */
1174
1175 void BKE_texture_get_value_ex(
1176         const Scene *scene, Tex *texture,
1177         float *tex_co, TexResult *texres,
1178         struct ImagePool *pool,
1179         bool use_color_management)
1180 {
1181         int result_type;
1182         bool do_color_manage = false;
1183
1184         if (scene && use_color_management) {
1185                 do_color_manage = BKE_scene_check_color_management_enabled(scene);
1186         }
1187
1188         /* no node textures for now */
1189         result_type = multitex_ext_safe(texture, tex_co, texres, pool, do_color_manage, false);
1190
1191         /* if the texture gave an RGB value, we assume it didn't give a valid
1192          * intensity, since this is in the context of modifiers don't use perceptual color conversion.
1193          * if the texture didn't give an RGB value, copy the intensity across
1194          */
1195         if (result_type & TEX_RGB) {
1196                 texres->tin = (1.0f / 3.0f) * (texres->tr + texres->tg + texres->tb);
1197         }
1198         else {
1199                 copy_v3_fl(&texres->tr, texres->tin);
1200         }
1201 }
1202
1203 void BKE_texture_get_value(
1204         const Scene *scene, Tex *texture,
1205         float *tex_co, TexResult *texres, bool use_color_management)
1206 {
1207         BKE_texture_get_value_ex(scene, texture, tex_co, texres, NULL, use_color_management);
1208 }
1209
1210 static void texture_nodes_fetch_images_for_pool(Tex *texture, bNodeTree *ntree, struct ImagePool *pool)
1211 {
1212         for (bNode *node = ntree->nodes.first; node; node = node->next) {
1213                 if (node->type == SH_NODE_TEX_IMAGE && node->id != NULL) {
1214                         Image *image = (Image *)node->id;
1215                         BKE_image_pool_acquire_ibuf(image, &texture->iuser, pool);
1216                 }
1217                 else if (node->type == NODE_GROUP && node->id != NULL) {
1218                         /* TODO(sergey): Do we need to control recursion here? */
1219                         bNodeTree *nested_tree = (bNodeTree *)node->id;
1220                         texture_nodes_fetch_images_for_pool(texture, nested_tree, pool);
1221                 }
1222         }
1223 }
1224
1225 /* Make sure all images used by texture are loaded into pool. */
1226 void BKE_texture_fetch_images_for_pool(Tex *texture, struct ImagePool *pool)
1227 {
1228         if (texture->nodetree != NULL) {
1229                 texture_nodes_fetch_images_for_pool(texture, texture->nodetree, pool);
1230         }
1231         else {
1232                 if (texture->type == TEX_IMAGE) {
1233                         if (texture->ima != NULL) {
1234                                 BKE_image_pool_acquire_ibuf(texture->ima, &texture->iuser, pool);
1235                         }
1236                 }
1237         }
1238 }