Cleanup: style, use braces for render
[blender.git] / source / blender / render / intern / source / render_texture.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup render
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <math.h>
28
29 #include "BLI_math.h"
30 #include "BLI_noise.h"
31 #include "BLI_rand.h"
32 #include "BLI_utildefines.h"
33
34 #include "DNA_anim_types.h"
35 #include "DNA_texture_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_light_types.h"
38 #include "DNA_meshdata_types.h"
39 #include "DNA_material_types.h"
40 #include "DNA_image_types.h"
41 #include "DNA_node_types.h"
42
43 #include "IMB_imbuf_types.h"
44 #include "IMB_colormanagement.h"
45
46 #include "BKE_image.h"
47 #include "BKE_node.h"
48
49 #include "BKE_animsys.h"
50 #include "BKE_colorband.h"
51 #include "BKE_material.h"
52 #include "BKE_scene.h"
53
54 #include "BKE_texture.h"
55
56 #include "MEM_guardedalloc.h"
57
58 #include "render_types.h"
59 #include "texture.h"
60
61 #include "RE_render_ext.h"
62 #include "RE_shader_ext.h"
63
64 static RNG_THREAD_ARRAY *random_tex_array;
65
66 void RE_texture_rng_init(void)
67 {
68   random_tex_array = BLI_rng_threaded_new();
69 }
70
71 void RE_texture_rng_exit(void)
72 {
73   BLI_rng_threaded_free(random_tex_array);
74 }
75
76 /* ------------------------------------------------------------------------- */
77
78 /* this allows colorbanded textures to control normals as well */
79 static void tex_normal_derivate(Tex *tex, TexResult *texres)
80 {
81   if (tex->flag & TEX_COLORBAND) {
82     float col[4];
83     if (BKE_colorband_evaluate(tex->coba, texres->tin, col)) {
84       float fac0, fac1, fac2, fac3;
85
86       fac0 = (col[0] + col[1] + col[2]);
87       BKE_colorband_evaluate(tex->coba, texres->nor[0], col);
88       fac1 = (col[0] + col[1] + col[2]);
89       BKE_colorband_evaluate(tex->coba, texres->nor[1], col);
90       fac2 = (col[0] + col[1] + col[2]);
91       BKE_colorband_evaluate(tex->coba, texres->nor[2], col);
92       fac3 = (col[0] + col[1] + col[2]);
93
94       texres->nor[0] = (fac0 - fac1) / 3.0f;
95       texres->nor[1] = (fac0 - fac2) / 3.0f;
96       texres->nor[2] = (fac0 - fac3) / 3.0f;
97
98       return;
99     }
100   }
101   texres->nor[0] = texres->tin - texres->nor[0];
102   texres->nor[1] = texres->tin - texres->nor[1];
103   texres->nor[2] = texres->tin - texres->nor[2];
104 }
105
106 static int blend(Tex *tex, const float texvec[3], TexResult *texres)
107 {
108   float x, y, t;
109
110   if (tex->flag & TEX_FLIPBLEND) {
111     x = texvec[1];
112     y = texvec[0];
113   }
114   else {
115     x = texvec[0];
116     y = texvec[1];
117   }
118
119   if (tex->stype == TEX_LIN) { /* lin */
120     texres->tin = (1.0f + x) / 2.0f;
121   }
122   else if (tex->stype == TEX_QUAD) { /* quad */
123     texres->tin = (1.0f + x) / 2.0f;
124     if (texres->tin < 0.0f) {
125       texres->tin = 0.0f;
126     }
127     else {
128       texres->tin *= texres->tin;
129     }
130   }
131   else if (tex->stype == TEX_EASE) { /* ease */
132     texres->tin = (1.0f + x) / 2.0f;
133     if (texres->tin <= 0.0f) {
134       texres->tin = 0.0f;
135     }
136     else if (texres->tin >= 1.0f) {
137       texres->tin = 1.0f;
138     }
139     else {
140       t = texres->tin * texres->tin;
141       texres->tin = (3.0f * t - 2.0f * t * texres->tin);
142     }
143   }
144   else if (tex->stype == TEX_DIAG) { /* diag */
145     texres->tin = (2.0f + x + y) / 4.0f;
146   }
147   else if (tex->stype == TEX_RAD) { /* radial */
148     texres->tin = (atan2f(y, x) / (float)(2 * M_PI) + 0.5f);
149   }
150   else { /* sphere TEX_SPHERE */
151     texres->tin = 1.0f - sqrtf(x * x + y * y + texvec[2] * texvec[2]);
152     if (texres->tin < 0.0f) {
153       texres->tin = 0.0f;
154     }
155     if (tex->stype == TEX_HALO) {
156       texres->tin *= texres->tin; /* halo */
157     }
158   }
159
160   BRICONT;
161
162   return TEX_INT;
163 }
164
165 /* ------------------------------------------------------------------------- */
166 /* ************************************************************************* */
167
168 /* newnoise: all noisebased types now have different noisebases to choose from */
169
170 static int clouds(Tex *tex, const float texvec[3], TexResult *texres)
171 {
172   int rv = TEX_INT;
173
174   texres->tin = BLI_gTurbulence(tex->noisesize,
175                                 texvec[0],
176                                 texvec[1],
177                                 texvec[2],
178                                 tex->noisedepth,
179                                 (tex->noisetype != TEX_NOISESOFT),
180                                 tex->noisebasis);
181
182   if (texres->nor != NULL) {
183     /* calculate bumpnormal */
184     texres->nor[0] = BLI_gTurbulence(tex->noisesize,
185                                      texvec[0] + tex->nabla,
186                                      texvec[1],
187                                      texvec[2],
188                                      tex->noisedepth,
189                                      (tex->noisetype != TEX_NOISESOFT),
190                                      tex->noisebasis);
191     texres->nor[1] = BLI_gTurbulence(tex->noisesize,
192                                      texvec[0],
193                                      texvec[1] + tex->nabla,
194                                      texvec[2],
195                                      tex->noisedepth,
196                                      (tex->noisetype != TEX_NOISESOFT),
197                                      tex->noisebasis);
198     texres->nor[2] = BLI_gTurbulence(tex->noisesize,
199                                      texvec[0],
200                                      texvec[1],
201                                      texvec[2] + tex->nabla,
202                                      tex->noisedepth,
203                                      (tex->noisetype != TEX_NOISESOFT),
204                                      tex->noisebasis);
205
206     tex_normal_derivate(tex, texres);
207     rv |= TEX_NOR;
208   }
209
210   if (tex->stype == TEX_COLOR) {
211     /* in this case, int. value should really be computed from color,
212      * and bumpnormal from that, would be too slow, looks ok as is */
213     texres->tr = texres->tin;
214     texres->tg = BLI_gTurbulence(tex->noisesize,
215                                  texvec[1],
216                                  texvec[0],
217                                  texvec[2],
218                                  tex->noisedepth,
219                                  (tex->noisetype != TEX_NOISESOFT),
220                                  tex->noisebasis);
221     texres->tb = BLI_gTurbulence(tex->noisesize,
222                                  texvec[1],
223                                  texvec[2],
224                                  texvec[0],
225                                  tex->noisedepth,
226                                  (tex->noisetype != TEX_NOISESOFT),
227                                  tex->noisebasis);
228     BRICONTRGB;
229     texres->ta = 1.0;
230     return (rv | TEX_RGB);
231   }
232
233   BRICONT;
234
235   return rv;
236 }
237
238 /* creates a sine wave */
239 static float tex_sin(float a)
240 {
241   a = 0.5f + 0.5f * sinf(a);
242
243   return a;
244 }
245
246 /* creates a saw wave */
247 static float tex_saw(float a)
248 {
249   const float b = 2 * M_PI;
250
251   int n = (int)(a / b);
252   a -= n * b;
253   if (a < 0) {
254     a += b;
255   }
256   return a / b;
257 }
258
259 /* creates a triangle wave */
260 static float tex_tri(float a)
261 {
262   const float b = 2 * M_PI;
263   const float rmax = 1.0;
264
265   a = rmax - 2.0f * fabsf(floorf((a * (1.0f / b)) + 0.5f) - (a * (1.0f / b)));
266
267   return a;
268 }
269
270 /* computes basic wood intensity value at x,y,z */
271 static float wood_int(Tex *tex, float x, float y, float z)
272 {
273   float wi = 0;
274   short wf =
275       tex->noisebasis2; /* wave form:   TEX_SIN=0,  TEX_SAW=1,  TEX_TRI=2                        */
276   short wt =
277       tex->stype; /* wood type:   TEX_BAND=0, TEX_RING=1, TEX_BANDNOISE=2, TEX_RINGNOISE=3 */
278
279   float (*waveform[3])(float); /* create array of pointers to waveform functions */
280   waveform[0] = tex_sin;       /* assign address of tex_sin() function to pointer array */
281   waveform[1] = tex_saw;
282   waveform[2] = tex_tri;
283
284   if ((wf > TEX_TRI) || (wf < TEX_SIN)) {
285     wf = 0; /* check to be sure noisebasis2 is initialized ahead of time */
286   }
287
288   if (wt == TEX_BAND) {
289     wi = waveform[wf]((x + y + z) * 10.0f);
290   }
291   else if (wt == TEX_RING) {
292     wi = waveform[wf](sqrtf(x * x + y * y + z * z) * 20.0f);
293   }
294   else if (wt == TEX_BANDNOISE) {
295     wi = tex->turbul *
296          BLI_gNoise(tex->noisesize, x, y, z, (tex->noisetype != TEX_NOISESOFT), tex->noisebasis);
297     wi = waveform[wf]((x + y + z) * 10.0f + wi);
298   }
299   else if (wt == TEX_RINGNOISE) {
300     wi = tex->turbul *
301          BLI_gNoise(tex->noisesize, x, y, z, (tex->noisetype != TEX_NOISESOFT), tex->noisebasis);
302     wi = waveform[wf](sqrtf(x * x + y * y + z * z) * 20.0f + wi);
303   }
304
305   return wi;
306 }
307
308 static int wood(Tex *tex, const float texvec[3], TexResult *texres)
309 {
310   int rv = TEX_INT;
311
312   texres->tin = wood_int(tex, texvec[0], texvec[1], texvec[2]);
313   if (texres->nor != NULL) {
314     /* calculate bumpnormal */
315     texres->nor[0] = wood_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]);
316     texres->nor[1] = wood_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]);
317     texres->nor[2] = wood_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla);
318
319     tex_normal_derivate(tex, texres);
320     rv |= TEX_NOR;
321   }
322
323   BRICONT;
324
325   return rv;
326 }
327
328 /* computes basic marble intensity at x,y,z */
329 static float marble_int(Tex *tex, float x, float y, float z)
330 {
331   float n, mi;
332   short wf = tex->noisebasis2; /* wave form:   TEX_SIN=0, TEX_SAW=1, TEX_TRI=2 */
333   short mt = tex->stype;       /* marble type: TEX_SOFT=0, TEX_SHARP=1, TEX_SHAPER=2 */
334
335   float (*waveform[3])(float); /* create array of pointers to waveform functions */
336   waveform[0] = tex_sin;       /* assign address of tex_sin() function to pointer array */
337   waveform[1] = tex_saw;
338   waveform[2] = tex_tri;
339
340   if ((wf > TEX_TRI) || (wf < TEX_SIN)) {
341     wf = 0; /* check to be sure noisebasis2 isn't initialized ahead of time */
342   }
343
344   n = 5.0f * (x + y + z);
345
346   mi = n + tex->turbul * BLI_gTurbulence(tex->noisesize,
347                                          x,
348                                          y,
349                                          z,
350                                          tex->noisedepth,
351                                          (tex->noisetype != TEX_NOISESOFT),
352                                          tex->noisebasis);
353
354   if (mt >= TEX_SOFT) { /* TEX_SOFT always true */
355     mi = waveform[wf](mi);
356     if (mt == TEX_SHARP) {
357       mi = sqrtf(mi);
358     }
359     else if (mt == TEX_SHARPER) {
360       mi = sqrtf(sqrtf(mi));
361     }
362   }
363
364   return mi;
365 }
366
367 static int marble(Tex *tex, const float texvec[3], TexResult *texres)
368 {
369   int rv = TEX_INT;
370
371   texres->tin = marble_int(tex, texvec[0], texvec[1], texvec[2]);
372
373   if (texres->nor != NULL) {
374     /* calculate bumpnormal */
375     texres->nor[0] = marble_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]);
376     texres->nor[1] = marble_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]);
377     texres->nor[2] = marble_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla);
378
379     tex_normal_derivate(tex, texres);
380
381     rv |= TEX_NOR;
382   }
383
384   BRICONT;
385
386   return rv;
387 }
388
389 /* ------------------------------------------------------------------------- */
390
391 static int magic(Tex *tex, const float texvec[3], TexResult *texres)
392 {
393   float x, y, z, turb;
394   int n;
395
396   n = tex->noisedepth;
397   turb = tex->turbul / 5.0f;
398
399   x = sinf((texvec[0] + texvec[1] + texvec[2]) * 5.0f);
400   y = cosf((-texvec[0] + texvec[1] - texvec[2]) * 5.0f);
401   z = -cosf((-texvec[0] - texvec[1] + texvec[2]) * 5.0f);
402   if (n > 0) {
403     x *= turb;
404     y *= turb;
405     z *= turb;
406     y = -cosf(x - y + z);
407     y *= turb;
408     if (n > 1) {
409       x = cosf(x - y - z);
410       x *= turb;
411       if (n > 2) {
412         z = sinf(-x - y - z);
413         z *= turb;
414         if (n > 3) {
415           x = -cosf(-x + y - z);
416           x *= turb;
417           if (n > 4) {
418             y = -sinf(-x + y + z);
419             y *= turb;
420             if (n > 5) {
421               y = -cosf(-x + y + z);
422               y *= turb;
423               if (n > 6) {
424                 x = cosf(x + y + z);
425                 x *= turb;
426                 if (n > 7) {
427                   z = sinf(x + y - z);
428                   z *= turb;
429                   if (n > 8) {
430                     x = -cosf(-x - y + z);
431                     x *= turb;
432                     if (n > 9) {
433                       y = -sinf(x - y + z);
434                       y *= turb;
435                     }
436                   }
437                 }
438               }
439             }
440           }
441         }
442       }
443     }
444   }
445
446   if (turb != 0.0f) {
447     turb *= 2.0f;
448     x /= turb;
449     y /= turb;
450     z /= turb;
451   }
452   texres->tr = 0.5f - x;
453   texres->tg = 0.5f - y;
454   texres->tb = 0.5f - z;
455
456   texres->tin = (1.0f / 3.0f) * (texres->tr + texres->tg + texres->tb);
457
458   BRICONTRGB;
459   texres->ta = 1.0f;
460
461   return TEX_RGB;
462 }
463
464 /* ------------------------------------------------------------------------- */
465
466 /* newnoise: stucci also modified to use different noisebasis */
467 static int stucci(Tex *tex, const float texvec[3], TexResult *texres)
468 {
469   float nor[3], b2, ofs;
470   int retval = TEX_INT;
471
472   b2 = BLI_gNoise(tex->noisesize,
473                   texvec[0],
474                   texvec[1],
475                   texvec[2],
476                   (tex->noisetype != TEX_NOISESOFT),
477                   tex->noisebasis);
478
479   ofs = tex->turbul / 200.0f;
480
481   if (tex->stype) {
482     ofs *= (b2 * b2);
483   }
484   nor[0] = BLI_gNoise(tex->noisesize,
485                       texvec[0] + ofs,
486                       texvec[1],
487                       texvec[2],
488                       (tex->noisetype != TEX_NOISESOFT),
489                       tex->noisebasis);
490   nor[1] = BLI_gNoise(tex->noisesize,
491                       texvec[0],
492                       texvec[1] + ofs,
493                       texvec[2],
494                       (tex->noisetype != TEX_NOISESOFT),
495                       tex->noisebasis);
496   nor[2] = BLI_gNoise(tex->noisesize,
497                       texvec[0],
498                       texvec[1],
499                       texvec[2] + ofs,
500                       (tex->noisetype != TEX_NOISESOFT),
501                       tex->noisebasis);
502
503   texres->tin = nor[2];
504
505   if (texres->nor) {
506
507     copy_v3_v3(texres->nor, nor);
508     tex_normal_derivate(tex, texres);
509
510     if (tex->stype == TEX_WALLOUT) {
511       texres->nor[0] = -texres->nor[0];
512       texres->nor[1] = -texres->nor[1];
513       texres->nor[2] = -texres->nor[2];
514     }
515
516     retval |= TEX_NOR;
517   }
518
519   if (tex->stype == TEX_WALLOUT) {
520     texres->tin = 1.0f - texres->tin;
521   }
522
523   if (texres->tin < 0.0f) {
524     texres->tin = 0.0f;
525   }
526
527   return retval;
528 }
529
530 /* ------------------------------------------------------------------------- */
531 /* newnoise: musgrave terrain noise types */
532
533 static float mg_mFractalOrfBmTex(Tex *tex, const float texvec[3], TexResult *texres)
534 {
535   int rv = TEX_INT;
536   float (*mgravefunc)(float, float, float, float, float, float, int);
537
538   if (tex->stype == TEX_MFRACTAL) {
539     mgravefunc = mg_MultiFractal;
540   }
541   else {
542     mgravefunc = mg_fBm;
543   }
544
545   texres->tin = tex->ns_outscale * mgravefunc(texvec[0],
546                                               texvec[1],
547                                               texvec[2],
548                                               tex->mg_H,
549                                               tex->mg_lacunarity,
550                                               tex->mg_octaves,
551                                               tex->noisebasis);
552
553   if (texres->nor != NULL) {
554     float offs = tex->nabla / tex->noisesize; /* also scaling of texvec */
555
556     /* calculate bumpnormal */
557     texres->nor[0] = tex->ns_outscale * mgravefunc(texvec[0] + offs,
558                                                    texvec[1],
559                                                    texvec[2],
560                                                    tex->mg_H,
561                                                    tex->mg_lacunarity,
562                                                    tex->mg_octaves,
563                                                    tex->noisebasis);
564     texres->nor[1] = tex->ns_outscale * mgravefunc(texvec[0],
565                                                    texvec[1] + offs,
566                                                    texvec[2],
567                                                    tex->mg_H,
568                                                    tex->mg_lacunarity,
569                                                    tex->mg_octaves,
570                                                    tex->noisebasis);
571     texres->nor[2] = tex->ns_outscale * mgravefunc(texvec[0],
572                                                    texvec[1],
573                                                    texvec[2] + offs,
574                                                    tex->mg_H,
575                                                    tex->mg_lacunarity,
576                                                    tex->mg_octaves,
577                                                    tex->noisebasis);
578
579     tex_normal_derivate(tex, texres);
580     rv |= TEX_NOR;
581   }
582
583   BRICONT;
584
585   return rv;
586 }
587
588 static float mg_ridgedOrHybridMFTex(Tex *tex, const float texvec[3], TexResult *texres)
589 {
590   int rv = TEX_INT;
591   float (*mgravefunc)(float, float, float, float, float, float, float, float, int);
592
593   if (tex->stype == TEX_RIDGEDMF) {
594     mgravefunc = mg_RidgedMultiFractal;
595   }
596   else {
597     mgravefunc = mg_HybridMultiFractal;
598   }
599
600   texres->tin = tex->ns_outscale * mgravefunc(texvec[0],
601                                               texvec[1],
602                                               texvec[2],
603                                               tex->mg_H,
604                                               tex->mg_lacunarity,
605                                               tex->mg_octaves,
606                                               tex->mg_offset,
607                                               tex->mg_gain,
608                                               tex->noisebasis);
609
610   if (texres->nor != NULL) {
611     float offs = tex->nabla / tex->noisesize; /* also scaling of texvec */
612
613     /* calculate bumpnormal */
614     texres->nor[0] = tex->ns_outscale * mgravefunc(texvec[0] + offs,
615                                                    texvec[1],
616                                                    texvec[2],
617                                                    tex->mg_H,
618                                                    tex->mg_lacunarity,
619                                                    tex->mg_octaves,
620                                                    tex->mg_offset,
621                                                    tex->mg_gain,
622                                                    tex->noisebasis);
623     texres->nor[1] = tex->ns_outscale * mgravefunc(texvec[0],
624                                                    texvec[1] + offs,
625                                                    texvec[2],
626                                                    tex->mg_H,
627                                                    tex->mg_lacunarity,
628                                                    tex->mg_octaves,
629                                                    tex->mg_offset,
630                                                    tex->mg_gain,
631                                                    tex->noisebasis);
632     texres->nor[2] = tex->ns_outscale * mgravefunc(texvec[0],
633                                                    texvec[1],
634                                                    texvec[2] + offs,
635                                                    tex->mg_H,
636                                                    tex->mg_lacunarity,
637                                                    tex->mg_octaves,
638                                                    tex->mg_offset,
639                                                    tex->mg_gain,
640                                                    tex->noisebasis);
641
642     tex_normal_derivate(tex, texres);
643     rv |= TEX_NOR;
644   }
645
646   BRICONT;
647
648   return rv;
649 }
650
651 static float mg_HTerrainTex(Tex *tex, const float texvec[3], TexResult *texres)
652 {
653   int rv = TEX_INT;
654
655   texres->tin = tex->ns_outscale * mg_HeteroTerrain(texvec[0],
656                                                     texvec[1],
657                                                     texvec[2],
658                                                     tex->mg_H,
659                                                     tex->mg_lacunarity,
660                                                     tex->mg_octaves,
661                                                     tex->mg_offset,
662                                                     tex->noisebasis);
663
664   if (texres->nor != NULL) {
665     float offs = tex->nabla / tex->noisesize; /* also scaling of texvec */
666
667     /* calculate bumpnormal */
668     texres->nor[0] = tex->ns_outscale * mg_HeteroTerrain(texvec[0] + offs,
669                                                          texvec[1],
670                                                          texvec[2],
671                                                          tex->mg_H,
672                                                          tex->mg_lacunarity,
673                                                          tex->mg_octaves,
674                                                          tex->mg_offset,
675                                                          tex->noisebasis);
676     texres->nor[1] = tex->ns_outscale * mg_HeteroTerrain(texvec[0],
677                                                          texvec[1] + offs,
678                                                          texvec[2],
679                                                          tex->mg_H,
680                                                          tex->mg_lacunarity,
681                                                          tex->mg_octaves,
682                                                          tex->mg_offset,
683                                                          tex->noisebasis);
684     texres->nor[2] = tex->ns_outscale * mg_HeteroTerrain(texvec[0],
685                                                          texvec[1],
686                                                          texvec[2] + offs,
687                                                          tex->mg_H,
688                                                          tex->mg_lacunarity,
689                                                          tex->mg_octaves,
690                                                          tex->mg_offset,
691                                                          tex->noisebasis);
692
693     tex_normal_derivate(tex, texres);
694     rv |= TEX_NOR;
695   }
696
697   BRICONT;
698
699   return rv;
700 }
701
702 static float mg_distNoiseTex(Tex *tex, const float texvec[3], TexResult *texres)
703 {
704   int rv = TEX_INT;
705
706   texres->tin = mg_VLNoise(
707       texvec[0], texvec[1], texvec[2], tex->dist_amount, tex->noisebasis, tex->noisebasis2);
708
709   if (texres->nor != NULL) {
710     float offs = tex->nabla / tex->noisesize; /* also scaling of texvec */
711
712     /* calculate bumpnormal */
713     texres->nor[0] = mg_VLNoise(texvec[0] + offs,
714                                 texvec[1],
715                                 texvec[2],
716                                 tex->dist_amount,
717                                 tex->noisebasis,
718                                 tex->noisebasis2);
719     texres->nor[1] = mg_VLNoise(texvec[0],
720                                 texvec[1] + offs,
721                                 texvec[2],
722                                 tex->dist_amount,
723                                 tex->noisebasis,
724                                 tex->noisebasis2);
725     texres->nor[2] = mg_VLNoise(texvec[0],
726                                 texvec[1],
727                                 texvec[2] + offs,
728                                 tex->dist_amount,
729                                 tex->noisebasis,
730                                 tex->noisebasis2);
731
732     tex_normal_derivate(tex, texres);
733     rv |= TEX_NOR;
734   }
735
736   BRICONT;
737
738   return rv;
739 }
740
741 /* ------------------------------------------------------------------------- */
742 /* newnoise: Voronoi texture type
743  *
744  * probably the slowest, especially with minkovsky, bumpmapping, could be done another way.
745  */
746
747 static float voronoiTex(Tex *tex, const float texvec[3], TexResult *texres)
748 {
749   int rv = TEX_INT;
750   float da[4], pa[12]; /* distance and point coordinate arrays of 4 nearest neighbors */
751   float aw1 = fabsf(tex->vn_w1);
752   float aw2 = fabsf(tex->vn_w2);
753   float aw3 = fabsf(tex->vn_w3);
754   float aw4 = fabsf(tex->vn_w4);
755   float sc = (aw1 + aw2 + aw3 + aw4);
756   if (sc != 0.f) {
757     sc = tex->ns_outscale / sc;
758   }
759
760   voronoi(texvec[0], texvec[1], texvec[2], da, pa, tex->vn_mexp, tex->vn_distm);
761   texres->tin = sc * fabsf(tex->vn_w1 * da[0] + tex->vn_w2 * da[1] + tex->vn_w3 * da[2] +
762                            tex->vn_w4 * da[3]);
763
764   if (tex->vn_coltype) {
765     float ca[3]; /* cell color */
766     cellNoiseV(pa[0], pa[1], pa[2], ca);
767     texres->tr = aw1 * ca[0];
768     texres->tg = aw1 * ca[1];
769     texres->tb = aw1 * ca[2];
770     cellNoiseV(pa[3], pa[4], pa[5], ca);
771     texres->tr += aw2 * ca[0];
772     texres->tg += aw2 * ca[1];
773     texres->tb += aw2 * ca[2];
774     cellNoiseV(pa[6], pa[7], pa[8], ca);
775     texres->tr += aw3 * ca[0];
776     texres->tg += aw3 * ca[1];
777     texres->tb += aw3 * ca[2];
778     cellNoiseV(pa[9], pa[10], pa[11], ca);
779     texres->tr += aw4 * ca[0];
780     texres->tg += aw4 * ca[1];
781     texres->tb += aw4 * ca[2];
782     if (tex->vn_coltype >= 2) {
783       float t1 = (da[1] - da[0]) * 10;
784       if (t1 > 1) {
785         t1 = 1;
786       }
787       if (tex->vn_coltype == 3) {
788         t1 *= texres->tin;
789       }
790       else {
791         t1 *= sc;
792       }
793       texres->tr *= t1;
794       texres->tg *= t1;
795       texres->tb *= t1;
796     }
797     else {
798       texres->tr *= sc;
799       texres->tg *= sc;
800       texres->tb *= sc;
801     }
802   }
803
804   if (texres->nor != NULL) {
805     float offs = tex->nabla / tex->noisesize; /* also scaling of texvec */
806
807     /* calculate bumpnormal */
808     voronoi(texvec[0] + offs, texvec[1], texvec[2], da, pa, tex->vn_mexp, tex->vn_distm);
809     texres->nor[0] = sc * fabsf(tex->vn_w1 * da[0] + tex->vn_w2 * da[1] + tex->vn_w3 * da[2] +
810                                 tex->vn_w4 * da[3]);
811     voronoi(texvec[0], texvec[1] + offs, texvec[2], da, pa, tex->vn_mexp, tex->vn_distm);
812     texres->nor[1] = sc * fabsf(tex->vn_w1 * da[0] + tex->vn_w2 * da[1] + tex->vn_w3 * da[2] +
813                                 tex->vn_w4 * da[3]);
814     voronoi(texvec[0], texvec[1], texvec[2] + offs, da, pa, tex->vn_mexp, tex->vn_distm);
815     texres->nor[2] = sc * fabsf(tex->vn_w1 * da[0] + tex->vn_w2 * da[1] + tex->vn_w3 * da[2] +
816                                 tex->vn_w4 * da[3]);
817
818     tex_normal_derivate(tex, texres);
819     rv |= TEX_NOR;
820   }
821
822   if (tex->vn_coltype) {
823     BRICONTRGB;
824     texres->ta = 1.0;
825     return (rv | TEX_RGB);
826   }
827
828   BRICONT;
829
830   return rv;
831 }
832
833 /* ------------------------------------------------------------------------- */
834
835 static int texnoise(Tex *tex, TexResult *texres, int thread)
836 {
837   float div = 3.0;
838   int val, ran, loop, shift = 29;
839
840   ran = BLI_rng_thread_rand(random_tex_array, thread);
841
842   loop = tex->noisedepth;
843
844   /* start from top bits since they have more variance */
845   val = ((ran >> shift) & 3);
846
847   while (loop--) {
848     shift -= 2;
849     val *= ((ran >> shift) & 3);
850     div *= 3.0f;
851   }
852
853   texres->tin = ((float)val) / div;
854
855   BRICONT;
856   return TEX_INT;
857 }
858
859 /* ------------------------------------------------------------------------- */
860
861 static int cubemap_glob(const float n[3], float x, float y, float z, float *adr1, float *adr2)
862 {
863   float x1, y1, z1, nor[3];
864   int ret;
865
866   if (n == NULL) {
867     nor[0] = x;
868     nor[1] = y;
869     nor[2] = z; /* use local render coord */
870   }
871   else {
872     copy_v3_v3(nor, n);
873   }
874
875   x1 = fabsf(nor[0]);
876   y1 = fabsf(nor[1]);
877   z1 = fabsf(nor[2]);
878
879   if (z1 >= x1 && z1 >= y1) {
880     *adr1 = (x + 1.0f) / 2.0f;
881     *adr2 = (y + 1.0f) / 2.0f;
882     ret = 0;
883   }
884   else if (y1 >= x1 && y1 >= z1) {
885     *adr1 = (x + 1.0f) / 2.0f;
886     *adr2 = (z + 1.0f) / 2.0f;
887     ret = 1;
888   }
889   else {
890     *adr1 = (y + 1.0f) / 2.0f;
891     *adr2 = (z + 1.0f) / 2.0f;
892     ret = 2;
893   }
894   return ret;
895 }
896
897 /* ------------------------------------------------------------------------- */
898
899 /* ------------------------------------------------------------------------- */
900
901 static void do_2d_mapping(
902     const MTex *mtex, float texvec[3], const float n[3], float dxt[3], float dyt[3])
903 {
904   Tex *tex;
905   float fx, fy, fac1, area[8];
906   int ok, proj, areaflag = 0, wrap;
907
908   /* mtex variables localized, only cubemap doesn't cooperate yet... */
909   wrap = mtex->mapping;
910   tex = mtex->tex;
911
912   if (!(dxt && dyt)) {
913
914     if (wrap == MTEX_FLAT) {
915       fx = (texvec[0] + 1.0f) / 2.0f;
916       fy = (texvec[1] + 1.0f) / 2.0f;
917     }
918     else if (wrap == MTEX_TUBE) {
919       map_to_tube(&fx, &fy, texvec[0], texvec[1], texvec[2]);
920     }
921     else if (wrap == MTEX_SPHERE) {
922       map_to_sphere(&fx, &fy, texvec[0], texvec[1], texvec[2]);
923     }
924     else {
925       cubemap_glob(n, texvec[0], texvec[1], texvec[2], &fx, &fy);
926     }
927
928     /* repeat */
929     if (tex->extend == TEX_REPEAT) {
930       if (tex->xrepeat > 1) {
931         float origf = fx *= tex->xrepeat;
932
933         if (fx > 1.0f) {
934           fx -= (int)(fx);
935         }
936         else if (fx < 0.0f) {
937           fx += 1 - (int)(fx);
938         }
939
940         if (tex->flag & TEX_REPEAT_XMIR) {
941           int orig = (int)floor(origf);
942           if (orig & 1) {
943             fx = 1.0f - fx;
944           }
945         }
946       }
947       if (tex->yrepeat > 1) {
948         float origf = fy *= tex->yrepeat;
949
950         if (fy > 1.0f) {
951           fy -= (int)(fy);
952         }
953         else if (fy < 0.0f) {
954           fy += 1 - (int)(fy);
955         }
956
957         if (tex->flag & TEX_REPEAT_YMIR) {
958           int orig = (int)floor(origf);
959           if (orig & 1) {
960             fy = 1.0f - fy;
961           }
962         }
963       }
964     }
965     /* crop */
966     if (tex->cropxmin != 0.0f || tex->cropxmax != 1.0f) {
967       fac1 = tex->cropxmax - tex->cropxmin;
968       fx = tex->cropxmin + fx * fac1;
969     }
970     if (tex->cropymin != 0.0f || tex->cropymax != 1.0f) {
971       fac1 = tex->cropymax - tex->cropymin;
972       fy = tex->cropymin + fy * fac1;
973     }
974
975     texvec[0] = fx;
976     texvec[1] = fy;
977   }
978   else {
979
980     if (wrap == MTEX_FLAT) {
981       fx = (texvec[0] + 1.0f) / 2.0f;
982       fy = (texvec[1] + 1.0f) / 2.0f;
983       dxt[0] /= 2.0f;
984       dxt[1] /= 2.0f;
985       dxt[2] /= 2.0f;
986       dyt[0] /= 2.0f;
987       dyt[1] /= 2.0f;
988       dyt[2] /= 2.0f;
989     }
990     else if (ELEM(wrap, MTEX_TUBE, MTEX_SPHERE)) {
991       /* exception: the seam behind (y<0.0) */
992       ok = 1;
993       if (texvec[1] <= 0.0f) {
994         fx = texvec[0] + dxt[0];
995         fy = texvec[0] + dyt[0];
996         if (fx >= 0.0f && fy >= 0.0f && texvec[0] >= 0.0f) {
997           /* pass */
998         }
999         else if (fx <= 0.0f && fy <= 0.0f && texvec[0] <= 0.0f) {
1000           /* pass */
1001         }
1002         else {
1003           ok = 0;
1004         }
1005       }
1006
1007       if (ok) {
1008         if (wrap == MTEX_TUBE) {
1009           map_to_tube(area, area + 1, texvec[0], texvec[1], texvec[2]);
1010           map_to_tube(
1011               area + 2, area + 3, texvec[0] + dxt[0], texvec[1] + dxt[1], texvec[2] + dxt[2]);
1012           map_to_tube(
1013               area + 4, area + 5, texvec[0] + dyt[0], texvec[1] + dyt[1], texvec[2] + dyt[2]);
1014         }
1015         else {
1016           map_to_sphere(area, area + 1, texvec[0], texvec[1], texvec[2]);
1017           map_to_sphere(
1018               area + 2, area + 3, texvec[0] + dxt[0], texvec[1] + dxt[1], texvec[2] + dxt[2]);
1019           map_to_sphere(
1020               area + 4, area + 5, texvec[0] + dyt[0], texvec[1] + dyt[1], texvec[2] + dyt[2]);
1021         }
1022         areaflag = 1;
1023       }
1024       else {
1025         if (wrap == MTEX_TUBE) {
1026           map_to_tube(&fx, &fy, texvec[0], texvec[1], texvec[2]);
1027         }
1028         else {
1029           map_to_sphere(&fx, &fy, texvec[0], texvec[1], texvec[2]);
1030         }
1031         dxt[0] /= 2.0f;
1032         dxt[1] /= 2.0f;
1033         dyt[0] /= 2.0f;
1034         dyt[1] /= 2.0f;
1035       }
1036     }
1037     else {
1038
1039       proj = cubemap_glob(n, texvec[0], texvec[1], texvec[2], &fx, &fy);
1040
1041       if (proj == 1) {
1042         SWAP(float, dxt[1], dxt[2]);
1043         SWAP(float, dyt[1], dyt[2]);
1044       }
1045       else if (proj == 2) {
1046         float f1 = dxt[0], f2 = dyt[0];
1047         dxt[0] = dxt[1];
1048         dyt[0] = dyt[1];
1049         dxt[1] = dxt[2];
1050         dyt[1] = dyt[2];
1051         dxt[2] = f1;
1052         dyt[2] = f2;
1053       }
1054
1055       dxt[0] *= 0.5f;
1056       dxt[1] *= 0.5f;
1057       dxt[2] *= 0.5f;
1058
1059       dyt[0] *= 0.5f;
1060       dyt[1] *= 0.5f;
1061       dyt[2] *= 0.5f;
1062     }
1063
1064     /* if area, then reacalculate dxt[] and dyt[] */
1065     if (areaflag) {
1066       fx = area[0];
1067       fy = area[1];
1068       dxt[0] = area[2] - fx;
1069       dxt[1] = area[3] - fy;
1070       dyt[0] = area[4] - fx;
1071       dyt[1] = area[5] - fy;
1072     }
1073
1074     /* repeat */
1075     if (tex->extend == TEX_REPEAT) {
1076       float max = 1.0f;
1077       if (tex->xrepeat > 1) {
1078         float origf = fx *= tex->xrepeat;
1079
1080         /* TXF: omit mirror here, see comments in do_material_tex() after do_2d_mapping() call */
1081         if (tex->texfilter == TXF_BOX) {
1082           if (fx > 1.0f) {
1083             fx -= (int)(fx);
1084           }
1085           else if (fx < 0.0f) {
1086             fx += 1 - (int)(fx);
1087           }
1088
1089           if (tex->flag & TEX_REPEAT_XMIR) {
1090             int orig = (int)floor(origf);
1091             if (orig & 1) {
1092               fx = 1.0f - fx;
1093             }
1094           }
1095         }
1096
1097         max = tex->xrepeat;
1098
1099         dxt[0] *= tex->xrepeat;
1100         dyt[0] *= tex->xrepeat;
1101       }
1102       if (tex->yrepeat > 1) {
1103         float origf = fy *= tex->yrepeat;
1104
1105         /* TXF: omit mirror here, see comments in do_material_tex() after do_2d_mapping() call */
1106         if (tex->texfilter == TXF_BOX) {
1107           if (fy > 1.0f) {
1108             fy -= (int)(fy);
1109           }
1110           else if (fy < 0.0f) {
1111             fy += 1 - (int)(fy);
1112           }
1113
1114           if (tex->flag & TEX_REPEAT_YMIR) {
1115             int orig = (int)floor(origf);
1116             if (orig & 1) {
1117               fy = 1.0f - fy;
1118             }
1119           }
1120         }
1121
1122         if (max < tex->yrepeat) {
1123           max = tex->yrepeat;
1124         }
1125
1126         dxt[1] *= tex->yrepeat;
1127         dyt[1] *= tex->yrepeat;
1128       }
1129       if (max != 1.0f) {
1130         dxt[2] *= max;
1131         dyt[2] *= max;
1132       }
1133     }
1134     /* crop */
1135     if (tex->cropxmin != 0.0f || tex->cropxmax != 1.0f) {
1136       fac1 = tex->cropxmax - tex->cropxmin;
1137       fx = tex->cropxmin + fx * fac1;
1138       dxt[0] *= fac1;
1139       dyt[0] *= fac1;
1140     }
1141     if (tex->cropymin != 0.0f || tex->cropymax != 1.0f) {
1142       fac1 = tex->cropymax - tex->cropymin;
1143       fy = tex->cropymin + fy * fac1;
1144       dxt[1] *= fac1;
1145       dyt[1] *= fac1;
1146     }
1147
1148     texvec[0] = fx;
1149     texvec[1] = fy;
1150   }
1151 }
1152
1153 /* ************************************** */
1154
1155 static int multitex(Tex *tex,
1156                     float texvec[3],
1157                     float dxt[3],
1158                     float dyt[3],
1159                     int osatex,
1160                     TexResult *texres,
1161                     const short thread,
1162                     const short which_output,
1163                     struct ImagePool *pool,
1164                     const bool skip_load_image,
1165                     const bool texnode_preview,
1166                     const bool use_nodes)
1167 {
1168   float tmpvec[3];
1169   int retval = 0; /* return value, int:0, col:1, nor:2, everything:3 */
1170
1171   texres->talpha = false; /* is set when image texture returns alpha (considered premul) */
1172
1173   if (use_nodes && tex->use_nodes && tex->nodetree) {
1174     const float cfra = 1.0f; /* This was only set for Blender Internal render before. */
1175     retval = ntreeTexExecTree(tex->nodetree,
1176                               texres,
1177                               texvec,
1178                               dxt,
1179                               dyt,
1180                               osatex,
1181                               thread,
1182                               tex,
1183                               which_output,
1184                               cfra,
1185                               texnode_preview,
1186                               NULL);
1187   }
1188   else {
1189     switch (tex->type) {
1190       case 0:
1191         texres->tin = 0.0f;
1192         return 0;
1193       case TEX_CLOUDS:
1194         retval = clouds(tex, texvec, texres);
1195         break;
1196       case TEX_WOOD:
1197         retval = wood(tex, texvec, texres);
1198         break;
1199       case TEX_MARBLE:
1200         retval = marble(tex, texvec, texres);
1201         break;
1202       case TEX_MAGIC:
1203         retval = magic(tex, texvec, texres);
1204         break;
1205       case TEX_BLEND:
1206         retval = blend(tex, texvec, texres);
1207         break;
1208       case TEX_STUCCI:
1209         retval = stucci(tex, texvec, texres);
1210         break;
1211       case TEX_NOISE:
1212         retval = texnoise(tex, texres, thread);
1213         break;
1214       case TEX_IMAGE:
1215         if (osatex) {
1216           retval = imagewraposa(
1217               tex, tex->ima, NULL, texvec, dxt, dyt, texres, pool, skip_load_image);
1218         }
1219         else {
1220           retval = imagewrap(tex, tex->ima, NULL, texvec, texres, pool, skip_load_image);
1221         }
1222         if (tex->ima) {
1223           BKE_image_tag_time(tex->ima);
1224         }
1225         break;
1226       case TEX_MUSGRAVE:
1227         /* newnoise: musgrave types */
1228
1229         /* ton: added this, for Blender convention reason.
1230          * artificer: added the use of tmpvec to avoid scaling texvec
1231          */
1232         copy_v3_v3(tmpvec, texvec);
1233         mul_v3_fl(tmpvec, 1.0f / tex->noisesize);
1234
1235         switch (tex->stype) {
1236           case TEX_MFRACTAL:
1237           case TEX_FBM:
1238             retval = mg_mFractalOrfBmTex(tex, tmpvec, texres);
1239             break;
1240           case TEX_RIDGEDMF:
1241           case TEX_HYBRIDMF:
1242             retval = mg_ridgedOrHybridMFTex(tex, tmpvec, texres);
1243             break;
1244           case TEX_HTERRAIN:
1245             retval = mg_HTerrainTex(tex, tmpvec, texres);
1246             break;
1247         }
1248         break;
1249       /* newnoise: voronoi type */
1250       case TEX_VORONOI:
1251         /* ton: added this, for Blender convention reason.
1252          * artificer: added the use of tmpvec to avoid scaling texvec
1253          */
1254         copy_v3_v3(tmpvec, texvec);
1255         mul_v3_fl(tmpvec, 1.0f / tex->noisesize);
1256
1257         retval = voronoiTex(tex, tmpvec, texres);
1258         break;
1259       case TEX_DISTNOISE:
1260         /* ton: added this, for Blender convention reason.
1261          * artificer: added the use of tmpvec to avoid scaling texvec
1262          */
1263         copy_v3_v3(tmpvec, texvec);
1264         mul_v3_fl(tmpvec, 1.0f / tex->noisesize);
1265
1266         retval = mg_distNoiseTex(tex, tmpvec, texres);
1267         break;
1268     }
1269   }
1270
1271   if (tex->flag & TEX_COLORBAND) {
1272     float col[4];
1273     if (BKE_colorband_evaluate(tex->coba, texres->tin, col)) {
1274       texres->talpha = true;
1275       texres->tr = col[0];
1276       texres->tg = col[1];
1277       texres->tb = col[2];
1278       texres->ta = col[3];
1279       retval |= TEX_RGB;
1280     }
1281   }
1282   return retval;
1283 }
1284
1285 static int multitex_nodes_intern(Tex *tex,
1286                                  float texvec[3],
1287                                  float dxt[3],
1288                                  float dyt[3],
1289                                  int osatex,
1290                                  TexResult *texres,
1291                                  const short thread,
1292                                  short which_output,
1293                                  MTex *mtex,
1294                                  struct ImagePool *pool,
1295                                  const bool scene_color_manage,
1296                                  const bool skip_load_image,
1297                                  const bool texnode_preview,
1298                                  const bool use_nodes)
1299 {
1300   if (tex == NULL) {
1301     memset(texres, 0, sizeof(TexResult));
1302     return 0;
1303   }
1304
1305   if (mtex) {
1306     which_output = mtex->which_output;
1307   }
1308
1309   if (tex->type == TEX_IMAGE) {
1310     int rgbnor;
1311
1312     if (mtex) {
1313       /* we have mtex, use it for 2d mapping images only */
1314       do_2d_mapping(mtex, texvec, NULL, dxt, dyt);
1315       rgbnor = multitex(tex,
1316                         texvec,
1317                         dxt,
1318                         dyt,
1319                         osatex,
1320                         texres,
1321                         thread,
1322                         which_output,
1323                         pool,
1324                         skip_load_image,
1325                         texnode_preview,
1326                         use_nodes);
1327
1328       if (mtex->mapto & (MAP_COL)) {
1329         ImBuf *ibuf = BKE_image_pool_acquire_ibuf(tex->ima, &tex->iuser, pool);
1330
1331         /* don't linearize float buffers, assumed to be linear */
1332         if (ibuf != NULL && ibuf->rect_float == NULL && (rgbnor & TEX_RGB) && scene_color_manage) {
1333           IMB_colormanagement_colorspace_to_scene_linear_v3(&texres->tr, ibuf->rect_colorspace);
1334         }
1335
1336         BKE_image_pool_release_ibuf(tex->ima, ibuf, pool);
1337       }
1338     }
1339     else {
1340       /* we don't have mtex, do default flat 2d projection */
1341       MTex localmtex;
1342       float texvec_l[3], dxt_l[3], dyt_l[3];
1343
1344       localmtex.mapping = MTEX_FLAT;
1345       localmtex.tex = tex;
1346       localmtex.object = NULL;
1347       localmtex.texco = TEXCO_ORCO;
1348
1349       copy_v3_v3(texvec_l, texvec);
1350       if (dxt && dyt) {
1351         copy_v3_v3(dxt_l, dxt);
1352         copy_v3_v3(dyt_l, dyt);
1353       }
1354       else {
1355         zero_v3(dxt_l);
1356         zero_v3(dyt_l);
1357       }
1358
1359       do_2d_mapping(&localmtex, texvec_l, NULL, dxt_l, dyt_l);
1360       rgbnor = multitex(tex,
1361                         texvec_l,
1362                         dxt_l,
1363                         dyt_l,
1364                         osatex,
1365                         texres,
1366                         thread,
1367                         which_output,
1368                         pool,
1369                         skip_load_image,
1370                         texnode_preview,
1371                         use_nodes);
1372
1373       {
1374         ImBuf *ibuf = BKE_image_pool_acquire_ibuf(tex->ima, &tex->iuser, pool);
1375
1376         /* don't linearize float buffers, assumed to be linear */
1377         if (ibuf != NULL && ibuf->rect_float == NULL && (rgbnor & TEX_RGB) && scene_color_manage) {
1378           IMB_colormanagement_colorspace_to_scene_linear_v3(&texres->tr, ibuf->rect_colorspace);
1379         }
1380
1381         BKE_image_pool_release_ibuf(tex->ima, ibuf, pool);
1382       }
1383     }
1384
1385     return rgbnor;
1386   }
1387   else {
1388     return multitex(tex,
1389                     texvec,
1390                     dxt,
1391                     dyt,
1392                     osatex,
1393                     texres,
1394                     thread,
1395                     which_output,
1396                     pool,
1397                     skip_load_image,
1398                     texnode_preview,
1399                     use_nodes);
1400   }
1401 }
1402
1403 /* this is called from the shader and texture nodes
1404  * Use it from render pipeline only!
1405  */
1406 int multitex_nodes(Tex *tex,
1407                    float texvec[3],
1408                    float dxt[3],
1409                    float dyt[3],
1410                    int osatex,
1411                    TexResult *texres,
1412                    const short thread,
1413                    short which_output,
1414                    MTex *mtex,
1415                    struct ImagePool *pool)
1416 {
1417   return multitex_nodes_intern(tex,
1418                                texvec,
1419                                dxt,
1420                                dyt,
1421                                osatex,
1422                                texres,
1423                                thread,
1424                                which_output,
1425                                mtex,
1426                                pool,
1427                                true,
1428                                false,
1429                                false,
1430                                true);
1431 }
1432
1433 /**
1434  * \warning if the texres's values are not declared zero,
1435  * check the return value to be sure the color values are set before using the r/g/b values,
1436  * otherwise you may use uninitialized values - Campbell
1437  *
1438  * Use it for stuff which is out of render pipeline.
1439  */
1440 int multitex_ext(Tex *tex,
1441                  float texvec[3],
1442                  float dxt[3],
1443                  float dyt[3],
1444                  int osatex,
1445                  TexResult *texres,
1446                  const short thread,
1447                  struct ImagePool *pool,
1448                  bool scene_color_manage,
1449                  const bool skip_load_image)
1450 {
1451   return multitex_nodes_intern(tex,
1452                                texvec,
1453                                dxt,
1454                                dyt,
1455                                osatex,
1456                                texres,
1457                                thread,
1458                                0,
1459                                NULL,
1460                                pool,
1461                                scene_color_manage,
1462                                skip_load_image,
1463                                false,
1464                                true);
1465 }
1466
1467 /* extern-tex doesn't support nodes (ntreeBeginExec() can't be called when rendering is going on)\
1468  *
1469  * Use it for stuff which is out of render pipeline.
1470  */
1471 int multitex_ext_safe(Tex *tex,
1472                       float texvec[3],
1473                       TexResult *texres,
1474                       struct ImagePool *pool,
1475                       bool scene_color_manage,
1476                       const bool skip_load_image)
1477 {
1478   return multitex_nodes_intern(tex,
1479                                texvec,
1480                                NULL,
1481                                NULL,
1482                                0,
1483                                texres,
1484                                0,
1485                                0,
1486                                NULL,
1487                                pool,
1488                                scene_color_manage,
1489                                skip_load_image,
1490                                false,
1491                                false);
1492 }
1493
1494 /* ------------------------------------------------------------------------- */
1495
1496 /* in = destination, tex = texture, out = previous color */
1497 /* fact = texture strength, facg = button strength value */
1498 void texture_rgb_blend(
1499     float in[3], const float tex[3], const float out[3], float fact, float facg, int blendtype)
1500 {
1501   float facm;
1502
1503   switch (blendtype) {
1504     case MTEX_BLEND:
1505       fact *= facg;
1506       facm = 1.0f - fact;
1507
1508       in[0] = (fact * tex[0] + facm * out[0]);
1509       in[1] = (fact * tex[1] + facm * out[1]);
1510       in[2] = (fact * tex[2] + facm * out[2]);
1511       break;
1512
1513     case MTEX_MUL:
1514       fact *= facg;
1515       facm = 1.0f - fact;
1516       in[0] = (facm + fact * tex[0]) * out[0];
1517       in[1] = (facm + fact * tex[1]) * out[1];
1518       in[2] = (facm + fact * tex[2]) * out[2];
1519       break;
1520
1521     case MTEX_SCREEN:
1522       fact *= facg;
1523       facm = 1.0f - fact;
1524       in[0] = 1.0f - (facm + fact * (1.0f - tex[0])) * (1.0f - out[0]);
1525       in[1] = 1.0f - (facm + fact * (1.0f - tex[1])) * (1.0f - out[1]);
1526       in[2] = 1.0f - (facm + fact * (1.0f - tex[2])) * (1.0f - out[2]);
1527       break;
1528
1529     case MTEX_OVERLAY:
1530       fact *= facg;
1531       facm = 1.0f - fact;
1532
1533       if (out[0] < 0.5f) {
1534         in[0] = out[0] * (facm + 2.0f * fact * tex[0]);
1535       }
1536       else {
1537         in[0] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[0])) * (1.0f - out[0]);
1538       }
1539       if (out[1] < 0.5f) {
1540         in[1] = out[1] * (facm + 2.0f * fact * tex[1]);
1541       }
1542       else {
1543         in[1] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[1])) * (1.0f - out[1]);
1544       }
1545       if (out[2] < 0.5f) {
1546         in[2] = out[2] * (facm + 2.0f * fact * tex[2]);
1547       }
1548       else {
1549         in[2] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[2])) * (1.0f - out[2]);
1550       }
1551       break;
1552
1553     case MTEX_SUB:
1554       fact = -fact;
1555       ATTR_FALLTHROUGH;
1556     case MTEX_ADD:
1557       fact *= facg;
1558       in[0] = (fact * tex[0] + out[0]);
1559       in[1] = (fact * tex[1] + out[1]);
1560       in[2] = (fact * tex[2] + out[2]);
1561       break;
1562
1563     case MTEX_DIV:
1564       fact *= facg;
1565       facm = 1.0f - fact;
1566
1567       if (tex[0] != 0.0f) {
1568         in[0] = facm * out[0] + fact * out[0] / tex[0];
1569       }
1570       if (tex[1] != 0.0f) {
1571         in[1] = facm * out[1] + fact * out[1] / tex[1];
1572       }
1573       if (tex[2] != 0.0f) {
1574         in[2] = facm * out[2] + fact * out[2] / tex[2];
1575       }
1576
1577       break;
1578
1579     case MTEX_DIFF:
1580       fact *= facg;
1581       facm = 1.0f - fact;
1582       in[0] = facm * out[0] + fact * fabsf(tex[0] - out[0]);
1583       in[1] = facm * out[1] + fact * fabsf(tex[1] - out[1]);
1584       in[2] = facm * out[2] + fact * fabsf(tex[2] - out[2]);
1585       break;
1586
1587     case MTEX_DARK:
1588       fact *= facg;
1589       facm = 1.0f - fact;
1590
1591       in[0] = min_ff(out[0], tex[0]) * fact + out[0] * facm;
1592       in[1] = min_ff(out[1], tex[1]) * fact + out[1] * facm;
1593       in[2] = min_ff(out[2], tex[2]) * fact + out[2] * facm;
1594       break;
1595
1596     case MTEX_LIGHT:
1597       fact *= facg;
1598
1599       in[0] = max_ff(fact * tex[0], out[0]);
1600       in[1] = max_ff(fact * tex[1], out[1]);
1601       in[2] = max_ff(fact * tex[2], out[2]);
1602       break;
1603
1604     case MTEX_BLEND_HUE:
1605       fact *= facg;
1606       copy_v3_v3(in, out);
1607       ramp_blend(MA_RAMP_HUE, in, fact, tex);
1608       break;
1609     case MTEX_BLEND_SAT:
1610       fact *= facg;
1611       copy_v3_v3(in, out);
1612       ramp_blend(MA_RAMP_SAT, in, fact, tex);
1613       break;
1614     case MTEX_BLEND_VAL:
1615       fact *= facg;
1616       copy_v3_v3(in, out);
1617       ramp_blend(MA_RAMP_VAL, in, fact, tex);
1618       break;
1619     case MTEX_BLEND_COLOR:
1620       fact *= facg;
1621       copy_v3_v3(in, out);
1622       ramp_blend(MA_RAMP_COLOR, in, fact, tex);
1623       break;
1624     case MTEX_SOFT_LIGHT:
1625       fact *= facg;
1626       copy_v3_v3(in, out);
1627       ramp_blend(MA_RAMP_SOFT, in, fact, tex);
1628       break;
1629     case MTEX_LIN_LIGHT:
1630       fact *= facg;
1631       copy_v3_v3(in, out);
1632       ramp_blend(MA_RAMP_LINEAR, in, fact, tex);
1633       break;
1634   }
1635 }
1636
1637 float texture_value_blend(float tex, float out, float fact, float facg, int blendtype)
1638 {
1639   float in = 0.0, facm, col, scf;
1640   int flip = (facg < 0.0f);
1641
1642   facg = fabsf(facg);
1643
1644   fact *= facg;
1645   facm = 1.0f - fact;
1646   if (flip) {
1647     SWAP(float, fact, facm);
1648   }
1649
1650   switch (blendtype) {
1651     case MTEX_BLEND:
1652       in = fact * tex + facm * out;
1653       break;
1654
1655     case MTEX_MUL:
1656       facm = 1.0f - facg;
1657       in = (facm + fact * tex) * out;
1658       break;
1659
1660     case MTEX_SCREEN:
1661       facm = 1.0f - facg;
1662       in = 1.0f - (facm + fact * (1.0f - tex)) * (1.0f - out);
1663       break;
1664
1665     case MTEX_OVERLAY:
1666       facm = 1.0f - facg;
1667       if (out < 0.5f) {
1668         in = out * (facm + 2.0f * fact * tex);
1669       }
1670       else {
1671         in = 1.0f - (facm + 2.0f * fact * (1.0f - tex)) * (1.0f - out);
1672       }
1673       break;
1674
1675     case MTEX_SUB:
1676       fact = -fact;
1677       ATTR_FALLTHROUGH;
1678     case MTEX_ADD:
1679       in = fact * tex + out;
1680       break;
1681
1682     case MTEX_DIV:
1683       if (tex != 0.0f) {
1684         in = facm * out + fact * out / tex;
1685       }
1686       break;
1687
1688     case MTEX_DIFF:
1689       in = facm * out + fact * fabsf(tex - out);
1690       break;
1691
1692     case MTEX_DARK:
1693       in = min_ff(out, tex) * fact + out * facm;
1694       break;
1695
1696     case MTEX_LIGHT:
1697       col = fact * tex;
1698       if (col > out) {
1699         in = col;
1700       }
1701       else {
1702         in = out;
1703       }
1704       break;
1705
1706     case MTEX_SOFT_LIGHT:
1707       scf = 1.0f - (1.0f - tex) * (1.0f - out);
1708       in = facm * out + fact * ((1.0f - out) * tex * out) + (out * scf);
1709       break;
1710
1711     case MTEX_LIN_LIGHT:
1712       if (tex > 0.5f) {
1713         in = out + fact * (2.0f * (tex - 0.5f));
1714       }
1715       else {
1716         in = out + fact * (2.0f * tex - 1.0f);
1717       }
1718       break;
1719   }
1720
1721   return in;
1722 }
1723
1724 /* ------------------------------------------------------------------------- */
1725
1726 int externtex(const MTex *mtex,
1727               const float vec[3],
1728               float *tin,
1729               float *tr,
1730               float *tg,
1731               float *tb,
1732               float *ta,
1733               const int thread,
1734               struct ImagePool *pool,
1735               const bool skip_load_image,
1736               const bool texnode_preview)
1737 {
1738   Tex *tex;
1739   TexResult texr;
1740   float dxt[3], dyt[3], texvec[3];
1741   int rgb;
1742
1743   tex = mtex->tex;
1744   if (tex == NULL) {
1745     return 0;
1746   }
1747   texr.nor = NULL;
1748
1749   /* placement */
1750   if (mtex->projx) {
1751     texvec[0] = mtex->size[0] * (vec[mtex->projx - 1] + mtex->ofs[0]);
1752   }
1753   else {
1754     texvec[0] = mtex->size[0] * (mtex->ofs[0]);
1755   }
1756
1757   if (mtex->projy) {
1758     texvec[1] = mtex->size[1] * (vec[mtex->projy - 1] + mtex->ofs[1]);
1759   }
1760   else {
1761     texvec[1] = mtex->size[1] * (mtex->ofs[1]);
1762   }
1763
1764   if (mtex->projz) {
1765     texvec[2] = mtex->size[2] * (vec[mtex->projz - 1] + mtex->ofs[2]);
1766   }
1767   else {
1768     texvec[2] = mtex->size[2] * (mtex->ofs[2]);
1769   }
1770
1771   /* texture */
1772   if (tex->type == TEX_IMAGE) {
1773     do_2d_mapping(mtex, texvec, NULL, dxt, dyt);
1774   }
1775
1776   rgb = multitex(tex,
1777                  texvec,
1778                  dxt,
1779                  dyt,
1780                  0,
1781                  &texr,
1782                  thread,
1783                  mtex->which_output,
1784                  pool,
1785                  skip_load_image,
1786                  texnode_preview,
1787                  true);
1788
1789   if (rgb) {
1790     texr.tin = IMB_colormanagement_get_luminance(&texr.tr);
1791   }
1792   else {
1793     texr.tr = mtex->r;
1794     texr.tg = mtex->g;
1795     texr.tb = mtex->b;
1796   }
1797
1798   *tin = texr.tin;
1799   *tr = texr.tr;
1800   *tg = texr.tg;
1801   *tb = texr.tb;
1802   *ta = texr.ta;
1803
1804   return (rgb != 0);
1805 }