source/blender/render/intern/source/render_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  * Contributor(s): 2004-2006, Blender Foundation, full recode
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  */
  25
  26 /** \file blender/render/intern/source/render_texture.c
  27  *  \ingroup render
  28  */
  29
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <math.h>
  35
  36 #include "BLI_blenlib.h"
  37 #include "BLI_math.h"
  38 #include "BLI_rand.h"
  39 #include "BLI_utildefines.h"
  40
  41 #include "DNA_anim_types.h"
  42 #include "DNA_texture_types.h"
  43 #include "DNA_object_types.h"
  44 #include "DNA_lamp_types.h"
  45 #include "DNA_mesh_types.h"
  46 #include "DNA_meshdata_types.h"
  47 #include "DNA_material_types.h"
  48 #include "DNA_image_types.h"
  49 #include "DNA_node_types.h"
  50
  51 #include "IMB_imbuf_types.h"
  52 #include "IMB_imbuf.h"
  53
  54 #include "BKE_colortools.h"
  55 #include "BKE_image.h"
  56 #include "BKE_node.h"
  57 #include "BKE_plugin_types.h"
  58
  59 #include "BKE_animsys.h"
  60 #include "BKE_DerivedMesh.h"
  61 #include "BKE_global.h"
  62 #include "BKE_main.h"
  63 #include "BKE_material.h"
  64 #include "BKE_scene.h"
  65
  66 #include "BKE_library.h"
  67 #include "BKE_image.h"
  68 #include "BKE_texture.h"
  69 #include "BKE_key.h"
  70 #include "BKE_ipo.h"
  71
  72 #include "MEM_guardedalloc.h"
  73
  74 #include "envmap.h"
  75 #include "pointdensity.h"
  76 #include "voxeldata.h"
  77 #include "renderpipeline.h"
  78 #include "render_types.h"
  79 #include "rendercore.h"
  80 #include "shading.h"
  81 #include "texture.h"
  82 #include "texture_ocean.h"
  83
  84 #include "renderdatabase.h" /* needed for UV */
  85
  86 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  87 /* defined in pipeline.c, is hardcopy of active dynamic allocated Render */
  88 /* only to be used here in this file, it's for speed */
  89 extern struct Render R;
  90 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  91
  92
  93
  94
  95 static void init_render_texture(Render *re, Tex *tex)
  96 {
  97         int cfra= re->scene->r.cfra;
  98
  99         if (re) cfra= re->r.cfra;
 100
 101         /* imap test */
 102         if (tex->ima && ELEM(tex->ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
 103                 BKE_image_user_frame_calc(&tex->iuser, cfra, re?re->flag & R_SEC_FIELD:0);
 104         }
 105
 106         if (tex->type==TEX_PLUGIN) {
 107                 if (tex->plugin && tex->plugin->doit) {
 108                         if (tex->plugin->cfra) {
 109                                 *(tex->plugin->cfra)= (float)cfra; //BKE_scene_frame_get(re->scene); // XXX old animsys - timing stuff to be fixed
 110                         }
 111                 }
 112         }
 113         else if (tex->type==TEX_ENVMAP) {
 114                 /* just in case */
 115                 tex->imaflag |= TEX_INTERPOL | TEX_MIPMAP;
 116                 tex->extend= TEX_CLIP;
 117
 118                 if (tex->env) {
 119                         if (tex->env->type==ENV_PLANE)
 120                                 tex->extend= TEX_EXTEND;
 121
 122                         /* only free envmap when rendermode was set to render envmaps, for previewrender */
 123                         if (G.rendering && re) {
 124                                 if (re->r.mode & R_ENVMAP)
 125                                         if (tex->env->stype==ENV_ANIM)
 126                                                 BKE_free_envmapdata(tex->env);
 127                         }
 128                 }
 129         }
 130
 131         if (tex->nodetree && tex->use_nodes) {
 132                 ntreeTexBeginExecTree(tex->nodetree, 1); /* has internal flag to detect it only does it once */
 133         }
 134 }
 135
 136 /* ------------------------------------------------------------------------- */
 137
 138 void init_render_textures(Render *re)
 139 {
 140         Tex *tex;
 141
 142         tex= re->main->tex.first;
 143         while (tex) {
 144                 if (tex->id.us) init_render_texture(re, tex);
 145                 tex= tex->id.next;
 146         }
 147 }
 148
 149 static void end_render_texture(Tex *tex)
 150 {
 151         if (tex && tex->use_nodes && tex->nodetree && tex->nodetree->execdata)
 152                 ntreeTexEndExecTree(tex->nodetree->execdata, 1);
 153 }
 154
 155 void end_render_textures(Render *re)
 156 {
 157         Tex *tex;
 158         for (tex= re->main->tex.first; tex; tex= tex->id.next)
 159                 if (tex->id.us)
 160                         end_render_texture(tex);
 161 }
 162
 163 /* ------------------------------------------------------------------------- */
 164
 165
 166 /* this allows colorbanded textures to control normals as well */
 167 static void tex_normal_derivate(Tex *tex, TexResult *texres)
 168 {
 169         if (tex->flag & TEX_COLORBAND) {
 170                 float col[4];
 171                 if (do_colorband(tex->coba, texres->tin, col)) {
 172                         float fac0, fac1, fac2, fac3;
 173
 174                         fac0= (col[0]+col[1]+col[2]);
 175                         do_colorband(tex->coba, texres->nor[0], col);
 176                         fac1= (col[0]+col[1]+col[2]);
 177                         do_colorband(tex->coba, texres->nor[1], col);
 178                         fac2= (col[0]+col[1]+col[2]);
 179                         do_colorband(tex->coba, texres->nor[2], col);
 180                         fac3= (col[0]+col[1]+col[2]);
 181
 182                         texres->nor[0]= 0.3333f*(fac0 - fac1);
 183                         texres->nor[1]= 0.3333f*(fac0 - fac2);
 184                         texres->nor[2]= 0.3333f*(fac0 - fac3);
 185
 186                         return;
 187                 }
 188         }
 189         texres->nor[0]= texres->tin - texres->nor[0];
 190         texres->nor[1]= texres->tin - texres->nor[1];
 191         texres->nor[2]= texres->tin - texres->nor[2];
 192 }
 193
 194
 195
 196 static int blend(Tex *tex, float *texvec, TexResult *texres)
 197 {
 198         float x, y, t;
 199
 200         if (tex->flag & TEX_FLIPBLEND) {
 201                 x= texvec[1];
 202                 y= texvec[0];
 203         }
 204         else {
 205                 x= texvec[0];
 206                 y= texvec[1];
 207         }
 208
 209         if (tex->stype==TEX_LIN) {      /* lin */
 210                 texres->tin= (1.0f+x)/2.0f;
 211         }
 212         else if (tex->stype==TEX_QUAD) {        /* quad */
 213                 texres->tin= (1.0f+x)/2.0f;
 214                 if (texres->tin<0.0f) texres->tin= 0.0f;
 215                 else texres->tin*= texres->tin;
 216         }
 217         else if (tex->stype==TEX_EASE) {        /* ease */
 218                 texres->tin= (1.0f+x)/2.0f;
 219                 if (texres->tin<=0.0f) texres->tin= 0.0f;
 220                 else if (texres->tin>=1.0f) texres->tin= 1.0f;
 221                 else {
 222                         t= texres->tin*texres->tin;
 223                         texres->tin= (3.0f*t-2.0f*t*texres->tin);
 224                 }
 225         }
 226         else if (tex->stype==TEX_DIAG) { /* diag */
 227                 texres->tin= (2.0f+x+y)/4.0f;
 228         }
 229         else if (tex->stype==TEX_RAD) { /* radial */
 230                 texres->tin= (atan2(y, x) / (2*M_PI) + 0.5);
 231         }
 232         else {  /* sphere TEX_SPHERE */
 233                 texres->tin= 1.0-sqrt(x*x+      y*y+texvec[2]*texvec[2]);
 234                 if (texres->tin<0.0f) texres->tin= 0.0f;
 235                 if (tex->stype==TEX_HALO) texres->tin*= texres->tin;  /* halo */
 236         }
 237
 238         BRICONT;
 239
 240         return TEX_INT;
 241 }
 242
 243 /* ------------------------------------------------------------------------- */
 244 /* ************************************************************************* */
 245
 246 /* newnoise: all noisebased types now have different noisebases to choose from */
 247
 248 static int clouds(Tex *tex, float *texvec, TexResult *texres)
 249 {
 250         int rv = TEX_INT;
 251
 252         texres->tin = BLI_gTurbulence(tex->noisesize, texvec[0], texvec[1], texvec[2], tex->noisedepth, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 253
 254         if (texres->nor!=NULL) {
 255                 // calculate bumpnormal
 256                 texres->nor[0] = BLI_gTurbulence(tex->noisesize, texvec[0] + tex->nabla, texvec[1], texvec[2], tex->noisedepth,  (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 257                 texres->nor[1] = BLI_gTurbulence(tex->noisesize, texvec[0], texvec[1] + tex->nabla, texvec[2], tex->noisedepth,  (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 258                 texres->nor[2] = BLI_gTurbulence(tex->noisesize, texvec[0], texvec[1], texvec[2] + tex->nabla, tex->noisedepth,  (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 259
 260                 tex_normal_derivate(tex, texres);
 261                 rv |= TEX_NOR;
 262         }
 263
 264         if (tex->stype==TEX_COLOR) {
 265                 // in this case, int. value should really be computed from color,
 266                 // and bumpnormal from that, would be too slow, looks ok as is
 267                 texres->tr = texres->tin;
 268                 texres->tg = BLI_gTurbulence(tex->noisesize, texvec[1], texvec[0], texvec[2], tex->noisedepth, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 269                 texres->tb = BLI_gTurbulence(tex->noisesize, texvec[1], texvec[2], texvec[0], tex->noisedepth, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 270                 BRICONTRGB;
 271                 texres->ta = 1.0;
 272                 return (rv | TEX_RGB);
 273         }
 274
 275         BRICONT;
 276
 277         return rv;
 278
 279 }
 280
 281 /* creates a sine wave */
 282 static float tex_sin(float a)
 283 {
 284         a = 0.5 + 0.5*sin(a);
 285
 286         return a;
 287 }
 288
 289 /* creates a saw wave */
 290 static float tex_saw(float a)
 291 {
 292         const float b = 2*M_PI;
 293
 294         int n = (int)(a / b);
 295         a -= n*b;
 296         if (a < 0) a += b;
 297         return a / b;
 298 }
 299
 300 /* creates a triangle wave */
 301 static float tex_tri(float a)
 302 {
 303         const float b = 2*M_PI;
 304         const float rmax = 1.0;
 305
 306         a = rmax - 2.0f*fabsf(floorf((a*(1.0f/b))+0.5f) - (a*(1.0f/b)));
 307
 308         return a;
 309 }
 310
 311 /* computes basic wood intensity value at x,y,z */
 312 static float wood_int(Tex *tex, float x, float y, float z)
 313 {
 314         float wi=0;
 315         short wf = tex->noisebasis2;    /* wave form:   TEX_SIN=0,  TEX_SAW=1,  TEX_TRI=2                                                */
 316         short wt = tex->stype;                  /* wood type:   TEX_BAND=0, TEX_RING=1, TEX_BANDNOISE=2, TEX_RINGNOISE=3 */
 317
 318         float (*waveform[3])(float);    /* create array of pointers to waveform functions */
 319         waveform[0] = tex_sin;                  /* assign address of tex_sin() function to pointer array */
 320         waveform[1] = tex_saw;
 321         waveform[2] = tex_tri;
 322
 323         if ((wf>TEX_TRI) || (wf<TEX_SIN)) wf=0; /* check to be sure noisebasis2 is initialized ahead of time */
 324
 325         if (wt==TEX_BAND) {
 326                 wi = waveform[wf]((x + y + z)*10.0f);
 327         }
 328         else if (wt==TEX_RING) {
 329                 wi = waveform[wf](sqrtf(x*x + y*y + z*z)*20.0f);
 330         }
 331         else if (wt==TEX_BANDNOISE) {
 332                 wi = tex->turbul*BLI_gNoise(tex->noisesize, x, y, z, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 333                 wi = waveform[wf]((x + y + z)*10.0f + wi);
 334         }
 335         else if (wt==TEX_RINGNOISE) {
 336                 wi = tex->turbul*BLI_gNoise(tex->noisesize, x, y, z, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 337                 wi = waveform[wf](sqrtf(x*x + y*y + z*z)*20.0f + wi);
 338         }
 339
 340         return wi;
 341 }
 342
 343 static int wood(Tex *tex, float *texvec, TexResult *texres)
 344 {
 345         int rv=TEX_INT;
 346
 347         texres->tin = wood_int(tex, texvec[0], texvec[1], texvec[2]);
 348         if (texres->nor!=NULL) {
 349                 /* calculate bumpnormal */
 350                 texres->nor[0] = wood_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]);
 351                 texres->nor[1] = wood_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]);
 352                 texres->nor[2] = wood_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla);
 353
 354                 tex_normal_derivate(tex, texres);
 355                 rv |= TEX_NOR;
 356         }
 357
 358         BRICONT;
 359
 360         return rv;
 361 }
 362
 363 /* computes basic marble intensity at x,y,z */
 364 static float marble_int(Tex *tex, float x, float y, float z)
 365 {
 366         float n, mi;
 367         short wf = tex->noisebasis2;    /* wave form:   TEX_SIN=0,  TEX_SAW=1,  TEX_TRI=2                                               */
 368         short mt = tex->stype;                  /* marble type: TEX_SOFT=0,     TEX_SHARP=1,TEX_SHAPER=2                                        */
 369
 370         float (*waveform[3])(float);    /* create array of pointers to waveform functions */
 371         waveform[0] = tex_sin;                  /* assign address of tex_sin() function to pointer array */
 372         waveform[1] = tex_saw;
 373         waveform[2] = tex_tri;
 374
 375         if ((wf>TEX_TRI) || (wf<TEX_SIN)) wf=0; /* check to be sure noisebasis2 isn't initialized ahead of time */
 376
 377         n = 5.0f * (x + y + z);
 378
 379         mi = n + tex->turbul * BLI_gTurbulence(tex->noisesize, x, y, z, tex->noisedepth, (tex->noisetype!=TEX_NOISESOFT),  tex->noisebasis);
 380
 381         if (mt>=TEX_SOFT) {  /* TEX_SOFT always true */
 382                 mi = waveform[wf](mi);
 383                 if (mt==TEX_SHARP) {
 384                         mi = sqrt(mi);
 385                 }
 386                 else if (mt==TEX_SHARPER) {
 387                         mi = sqrt(sqrt(mi));
 388                 }
 389         }
 390
 391         return mi;
 392 }
 393
 394 static int marble(Tex *tex, float *texvec, TexResult *texres)
 395 {
 396         int rv=TEX_INT;
 397
 398         texres->tin = marble_int(tex, texvec[0], texvec[1], texvec[2]);
 399
 400         if (texres->nor!=NULL) {
 401                 /* calculate bumpnormal */
 402                 texres->nor[0] = marble_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]);
 403                 texres->nor[1] = marble_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]);
 404                 texres->nor[2] = marble_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla);
 405
 406                 tex_normal_derivate(tex, texres);
 407
 408                 rv |= TEX_NOR;
 409         }
 410
 411         BRICONT;
 412
 413         return rv;
 414 }
 415
 416 /* ------------------------------------------------------------------------- */
 417
 418 static int magic(Tex *tex, float *texvec, TexResult *texres)
 419 {
 420         float x, y, z, turb=1.0;
 421         int n;
 422
 423         n= tex->noisedepth;
 424         turb= tex->turbul/5.0f;
 425
 426         x=  sin( ( texvec[0]+texvec[1]+texvec[2])*5.0f );
 427         y=  cos( (-texvec[0]+texvec[1]-texvec[2])*5.0f );
 428         z= -cos( (-texvec[0]-texvec[1]+texvec[2])*5.0f );
 429         if (n>0) {
 430                 x*= turb;
 431                 y*= turb;
 432                 z*= turb;
 433                 y= -cos(x-y+z);
 434                 y*= turb;
 435                 if (n>1) {
 436                         x= cos(x-y-z);
 437                         x*= turb;
 438                         if (n>2) {
 439                                 z= sin(-x-y-z);
 440                                 z*= turb;
 441                                 if (n>3) {
 442                                         x= -cos(-x+y-z);
 443                                         x*= turb;
 444                                         if (n>4) {
 445                                                 y= -sin(-x+y+z);
 446                                                 y*= turb;
 447                                                 if (n>5) {
 448                                                         y= -cos(-x+y+z);
 449                                                         y*= turb;
 450                                                         if (n>6) {
 451                                                                 x= cos(x+y+z);
 452                                                                 x*= turb;
 453                                                                 if (n>7) {
 454                                                                         z= sin(x+y-z);
 455                                                                         z*= turb;
 456                                                                         if (n>8) {
 457                                                                                 x= -cos(-x-y+z);
 458                                                                                 x*= turb;
 459                                                                                 if (n>9) {
 460                                                                                         y= -sin(x-y+z);
 461                                                                                         y*= turb;
 462                                                                                 }
 463                                                                         }
 464                                                                 }
 465                                                         }
 466                                                 }
 467                                         }
 468                                 }
 469                         }
 470                 }
 471         }
 472
 473         if (turb!=0.0f) {
 474                 turb*= 2.0f;
 475                 x/= turb;
 476                 y/= turb;
 477                 z/= turb;
 478         }
 479         texres->tr = 0.5f - x;
 480         texres->tg = 0.5f - y;
 481         texres->tb = 0.5f - z;
 482
 483         texres->tin= (1.0f / 3.0f) * (texres->tr + texres->tg + texres->tb);
 484
 485         BRICONTRGB;
 486         texres->ta = 1.0f;
 487
 488         return TEX_RGB;
 489 }
 490
 491 /* ------------------------------------------------------------------------- */
 492
 493 /* newnoise: stucci also modified to use different noisebasis */
 494 static int stucci(Tex *tex, float *texvec, TexResult *texres)
 495 {
 496         float nor[3], b2, ofs;
 497         int retval= TEX_INT;
 498
 499         b2= BLI_gNoise(tex->noisesize, texvec[0], texvec[1], texvec[2], (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 500
 501         ofs= tex->turbul/200.0f;
 502
 503         if (tex->stype) ofs*=(b2*b2);
 504         nor[0] = BLI_gNoise(tex->noisesize, texvec[0]+ofs, texvec[1], texvec[2], (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 505         nor[1] = BLI_gNoise(tex->noisesize, texvec[0], texvec[1]+ofs, texvec[2], (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 506         nor[2] = BLI_gNoise(tex->noisesize, texvec[0], texvec[1], texvec[2]+ofs, (tex->noisetype!=TEX_NOISESOFT), tex->noisebasis);
 507
 508         texres->tin= nor[2];
 509
 510         if (texres->nor) {
 511
 512                 copy_v3_v3(texres->nor, nor);
 513                 tex_normal_derivate(tex, texres);
 514
 515                 if (tex->stype==TEX_WALLOUT) {
 516                         texres->nor[0]= -texres->nor[0];
 517                         texres->nor[1]= -texres->nor[1];
 518                         texres->nor[2]= -texres->nor[2];
 519                 }
 520
 521                 retval |= TEX_NOR;
 522         }
 523
 524         if (tex->stype==TEX_WALLOUT)
 525                 texres->tin= 1.0f-texres->tin;
 526
 527         if (texres->tin<0.0f)
 528                 texres->tin= 0.0f;
 529
 530         return retval;
 531 }
 532
 533 /* ------------------------------------------------------------------------- */
 534 /* newnoise: musgrave terrain noise types */
 535
 536 static float mg_mFractalOrfBmTex(Tex *tex, float *texvec, TexResult *texres)
 537 {
 538         int rv = TEX_INT;
 539         float (*mgravefunc)(float, float, float, float, float, float, int);
 540
 541         if (tex->stype==TEX_MFRACTAL)
 542                 mgravefunc = mg_MultiFractal;
 543         else
 544                 mgravefunc = mg_fBm;
 545
 546         texres->tin = tex->ns_outscale*mgravefunc(texvec[0], texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->noisebasis);
 547
 548         if (texres->nor!=NULL) {
 549                 float offs= tex->nabla/tex->noisesize;  // also scaling of texvec
 550
 551                 /* calculate bumpnormal */
 552                 texres->nor[0] = tex->ns_outscale*mgravefunc(texvec[0] + offs, texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->noisebasis);
 553                 texres->nor[1] = tex->ns_outscale*mgravefunc(texvec[0], texvec[1] + offs, texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->noisebasis);
 554                 texres->nor[2] = tex->ns_outscale*mgravefunc(texvec[0], texvec[1], texvec[2] + offs, tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->noisebasis);
 555
 556                 tex_normal_derivate(tex, texres);
 557                 rv |= TEX_NOR;
 558         }
 559
 560         BRICONT;
 561
 562         return rv;
 563
 564 }
 565
 566 static float mg_ridgedOrHybridMFTex(Tex *tex, float *texvec, TexResult *texres)
 567 {
 568         int rv = TEX_INT;
 569         float (*mgravefunc)(float, float, float, float, float, float, float, float, int);
 570
 571         if (tex->stype==TEX_RIDGEDMF)
 572                 mgravefunc = mg_RidgedMultiFractal;
 573         else
 574                 mgravefunc = mg_HybridMultiFractal;
 575
 576         texres->tin = tex->ns_outscale*mgravefunc(texvec[0], texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->mg_gain, tex->noisebasis);
 577
 578         if (texres->nor!=NULL) {
 579                 float offs= tex->nabla/tex->noisesize;  // also scaling of texvec
 580
 581                 /* calculate bumpnormal */
 582                 texres->nor[0] = tex->ns_outscale*mgravefunc(texvec[0] + offs, texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->mg_gain, tex->noisebasis);
 583                 texres->nor[1] = tex->ns_outscale*mgravefunc(texvec[0], texvec[1] + offs, texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->mg_gain, tex->noisebasis);
 584                 texres->nor[2] = tex->ns_outscale*mgravefunc(texvec[0], texvec[1], texvec[2] + offs, tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->mg_gain, tex->noisebasis);
 585
 586                 tex_normal_derivate(tex, texres);
 587                 rv |= TEX_NOR;
 588         }
 589
 590         BRICONT;
 591
 592         return rv;
 593
 594 }
 595
 596
 597 static float mg_HTerrainTex(Tex *tex, float *texvec, TexResult *texres)
 598 {
 599         int rv = TEX_INT;
 600
 601         texres->tin = tex->ns_outscale*mg_HeteroTerrain(texvec[0], texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->noisebasis);
 602
 603         if (texres->nor!=NULL) {
 604                 float offs= tex->nabla/tex->noisesize;  // also scaling of texvec
 605
 606                 /* calculate bumpnormal */
 607                 texres->nor[0] = tex->ns_outscale*mg_HeteroTerrain(texvec[0] + offs, texvec[1], texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->noisebasis);
 608                 texres->nor[1] = tex->ns_outscale*mg_HeteroTerrain(texvec[0], texvec[1] + offs, texvec[2], tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->noisebasis);
 609                 texres->nor[2] = tex->ns_outscale*mg_HeteroTerrain(texvec[0], texvec[1], texvec[2] + offs, tex->mg_H, tex->mg_lacunarity, tex->mg_octaves, tex->mg_offset, tex->noisebasis);
 610
 611                 tex_normal_derivate(tex, texres);
 612                 rv |= TEX_NOR;
 613         }
 614
 615         BRICONT;
 616
 617         return rv;
 618
 619 }
 620
 621
 622 static float mg_distNoiseTex(Tex *tex, float *texvec, TexResult *texres)
 623 {
 624         int rv = TEX_INT;
 625
 626         texres->tin = mg_VLNoise(texvec[0], texvec[1], texvec[2], tex->dist_amount, tex->noisebasis, tex->noisebasis2);
 627
 628         if (texres->nor!=NULL) {
 629                 float offs= tex->nabla/tex->noisesize;  // also scaling of texvec
 630
 631                 /* calculate bumpnormal */
 632                 texres->nor[0] = mg_VLNoise(texvec[0] + offs, texvec[1], texvec[2], tex->dist_amount, tex->noisebasis, tex->noisebasis2);
 633                 texres->nor[1] = mg_VLNoise(texvec[0], texvec[1] + offs, texvec[2], tex->dist_amount, tex->noisebasis, tex->noisebasis2);
 634                 texres->nor[2] = mg_VLNoise(texvec[0], texvec[1], texvec[2] + offs, tex->dist_amount, tex->noisebasis, tex->noisebasis2);
 635
 636                 tex_normal_derivate(tex, texres);
 637                 rv |= TEX_NOR;
 638         }
 639
 640         BRICONT;
 641
 642
 643         return rv;
 644
 645 }
 646
 647
 648 /* ------------------------------------------------------------------------- */
 649 /* newnoise: Voronoi texture type, probably the slowest, especially with minkovsky, bumpmapping, could be done another way */
 650
 651 static float voronoiTex(Tex *tex, float *texvec, TexResult *texres)
 652 {
 653         int rv = TEX_INT;
 654         float da[4], pa[12];    /* distance and point coordinate arrays of 4 nearest neighbors */
 655         float aw1 = fabs(tex->vn_w1);
 656         float aw2 = fabs(tex->vn_w2);
 657         float aw3 = fabs(tex->vn_w3);
 658         float aw4 = fabs(tex->vn_w4);
 659         float sc = (aw1 + aw2 + aw3 + aw4);
 660         if (sc!=0.f) sc =  tex->ns_outscale/sc;
 661
 662         voronoi(texvec[0], texvec[1], texvec[2], da, pa, tex->vn_mexp, tex->vn_distm);
 663         texres->tin = sc * fabsf(tex->vn_w1*da[0] + tex->vn_w2*da[1] + tex->vn_w3*da[2] + tex->vn_w4*da[3]);
 664
 665         if (tex->vn_coltype) {
 666                 float ca[3];    /* cell color */
 667                 cellNoiseV(pa[0], pa[1], pa[2], ca);
 668                 texres->tr = aw1*ca[0];
 669                 texres->tg = aw1*ca[1];
 670                 texres->tb = aw1*ca[2];
 671                 cellNoiseV(pa[3], pa[4], pa[5], ca);
 672                 texres->tr += aw2*ca[0];
 673                 texres->tg += aw2*ca[1];
 674                 texres->tb += aw2*ca[2];
 675                 cellNoiseV(pa[6], pa[7], pa[8], ca);
 676                 texres->tr += aw3*ca[0];
 677                 texres->tg += aw3*ca[1];
 678                 texres->tb += aw3*ca[2];
 679                 cellNoiseV(pa[9], pa[10], pa[11], ca);
 680                 texres->tr += aw4*ca[0];
 681                 texres->tg += aw4*ca[1];
 682                 texres->tb += aw4*ca[2];
 683                 if (tex->vn_coltype>=2) {
 684                         float t1 = (da[1]-da[0])*10;
 685                         if (t1>1) t1=1;
 686                         if (tex->vn_coltype==3) t1*=texres->tin; else t1*=sc;
 687                         texres->tr *= t1;
 688                         texres->tg *= t1;
 689                         texres->tb *= t1;
 690                 }
 691                 else {
 692                         texres->tr *= sc;
 693                         texres->tg *= sc;
 694                         texres->tb *= sc;
 695                 }
 696         }
 697
 698         if (texres->nor!=NULL) {
 699                 float offs= tex->nabla/tex->noisesize;  // also scaling of texvec
 700
 701                 /* calculate bumpnormal */
 702                 voronoi(texvec[0] + offs, texvec[1], texvec[2], da, pa, tex->vn_mexp,  tex->vn_distm);
 703                 texres->nor[0] = sc * fabsf(tex->vn_w1*da[0] + tex->vn_w2*da[1] + tex->vn_w3*da[2] + tex->vn_w4*da[3]);
 704                 voronoi(texvec[0], texvec[1] + offs, texvec[2], da, pa, tex->vn_mexp,  tex->vn_distm);
 705                 texres->nor[1] = sc * fabsf(tex->vn_w1*da[0] + tex->vn_w2*da[1] + tex->vn_w3*da[2] + tex->vn_w4*da[3]);
 706                 voronoi(texvec[0], texvec[1], texvec[2] + offs, da, pa, tex->vn_mexp,  tex->vn_distm);
 707                 texres->nor[2] = sc * fabsf(tex->vn_w1*da[0] + tex->vn_w2*da[1] + tex->vn_w3*da[2] + tex->vn_w4*da[3]);
 708
 709                 tex_normal_derivate(tex, texres);
 710                 rv |= TEX_NOR;
 711         }
 712
 713         if (tex->vn_coltype) {
 714                 BRICONTRGB;
 715                 texres->ta = 1.0;
 716                 return (rv | TEX_RGB);
 717         }
 718
 719         BRICONT;
 720
 721         return rv;
 722
 723 }
 724
 725 /* ------------------------------------------------------------------------- */
 726
 727 static int texnoise(Tex *tex, TexResult *texres)
 728 {
 729         float div=3.0;
 730         int val, ran, loop;
 731
 732         ran= BLI_rand();
 733         val= (ran & 3);
 734
 735         loop= tex->noisedepth;
 736         while (loop--) {
 737                 ran= (ran>>2);
 738                 val*= (ran & 3);
 739                 div*= 3.0f;
 740         }
 741
 742         texres->tin= ((float)val)/div;
 743
 744         BRICONT;
 745         return TEX_INT;
 746 }
 747
 748 /* ------------------------------------------------------------------------- */
 749
 750 static int plugintex(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex, TexResult *texres)
 751 {
 752         PluginTex *pit;
 753         int rgbnor=0;
 754         float result[8]= {0.0f};
 755
 756         texres->tin= 0.0;
 757
 758         pit= tex->plugin;
 759         if (pit && pit->doit) {
 760                 if (texres->nor) {
 761                         if (pit->version < 6) {
 762                                 copy_v3_v3(pit->result+5, texres->nor);
 763                         }
 764                         else {
 765                                 copy_v3_v3(result+5, texres->nor);
 766                         }
 767                 }
 768                 if (pit->version < 6) {
 769                         if (osatex) rgbnor= ((TexDoitold)pit->doit)(tex->stype,
 770                                 pit->data, texvec, dxt, dyt);
 771                         else rgbnor= ((TexDoitold)pit->doit)(tex->stype,
 772                                 pit->data, texvec, NULL, NULL);
 773                 }
 774                 else {
 775                         if (osatex) rgbnor= ((TexDoit)pit->doit)(tex->stype,
 776                                 pit->data, texvec, dxt, dyt, result);
 777                         else rgbnor= ((TexDoit)pit->doit)(tex->stype,
 778                                 pit->data, texvec, NULL, NULL, result);
 779                 }
 780
 781                 if (pit->version < 6) {
 782                         texres->tin = pit->result[0];
 783                 }
 784                 else {
 785                         texres->tin = result[0]; /* XXX, assigning garbage value, fixme! */
 786                 }
 787
 788                 if (rgbnor & TEX_NOR) {
 789                         if (texres->nor) {
 790                                 if (pit->version < 6) {
 791                                         copy_v3_v3(texres->nor, pit->result+5);
 792                                 }
 793                                 else {
 794                                         copy_v3_v3(texres->nor, result+5);
 795                                 }
 796                         }
 797                 }
 798
 799                 if (rgbnor & TEX_RGB) {
 800                         if (pit->version < 6) {
 801                                 copy_v4_v4(&texres->tr, pit->result + 1);
 802                         }
 803                         else {
 804                                 copy_v4_v4(&texres->tr, result + 1);
 805                         }
 806
 807                         BRICONTRGB;
 808                 }
 809
 810                 BRICONT;
 811         }
 812
 813         return rgbnor;
 814 }
 815
 816
 817 static int cubemap_glob(const float n[3], float x, float y, float z, float *adr1, float *adr2)
 818 {
 819         float x1, y1, z1, nor[3];
 820         int ret;
 821
 822         if (n==NULL) {
 823                 nor[0]= x; nor[1]= y; nor[2]= z;        // use local render coord
 824         }
 825         else {
 826                 copy_v3_v3(nor, n);
 827         }
 828         mul_mat3_m4_v3(R.viewinv, nor);
 829
 830         x1= fabs(nor[0]);
 831         y1= fabs(nor[1]);
 832         z1= fabs(nor[2]);
 833
 834         if (z1>=x1 && z1>=y1) {
 835                 *adr1 = (x + 1.0f) / 2.0f;
 836                 *adr2 = (y + 1.0f) / 2.0f;
 837                 ret= 0;
 838         }
 839         else if (y1>=x1 && y1>=z1) {
 840                 *adr1 = (x + 1.0f) / 2.0f;
 841                 *adr2 = (z + 1.0f) / 2.0f;
 842                 ret= 1;
 843         }
 844         else {
 845                 *adr1 = (y + 1.0f) / 2.0f;
 846                 *adr2 = (z + 1.0f) / 2.0f;
 847                 ret= 2;
 848         }
 849         return ret;
 850 }
 851
 852 /* ------------------------------------------------------------------------- */
 853
 854 /* mtex argument only for projection switches */
 855 static int cubemap(MTex *mtex, VlakRen *vlr, const float n[3], float x, float y, float z, float *adr1, float *adr2)
 856 {
 857         int proj[4]={0, ME_PROJXY, ME_PROJXZ, ME_PROJYZ}, ret= 0;
 858
 859         if (vlr) {
 860                 int index;
 861
 862                 /* Mesh vertices have such flags, for others we calculate it once based on orco */
 863                 if ((vlr->puno & (ME_PROJXY|ME_PROJXZ|ME_PROJYZ))==0) {
 864                         /* test for v1, vlr can be faked for baking */
 865                         if (vlr->v1 && vlr->v1->orco) {
 866                                 float nor[3];
 867                                 normal_tri_v3(nor, vlr->v1->orco, vlr->v2->orco, vlr->v3->orco);
 868
 869                                 if ( fabs(nor[0])<fabs(nor[2]) && fabs(nor[1])<fabs(nor[2]) ) vlr->puno |= ME_PROJXY;
 870                                 else if ( fabs(nor[0])<fabs(nor[1]) && fabs(nor[2])<fabs(nor[1]) ) vlr->puno |= ME_PROJXZ;
 871                                 else vlr->puno |= ME_PROJYZ;
 872                         }
 873                         else return cubemap_glob(n, x, y, z, adr1, adr2);
 874                 }
 875
 876                 if (mtex) {
 877                         /* the mtex->proj{xyz} have type char. maybe this should be wider? */
 878                         /* casting to int ensures that the index type is right.            */
 879                         index = (int) mtex->projx;
 880                         proj[index]= ME_PROJXY;
 881
 882                         index = (int) mtex->projy;
 883                         proj[index]= ME_PROJXZ;
 884
 885                         index = (int) mtex->projz;
 886                         proj[index]= ME_PROJYZ;
 887                 }
 888
 889                 if (vlr->puno & proj[1]) {
 890                         *adr1 = (x + 1.0f) / 2.0f;
 891                         *adr2 = (y + 1.0f) / 2.0f;
 892                 }
 893                 else if (vlr->puno & proj[2]) {
 894                         *adr1 = (x + 1.0f) / 2.0f;
 895                         *adr2 = (z + 1.0f) / 2.0f;
 896                         ret= 1;
 897                 }
 898                 else {
 899                         *adr1 = (y + 1.0f) / 2.0f;
 900                         *adr2 = (z + 1.0f) / 2.0f;
 901                         ret= 2;
 902                 }
 903         }
 904         else {
 905                 return cubemap_glob(n, x, y, z, adr1, adr2);
 906         }
 907
 908         return ret;
 909 }
 910
 911 /* ------------------------------------------------------------------------- */
 912
 913 static int cubemap_ob(Object *ob, const float n[3], float x, float y, float z, float *adr1, float *adr2)
 914 {
 915         float x1, y1, z1, nor[3];
 916         int ret;
 917
 918         if (n==NULL) return 0;
 919
 920         copy_v3_v3(nor, n);
 921         if (ob) mul_mat3_m4_v3(ob->imat, nor);
 922
 923         x1= fabs(nor[0]);
 924         y1= fabs(nor[1]);
 925         z1= fabs(nor[2]);
 926
 927         if (z1>=x1 && z1>=y1) {
 928                 *adr1 = (x + 1.0f) / 2.0f;
 929                 *adr2 = (y + 1.0f) / 2.0f;
 930                 ret= 0;
 931         }
 932         else if (y1>=x1 && y1>=z1) {
 933                 *adr1 = (x + 1.0f) / 2.0f;
 934                 *adr2 = (z + 1.0f) / 2.0f;
 935                 ret= 1;
 936         }
 937         else {
 938                 *adr1 = (y + 1.0f) / 2.0f;
 939                 *adr2 = (z + 1.0f) / 2.0f;
 940                 ret= 2;
 941         }
 942         return ret;
 943 }
 944
 945 /* ------------------------------------------------------------------------- */
 946
 947 static void do_2d_mapping(MTex *mtex, float *t, VlakRen *vlr, const float n[3], float *dxt, float *dyt)
 948 {
 949         Tex *tex;
 950         Object *ob= NULL;
 951         float fx, fy, fac1, area[8];
 952         int ok, proj, areaflag= 0, wrap, texco;
 953
 954         /* mtex variables localized, only cubemap doesn't cooperate yet... */
 955         wrap= mtex->mapping;
 956         tex= mtex->tex;
 957         ob= mtex->object;
 958         texco= mtex->texco;
 959
 960         if (R.osa==0) {
 961
 962                 if (wrap==MTEX_FLAT) {
 963                         fx = (t[0] + 1.0f) / 2.0f;
 964                         fy = (t[1] + 1.0f) / 2.0f;
 965                 }
 966                 else if (wrap==MTEX_TUBE) map_to_tube( &fx, &fy, t[0], t[1], t[2]);
 967                 else if (wrap==MTEX_SPHERE) map_to_sphere(&fx, &fy, t[0], t[1], t[2]);
 968                 else {
 969                         if (texco==TEXCO_OBJECT) cubemap_ob(ob, n, t[0], t[1], t[2], &fx, &fy);
 970                         else if (texco==TEXCO_GLOB) cubemap_glob(n, t[0], t[1], t[2], &fx, &fy);
 971                         else cubemap(mtex, vlr, n, t[0], t[1], t[2], &fx, &fy);
 972                 }
 973
 974                 /* repeat */
 975                 if (tex->extend==TEX_REPEAT) {
 976                         if (tex->xrepeat>1) {
 977                                 float origf= fx *= tex->xrepeat;
 978
 979                                 if (fx>1.0f) fx -= (int)(fx);
 980                                 else if (fx<0.0f) fx+= 1-(int)(fx);
 981
 982                                 if (tex->flag & TEX_REPEAT_XMIR) {
 983                                         int orig= (int)floor(origf);
 984                                         if (orig & 1)
 985                                                 fx= 1.0f-fx;
 986                                 }
 987                         }
 988                         if (tex->yrepeat>1) {
 989                                 float origf= fy *= tex->yrepeat;
 990
 991                                 if (fy>1.0f) fy -= (int)(fy);
 992                                 else if (fy<0.0f) fy+= 1-(int)(fy);
 993
 994                                 if (tex->flag & TEX_REPEAT_YMIR) {
 995                                         int orig= (int)floor(origf);
 996                                         if (orig & 1)
 997                                                 fy= 1.0f-fy;
 998                                 }
 999                         }
1000                 }
1001                 /* crop */
1002                 if (tex->cropxmin!=0.0f || tex->cropxmax!=1.0f) {
1003                         fac1= tex->cropxmax - tex->cropxmin;
1004                         fx= tex->cropxmin+ fx*fac1;
1005                 }
1006                 if (tex->cropymin!=0.0f || tex->cropymax!=1.0f) {
1007                         fac1= tex->cropymax - tex->cropymin;
1008                         fy= tex->cropymin+ fy*fac1;
1009                 }
1010
1011                 t[0]= fx;
1012                 t[1]= fy;
1013         }
1014         else {
1015
1016                 if (wrap==MTEX_FLAT) {
1017                         fx= (t[0] + 1.0f) / 2.0f;
1018                         fy= (t[1] + 1.0f) / 2.0f;
1019                         dxt[0]/= 2.0f;
1020                         dxt[1]/= 2.0f;
1021                         dxt[2]/= 2.0f;
1022                         dyt[0]/= 2.0f;
1023                         dyt[1]/= 2.0f;
1024                         dyt[2]/= 2.0f;
1025                 }
1026                 else if (ELEM(wrap, MTEX_TUBE, MTEX_SPHERE)) {
1027                         /* exception: the seam behind (y<0.0) */
1028                         ok= 1;
1029                         if (t[1]<=0.0f) {
1030                                 fx= t[0]+dxt[0];
1031                                 fy= t[0]+dyt[0];
1032                                 if (fx>=0.0f && fy>=0.0f && t[0]>=0.0f);
1033                                 else if (fx<=0.0f && fy<=0.0f && t[0]<=0.0f);
1034                                 else ok= 0;
1035                         }
1036                         if (ok) {
1037                                 if (wrap==MTEX_TUBE) {
1038                                         map_to_tube(area, area+1, t[0], t[1], t[2]);
1039                                         map_to_tube(area + 2, area + 3, t[0] + dxt[0], t[1] + dxt[1], t[2] + dxt[2]);
1040                                         map_to_tube(area + 4, area + 5, t[0] + dyt[0], t[1] + dyt[1], t[2] + dyt[2]);
1041                                 }
1042                                 else {
1043                                         map_to_sphere(area, area+1, t[0], t[1], t[2]);
1044                                         map_to_sphere(area + 2, area + 3, t[0] + dxt[0], t[1] + dxt[1], t[2] + dxt[2]);
1045                                         map_to_sphere(area + 4, area + 5, t[0] + dyt[0], t[1] + dyt[1], t[2] + dyt[2]);
1046                                 }
1047                                 areaflag= 1;
1048                         }
1049                         else {
1050                                 if (wrap==MTEX_TUBE) map_to_tube( &fx, &fy, t[0], t[1], t[2]);
1051                                 else map_to_sphere(&fx, &fy, t[0], t[1], t[2]);
1052                                 dxt[0]/= 2.0f;
1053                                 dxt[1]/= 2.0f;
1054                                 dyt[0]/= 2.0f;
1055                                 dyt[1]/= 2.0f;
1056                         }
1057                 }
1058                 else {
1059
1060                         if (texco==TEXCO_OBJECT) proj = cubemap_ob(ob, n, t[0], t[1], t[2], &fx, &fy);
1061                         else if (texco==TEXCO_GLOB) proj = cubemap_glob(n, t[0], t[1], t[2], &fx, &fy);
1062                         else proj = cubemap(mtex, vlr, n, t[0], t[1], t[2], &fx, &fy);
1063
1064                         if (proj==1) {
1065                                 SWAP(float, dxt[1], dxt[2]);
1066                                 SWAP(float, dyt[1], dyt[2]);
1067                         }
1068                         else if (proj==2) {
1069                                 float f1= dxt[0], f2= dyt[0];
1070                                 dxt[0]= dxt[1];
1071                                 dyt[0]= dyt[1];
1072                                 dxt[1]= dxt[2];
1073                                 dyt[1]= dyt[2];
1074                                 dxt[2]= f1;
1075                                 dyt[2]= f2;
1076                         }
1077
1078                         dxt[0] *= 0.5f;
1079                         dxt[1] *= 0.5f;
1080                         dxt[2] *= 0.5f;
1081
1082                         dyt[0] *= 0.5f;
1083                         dyt[1] *= 0.5f;
1084                         dyt[2] *= 0.5f;
1085
1086                 }
1087
1088                 /* if area, then reacalculate dxt[] and dyt[] */
1089                 if (areaflag) {
1090                         fx= area[0];
1091                         fy= area[1];
1092                         dxt[0]= area[2]-fx;
1093                         dxt[1]= area[3]-fy;
1094                         dyt[0]= area[4]-fx;
1095                         dyt[1]= area[5]-fy;
1096                 }
1097
1098                 /* repeat */
1099                 if (tex->extend==TEX_REPEAT) {
1100                         float max= 1.0f;
1101                         if (tex->xrepeat>1) {
1102                                 float origf= fx *= tex->xrepeat;
1103
1104                                 // TXF: omit mirror here, see comments in do_material_tex() after do_2d_mapping() call
1105                                 if (tex->texfilter == TXF_BOX) {
1106                                         if (fx>1.0f) fx -= (int)(fx);
1107                                         else if (fx<0.0f) fx+= 1-(int)(fx);
1108
1109                                         if (tex->flag & TEX_REPEAT_XMIR) {
1110                                                 int orig= (int)floor(origf);
1111                                                 if (orig & 1)
1112                                                         fx= 1.0f-fx;
1113                                         }
1114                                 }
1115
1116                                 max= tex->xrepeat;
1117
1118                                 dxt[0]*= tex->xrepeat;
1119                                 dyt[0]*= tex->xrepeat;
1120                         }
1121                         if (tex->yrepeat>1) {
1122                                 float origf= fy *= tex->yrepeat;
1123
1124                                 // TXF: omit mirror here, see comments in do_material_tex() after do_2d_mapping() call
1125                                 if (tex->texfilter == TXF_BOX) {
1126                                         if (fy>1.0f) fy -= (int)(fy);
1127                                         else if (fy<0.0f) fy+= 1-(int)(fy);
1128
1129                                         if (tex->flag & TEX_REPEAT_YMIR) {
1130                                                 int orig= (int)floor(origf);
1131                                                 if (orig & 1)
1132                                                         fy= 1.0f-fy;
1133                                         }
1134                                 }
1135
1136                                 if (max<tex->yrepeat)
1137                                         max= tex->yrepeat;
1138
1139                                 dxt[1]*= tex->yrepeat;
1140                                 dyt[1]*= tex->yrepeat;
1141                         }
1142                         if (max!=1.0f) {
1143                                 dxt[2]*= max;
1144                                 dyt[2]*= max;
1145                         }
1146
1147                 }
1148                 /* crop */
1149                 if (tex->cropxmin!=0.0f || tex->cropxmax!=1.0f) {
1150                         fac1= tex->cropxmax - tex->cropxmin;
1151                         fx= tex->cropxmin+ fx*fac1;
1152                         dxt[0]*= fac1;
1153                         dyt[0]*= fac1;
1154                 }
1155                 if (tex->cropymin!=0.0f || tex->cropymax!=1.0f) {
1156                         fac1= tex->cropymax - tex->cropymin;
1157                         fy= tex->cropymin+ fy*fac1;
1158                         dxt[1]*= fac1;
1159                         dyt[1]*= fac1;
1160                 }
1161
1162                 t[0]= fx;
1163                 t[1]= fy;
1164
1165         }
1166 }
1167
1168 /* ************************************** */
1169
1170 static int multitex(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex, TexResult *texres, short thread, short which_output)
1171 {
1172         float tmpvec[3];
1173         int retval=0; /* return value, int:0, col:1, nor:2, everything:3 */
1174
1175         texres->talpha= 0;      /* is set when image texture returns alpha (considered premul) */
1176
1177         if (tex->use_nodes && tex->nodetree) {
1178                 retval = ntreeTexExecTree(tex->nodetree, texres, texvec, dxt, dyt, osatex, thread,
1179                         tex, which_output, R.r.cfra, (R.r.scemode & R_TEXNODE_PREVIEW) != 0, NULL, NULL);
1180         }
1181         else
1182         switch (tex->type) {
1183
1184         case 0:
1185                 texres->tin= 0.0f;
1186                 return 0;
1187         case TEX_CLOUDS:
1188                 retval= clouds(tex, texvec, texres);
1189                 break;
1190         case TEX_WOOD:
1191                 retval= wood(tex, texvec, texres);
1192                 break;
1193         case TEX_MARBLE:
1194                 retval= marble(tex, texvec, texres);
1195                 break;
1196         case TEX_MAGIC:
1197                 retval= magic(tex, texvec, texres);
1198                 break;
1199         case TEX_BLEND:
1200                 retval= blend(tex, texvec, texres);
1201                 break;
1202         case TEX_STUCCI:
1203                 retval= stucci(tex, texvec, texres);
1204                 break;
1205         case TEX_NOISE:
1206                 retval= texnoise(tex, texres);
1207                 break;
1208         case TEX_IMAGE:
1209                 if (osatex) retval= imagewraposa(tex, tex->ima, NULL, texvec, dxt, dyt, texres);
1210                 else retval= imagewrap(tex, tex->ima, NULL, texvec, texres);
1211                 BKE_image_tag_time(tex->ima); /* tag image as having being used */
1212                 break;
1213         case TEX_PLUGIN:
1214                 retval= plugintex(tex, texvec, dxt, dyt, osatex, texres);
1215                 break;
1216         case TEX_ENVMAP:
1217                 retval= envmaptex(tex, texvec, dxt, dyt, osatex, texres);
1218                 break;
1219         case TEX_MUSGRAVE:
1220                 /* newnoise: musgrave types */
1221
1222                 /* ton: added this, for Blender convention reason.
1223                  * artificer: added the use of tmpvec to avoid scaling texvec
1224                  */
1225                 copy_v3_v3(tmpvec, texvec);
1226                 mul_v3_fl(tmpvec, 1.0f/tex->noisesize);
1227
1228                 switch (tex->stype) {
1229                 case TEX_MFRACTAL:
1230                 case TEX_FBM:
1231                         retval= mg_mFractalOrfBmTex(tex, tmpvec, texres);
1232                         break;
1233                 case TEX_RIDGEDMF:
1234                 case TEX_HYBRIDMF:
1235                         retval= mg_ridgedOrHybridMFTex(tex, tmpvec, texres);
1236                         break;
1237                 case TEX_HTERRAIN:
1238                         retval= mg_HTerrainTex(tex, tmpvec, texres);
1239                         break;
1240                 }
1241                 break;
1242         /* newnoise: voronoi type */
1243         case TEX_VORONOI:
1244                 /* ton: added this, for Blender convention reason.
1245                  * artificer: added the use of tmpvec to avoid scaling texvec
1246                  */
1247                 copy_v3_v3(tmpvec, texvec);
1248                 mul_v3_fl(tmpvec, 1.0f/tex->noisesize);
1249
1250                 retval= voronoiTex(tex, tmpvec, texres);
1251                 break;
1252         case TEX_DISTNOISE:
1253                 /* ton: added this, for Blender convention reason.
1254                  * artificer: added the use of tmpvec to avoid scaling texvec
1255                  */
1256                 copy_v3_v3(tmpvec, texvec);
1257                 mul_v3_fl(tmpvec, 1.0f/tex->noisesize);
1258
1259                 retval= mg_distNoiseTex(tex, tmpvec, texres);
1260                 break;
1261         case TEX_POINTDENSITY:
1262                 retval= pointdensitytex(tex, texvec, texres);
1263                 break;
1264         case TEX_VOXELDATA:
1265                 retval= voxeldatatex(tex, texvec, texres);
1266                 break;
1267         case TEX_OCEAN:
1268                 retval= ocean_texture(tex, texvec, texres);
1269                 break;
1270         }
1271
1272         if (tex->flag & TEX_COLORBAND) {
1273                 float col[4];
1274                 if (do_colorband(tex->coba, texres->tin, col)) {
1275                         texres->talpha= 1;
1276                         texres->tr= col[0];
1277                         texres->tg= col[1];
1278                         texres->tb= col[2];
1279                         texres->ta= col[3];
1280                         retval |= TEX_RGB;
1281                 }
1282         }
1283         return retval;
1284 }
1285
1286 /* this is called from the shader and texture nodes */
1287 int multitex_nodes(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex, TexResult *texres, short thread, short which_output, ShadeInput *shi, MTex *mtex)
1288 {
1289         if (tex==NULL) {
1290                 memset(texres, 0, sizeof(TexResult));
1291                 return 0;
1292         }
1293
1294         if (mtex)
1295                 which_output= mtex->which_output;
1296
1297         if (tex->type==TEX_IMAGE) {
1298                 int rgbnor;
1299
1300                 if (mtex) {
1301                         /* we have mtex, use it for 2d mapping images only */
1302                         do_2d_mapping(mtex, texvec, shi->vlr, shi->facenor, dxt, dyt);
1303                         rgbnor= multitex(tex, texvec, dxt, dyt, osatex, texres, thread, which_output);
1304
1305                         if (mtex->mapto & (MAP_COL+MAP_COLSPEC+MAP_COLMIR)) {
1306                                 ImBuf *ibuf = BKE_image_get_ibuf(tex->ima, &tex->iuser);
1307
1308                                 /* don't linearize float buffers, assumed to be linear */
1309                                 if (ibuf && !(ibuf->rect_float) && R.r.color_mgt_flag & R_COLOR_MANAGEMENT)
1310                                         srgb_to_linearrgb_v3_v3(&texres->tr, &texres->tr);
1311                         }
1312                 }
1313                 else {
1314                         /* we don't have mtex, do default flat 2d projection */
1315                         MTex localmtex;
1316                         float texvec_l[3], dxt_l[3], dyt_l[3];
1317
1318                         localmtex.mapping= MTEX_FLAT;
1319                         localmtex.tex= tex;
1320                         localmtex.object= NULL;
1321                         localmtex.texco= TEXCO_ORCO;
1322
1323                         copy_v3_v3(texvec_l, texvec);
1324                         if (dxt && dyt) {
1325                                 copy_v3_v3(dxt_l, dxt);
1326                                 copy_v3_v3(dyt_l, dyt);
1327                         }
1328                         else {
1329                                 zero_v3(dxt_l);
1330                                 zero_v3(dyt_l);
1331                         }
1332
1333                         do_2d_mapping(&localmtex, texvec_l, NULL, NULL, dxt_l, dyt_l);
1334                         rgbnor= multitex(tex, texvec_l, dxt_l, dyt_l, osatex, texres, thread, which_output);
1335                 }
1336
1337                 return rgbnor;
1338         }
1339         else
1340                 return multitex(tex, texvec, dxt, dyt, osatex, texres, thread, which_output);
1341 }
1342
1343 /* this is called for surface shading */
1344 int multitex_mtex(ShadeInput *shi, MTex *mtex, float *texvec, float *dxt, float *dyt, TexResult *texres)
1345 {
1346         Tex *tex= mtex->tex;
1347
1348         if (tex->use_nodes && tex->nodetree) {
1349                 /* stupid exception here .. but we have to pass shi and mtex to
1350                  * textures nodes for 2d mapping and color management for images */
1351                 return ntreeTexExecTree(tex->nodetree, texres, texvec, dxt, dyt, shi->osatex, shi->thread,
1352                         tex, mtex->which_output, R.r.cfra, (R.r.scemode & R_TEXNODE_PREVIEW) != 0, shi, mtex);
1353         }
1354         else
1355                 return multitex(mtex->tex, texvec, dxt, dyt, shi->osatex, texres, shi->thread, mtex->which_output);
1356 }
1357
1358 /* Warning, if the texres's values are not declared zero, check the return value to be sure
1359  * the color values are set before using the r/g/b values, otherwise you may use uninitialized values - Campbell */
1360 int multitex_ext(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex, TexResult *texres)
1361 {
1362         return multitex_nodes(tex, texvec, dxt, dyt, osatex, texres, 0, 0, NULL, NULL);
1363 }
1364
1365 /* extern-tex doesn't support nodes (ntreeBeginExec() can't be called when rendering is going on) */
1366 int multitex_ext_safe(Tex *tex, float *texvec, TexResult *texres)
1367 {
1368         int use_nodes= tex->use_nodes, retval;
1369
1370         tex->use_nodes = FALSE;
1371         retval= multitex_nodes(tex, texvec, NULL, NULL, 0, texres, 0, 0, NULL, NULL);
1372         tex->use_nodes= use_nodes;
1373
1374         return retval;
1375 }
1376
1377
1378 /* ------------------------------------------------------------------------- */
1379
1380 /* in = destination, tex = texture, out = previous color */
1381 /* fact = texture strength, facg = button strength value */
1382 void texture_rgb_blend(float in[3], const float tex[3], const float out[3], float fact, float facg, int blendtype)
1383 {
1384         float facm, col;
1385
1386         switch (blendtype) {
1387         case MTEX_BLEND:
1388                 fact*= facg;
1389                 facm= 1.0f-fact;
1390
1391                 in[0]= (fact*tex[0] + facm*out[0]);
1392                 in[1]= (fact*tex[1] + facm*out[1]);
1393                 in[2]= (fact*tex[2] + facm*out[2]);
1394                 break;
1395
1396         case MTEX_MUL:
1397                 fact*= facg;
1398                 facm= 1.0f-facg;
1399                 in[0]= (facm+fact*tex[0])*out[0];
1400                 in[1]= (facm+fact*tex[1])*out[1];
1401                 in[2]= (facm+fact*tex[2])*out[2];
1402                 break;
1403
1404         case MTEX_SCREEN:
1405                 fact*= facg;
1406                 facm= 1.0f-facg;
1407                 in[0]= 1.0f - (facm+fact*(1.0f-tex[0])) * (1.0f-out[0]);
1408                 in[1]= 1.0f - (facm+fact*(1.0f-tex[1])) * (1.0f-out[1]);
1409                 in[2]= 1.0f - (facm+fact*(1.0f-tex[2])) * (1.0f-out[2]);
1410                 break;
1411
1412         case MTEX_OVERLAY:
1413                 fact*= facg;
1414                 facm= 1.0f-facg;
1415
1416                 if (out[0] < 0.5f)
1417                         in[0] = out[0] * (facm + 2.0f*fact*tex[0]);
1418                 else
1419                         in[0] = 1.0f - (facm + 2.0f*fact*(1.0f - tex[0])) * (1.0f - out[0]);
1420                 if (out[1] < 0.5f)
1421                         in[1] = out[1] * (facm + 2.0f*fact*tex[1]);
1422                 else
1423                         in[1] = 1.0f - (facm + 2.0f*fact*(1.0f - tex[1])) * (1.0f - out[1]);
1424                 if (out[2] < 0.5f)
1425                         in[2] = out[2] * (facm + 2.0f*fact*tex[2]);
1426                 else
1427                         in[2] = 1.0f - (facm + 2.0f*fact*(1.0f - tex[2])) * (1.0f - out[2]);
1428                 break;
1429
1430         case MTEX_SUB:
1431                 fact= -fact;
1432         case MTEX_ADD:
1433                 fact*= facg;
1434                 in[0]= (fact*tex[0] + out[0]);
1435                 in[1]= (fact*tex[1] + out[1]);
1436                 in[2]= (fact*tex[2] + out[2]);
1437                 break;
1438
1439         case MTEX_DIV:
1440                 fact*= facg;
1441                 facm= 1.0f-fact;
1442
1443                 if (tex[0]!=0.0f)
1444                         in[0]= facm*out[0] + fact*out[0]/tex[0];
1445                 if (tex[1]!=0.0f)
1446                         in[1]= facm*out[1] + fact*out[1]/tex[1];
1447                 if (tex[2]!=0.0f)
1448                         in[2]= facm*out[2] + fact*out[2]/tex[2];
1449
1450                 break;
1451
1452         case MTEX_DIFF:
1453                 fact*= facg;
1454                 facm= 1.0f-fact;
1455                 in[0]= facm*out[0] + fact*fabsf(tex[0]-out[0]);
1456                 in[1]= facm*out[1] + fact*fabsf(tex[1]-out[1]);
1457                 in[2]= facm*out[2] + fact*fabsf(tex[2]-out[2]);
1458                 break;
1459
1460         case MTEX_DARK:
1461                 fact*= facg;
1462                 facm= 1.0f-fact;
1463
1464                 col= tex[0]+((1-tex[0])*facm);
1465                 if (col < out[0]) in[0]= col; else in[0]= out[0];
1466                 col= tex[1]+((1-tex[1])*facm);
1467                 if (col < out[1]) in[1]= col; else in[1]= out[1];
1468                 col= tex[2]+((1-tex[2])*facm);
1469                 if (col < out[2]) in[2]= col; else in[2]= out[2];
1470                 break;
1471
1472         case MTEX_LIGHT:
1473                 fact*= facg;
1474
1475                 col= fact*tex[0];
1476                 if (col > out[0]) in[0]= col; else in[0]= out[0];
1477                 col= fact*tex[1];
1478                 if (col > out[1]) in[1]= col; else in[1]= out[1];
1479                 col= fact*tex[2];
1480                 if (col > out[2]) in[2]= col; else in[2]= out[2];
1481                 break;
1482
1483         case MTEX_BLEND_HUE:
1484                 fact*= facg;
1485                 copy_v3_v3(in, out);
1486                 ramp_blend(MA_RAMP_HUE, in, fact, tex);
1487                 break;
1488         case MTEX_BLEND_SAT:
1489                 fact*= facg;
1490                 copy_v3_v3(in, out);
1491                 ramp_blend(MA_RAMP_SAT, in, fact, tex);
1492                 break;
1493         case MTEX_BLEND_VAL:
1494                 fact*= facg;
1495                 copy_v3_v3(in, out);
1496                 ramp_blend(MA_RAMP_VAL, in, fact, tex);
1497                 break;
1498         case MTEX_BLEND_COLOR:
1499                 fact*= facg;
1500                 copy_v3_v3(in, out);
1501                 ramp_blend(MA_RAMP_COLOR, in, fact, tex);
1502                 break;
1503         case MTEX_SOFT_LIGHT:
1504                 fact*= facg;
1505                 copy_v3_v3(in, out);
1506                 ramp_blend(MA_RAMP_SOFT, in, fact, tex);
1507                 break;
1508         case MTEX_LIN_LIGHT:
1509                 fact*= facg;
1510                 copy_v3_v3(in, out);
1511                 ramp_blend(MA_RAMP_LINEAR, in, fact, tex);
1512                 break;
1513         }
1514 }
1515
1516 float texture_value_blend(float tex, float out, float fact, float facg, int blendtype)
1517 {
1518         float in=0.0, facm, col, scf;
1519         int flip= (facg < 0.0f);
1520
1521         facg= fabsf(facg);
1522
1523         fact*= facg;
1524         facm= 1.0f-fact;
1525         if (flip) SWAP(float, fact, facm);
1526
1527         switch (blendtype) {
1528         case MTEX_BLEND:
1529                 in= fact*tex + facm*out;
1530                 break;
1531
1532         case MTEX_MUL:
1533                 facm= 1.0f-facg;
1534                 in= (facm+fact*tex)*out;
1535                 break;
1536
1537         case MTEX_SCREEN:
1538                 facm= 1.0f-facg;
1539                 in= 1.0f-(facm+fact*(1.0f-tex))*(1.0f-out);
1540                 break;
1541
1542         case MTEX_OVERLAY:
1543                 facm= 1.0f-facg;
1544                 if (out < 0.5f)
1545                         in = out * (facm + 2.0f*fact*tex);
1546                 else
1547                         in = 1.0f - (facm + 2.0f*fact*(1.0f - tex)) * (1.0f - out);
1548                 break;
1549
1550         case MTEX_SUB:
1551                 fact= -fact;
1552         case MTEX_ADD:
1553                 in= fact*tex + out;
1554                 break;
1555
1556         case MTEX_DIV:
1557                 if (tex!=0.0f)
1558                         in= facm*out + fact*out/tex;
1559                 break;
1560
1561         case MTEX_DIFF:
1562                 in= facm*out + fact*fabsf(tex-out);
1563                 break;
1564
1565         case MTEX_DARK:
1566                 col= fact*tex;
1567                 if (col < out) in= col; else in= out;
1568                 break;
1569
1570         case MTEX_LIGHT:
1571                 col= fact*tex;
1572                 if (col > out) in= col; else in= out;
1573                 break;
1574
1575         case MTEX_SOFT_LIGHT:
1576                 scf=1.0f - (1.0f - tex) * (1.0f - out);
1577                 in= facm*out + fact * ((1.0f - out) * tex * out) + (out * scf);
1578                 break;
1579
1580         case MTEX_LIN_LIGHT:
1581                 if (tex > 0.5f)
1582                         in = out + fact*(2.0f*(tex - 0.5f));
1583                 else
1584                         in = out + fact*(2.0f*tex - 1.0f);
1585                 break;
1586         }
1587
1588         return in;
1589 }
1590
1591 static void texco_mapping(ShadeInput* shi, Tex* tex, MTex* mtex, float* co, float* dx, float* dy, float* texvec, float* dxt, float* dyt)
1592 {
1593         // new: first swap coords, then map, then trans/scale
1594         if (tex->type == TEX_IMAGE) {
1595                 // placement
1596                 texvec[0] = mtex->projx ? co[mtex->projx - 1] : 0.f;
1597                 texvec[1] = mtex->projy ? co[mtex->projy - 1] : 0.f;
1598                 texvec[2] = mtex->projz ? co[mtex->projz - 1] : 0.f;
1599
1600                 if (shi->osatex) {
1601                         if (mtex->projx) {
1602                                 dxt[0] = dx[mtex->projx - 1];
1603                                 dyt[0] = dy[mtex->projx - 1];
1604                         }
1605                         else dxt[0] = dyt[0] = 0.f;
1606                         if (mtex->projy) {
1607                                 dxt[1] = dx[mtex->projy - 1];
1608                                 dyt[1] = dy[mtex->projy - 1];
1609                         }
1610                         else dxt[1] = dyt[1] = 0.f;
1611                         if (mtex->projz) {
1612                                 dxt[2] = dx[mtex->projz - 1];
1613                                 dyt[2] = dy[mtex->projz - 1];
1614                         }
1615                         else dxt[2] = dyt[2] = 0.f;
1616                 }
1617                 do_2d_mapping(mtex, texvec, shi->vlr, shi->facenor, dxt, dyt);
1618
1619                 // translate and scale
1620                 texvec[0] = mtex->size[0]*(texvec[0] - 0.5f) + mtex->ofs[0] + 0.5f;
1621                 texvec[1] = mtex->size[1]*(texvec[1] - 0.5f) + mtex->ofs[1] + 0.5f;
1622                 if (shi->osatex) {
1623                         dxt[0] = mtex->size[0]*dxt[0];
1624                         dxt[1] = mtex->size[1]*dxt[1];
1625                         dyt[0] = mtex->size[0]*dyt[0];
1626                         dyt[1] = mtex->size[1]*dyt[1];
1627                 }
1628
1629                 /* problem: repeat-mirror is not a 'repeat' but 'extend' in imagetexture.c */
1630                 // TXF: bug was here, only modify texvec when repeat mode set, old code affected other modes too.
1631                 // New texfilters solve mirroring differently so that it also works correctly when
1632                 // textures are scaled (sizeXYZ) as well as repeated. See also modification in do_2d_mapping().
1633                 // (since currently only done in osa mode, results will look incorrect without osa TODO)
1634                 if (tex->extend == TEX_REPEAT && (tex->flag & TEX_REPEAT_XMIR)) {
1635                         if (tex->texfilter == TXF_BOX)
1636                                 texvec[0] -= floorf(texvec[0]); // this line equivalent to old code, same below
1637                         else if (texvec[0] < 0.f || texvec[0] > 1.f) {
1638                                 const float tx = 0.5f*texvec[0];
1639                                 texvec[0] = 2.f*(tx - floorf(tx));
1640                                 if (texvec[0] > 1.f) texvec[0] = 2.f - texvec[0];
1641                         }
1642                 }
1643                 if (tex->extend == TEX_REPEAT && (tex->flag & TEX_REPEAT_YMIR)) {
1644                         if (tex->texfilter == TXF_BOX)
1645                                 texvec[1] -= floorf(texvec[1]);
1646                         else if (texvec[1] < 0.f || texvec[1] > 1.f) {
1647                                 const float ty = 0.5f*texvec[1];
1648                                 texvec[1] = 2.f*(ty - floorf(ty));
1649                                 if (texvec[1] > 1.f) texvec[1] = 2.f - texvec[1];
1650                         }
1651                 }
1652
1653         }
1654         else {  // procedural
1655                 // placement
1656                 texvec[0] = mtex->size[0]*(mtex->projx ? (co[mtex->projx - 1] + mtex->ofs[0]) : mtex->ofs[0]);
1657                 texvec[1] = mtex->size[1]*(mtex->projy ? (co[mtex->projy - 1] + mtex->ofs[1]) : mtex->ofs[1]);
1658                 texvec[2] = mtex->size[2]*(mtex->projz ? (co[mtex->projz - 1] + mtex->ofs[2]) : mtex->ofs[2]);
1659
1660                 if (shi->osatex) {
1661                         if (mtex->projx) {
1662                                 dxt[0] = mtex->size[0]*dx[mtex->projx - 1];
1663                                 dyt[0] = mtex->size[0]*dy[mtex->projx - 1];
1664                         }
1665                         else dxt[0] = dyt[0] = 0.f;
1666                         if (mtex->projy) {
1667                                 dxt[1] = mtex->size[1]*dx[mtex->projy - 1];
1668                                 dyt[1] = mtex->size[1]*dy[mtex->projy - 1];
1669                         }
1670                         else dxt[1] = dyt[1] = 0.f;
1671                         if (mtex->projz) {
1672                                 dxt[2] = mtex->size[2]*dx[mtex->projz - 1];
1673                                 dyt[2] = mtex->size[2]*dy[mtex->projz - 1];
1674                         }
1675                         else dxt[2]= dyt[2] = 0.f;
1676                 }
1677         }
1678 }
1679
1680 /* Bump code from 2.5 development cycle, has a number of bugs, but here for compatibility */
1681
1682 typedef struct CompatibleBump {
1683         float nu[3], nv[3], nn[3];
1684         float dudnu, dudnv, dvdnu, dvdnv;
1685         int nunvdone;
1686 } CompatibleBump;
1687
1688 static void compatible_bump_init(CompatibleBump *compat_bump)
1689 {
1690         memset(compat_bump, 0, sizeof(*compat_bump));
1691
1692         compat_bump->dudnu = 1.0f;
1693         compat_bump->dvdnv = 1.0f;
1694 }
1695
1696 static void compatible_bump_uv_derivs(CompatibleBump *compat_bump, ShadeInput *shi, MTex *mtex, int i)
1697 {
1698         // uvmapping only, calculation of normal tangent u/v partial derivatives
1699         // (should not be here, dudnu, dudnv, dvdnu & dvdnv should probably be part of ShadeInputUV struct,
1700         //  nu/nv in ShadeInput and this calculation should then move to shadeinput.c, shade_input_set_shade_texco() func.)
1701         // NOTE: test for shi->obr->ob here, since vlr/obr/obi can be 'fake' when called from fastshade(), another reason to move it..
1702         // NOTE: shi->v1 is NULL when called from displace_render_vert, assigning verts in this case is not trivial because the shi quad face side is not know.
1703         if ((mtex->texflag & MTEX_COMPAT_BUMP) && shi->obr && shi->obr->ob && shi->v1) {
1704                 if (mtex->mapto & (MAP_NORM|MAP_WARP) && !((mtex->tex->type==TEX_IMAGE) && (mtex->tex->imaflag & TEX_NORMALMAP))) {
1705                         MTFace* tf = RE_vlakren_get_tface(shi->obr, shi->vlr, i, NULL, 0);
1706                         int j1 = shi->i1, j2 = shi->i2, j3 = shi->i3;
1707
1708                         vlr_set_uv_indices(shi->vlr, &j1, &j2, &j3);
1709
1710                         // compute ortho basis around normal
1711                         if (!compat_bump->nunvdone) {
1712                                 // render normal is negated
1713                                 compat_bump->nn[0] = -shi->vn[0];
1714                                 compat_bump->nn[1] = -shi->vn[1];
1715                                 compat_bump->nn[2] = -shi->vn[2];
1716                                 ortho_basis_v3v3_v3(compat_bump->nu, compat_bump->nv, compat_bump->nn);
1717                                 compat_bump->nunvdone = TRUE;
1718                         }
1719
1720                         if (tf) {
1721                                 float *uv1 = tf->uv[j1], *uv2 = tf->uv[j2], *uv3 = tf->uv[j3];
1722                                 const float an[3] = {fabsf(compat_bump->nn[0]), fabsf(compat_bump->nn[1]), fabsf(compat_bump->nn[2])};
1723                                 const int a1 = (an[0] > an[1] && an[0] > an[2]) ? 1 : 0;
1724                                 const int a2 = (an[2] > an[0] && an[2] > an[1]) ? 1 : 2;
1725                                 const float dp1_a1 = shi->v1->co[a1] - shi->v3->co[a1];
1726                                 const float dp1_a2 = shi->v1->co[a2] - shi->v3->co[a2];
1727                                 const float dp2_a1 = shi->v2->co[a1] - shi->v3->co[a1];
1728                                 const float dp2_a2 = shi->v2->co[a2] - shi->v3->co[a2];
1729                                 const float du1 = uv1[0] - uv3[0], du2 = uv2[0] - uv3[0];
1730                                 const float dv1 = uv1[1] - uv3[1], dv2 = uv2[1] - uv3[1];
1731                                 const float dpdu_a1 = dv2*dp1_a1 - dv1*dp2_a1;
1732                                 const float dpdu_a2 = dv2*dp1_a2 - dv1*dp2_a2;
1733                                 const float dpdv_a1 = du1*dp2_a1 - du2*dp1_a1;
1734                                 const float dpdv_a2 = du1*dp2_a2 - du2*dp1_a2;
1735                                 float d = dpdu_a1*dpdv_a2 - dpdv_a1*dpdu_a2;
1736                                 float uvd = du1*dv2 - dv1*du2;
1737
1738                                 if (uvd == 0.f) uvd = 1e-5f;
1739                                 if (d == 0.f) d = 1e-5f;
1740                                 d = uvd / d;
1741
1742                                 compat_bump->dudnu = (dpdv_a2*compat_bump->nu[a1] - dpdv_a1*compat_bump->nu[a2])*d;
1743                                 compat_bump->dvdnu = (dpdu_a1*compat_bump->nu[a2] - dpdu_a2*compat_bump->nu[a1])*d;
1744                                 compat_bump->dudnv = (dpdv_a2*compat_bump->nv[a1] - dpdv_a1*compat_bump->nv[a2])*d;
1745                                 compat_bump->dvdnv = (dpdu_a1*compat_bump->nv[a2] - dpdu_a2*compat_bump->nv[a1])*d;
1746                         }
1747                 }
1748         }
1749 }
1750
1751 static int compatible_bump_compute(CompatibleBump *compat_bump, ShadeInput *shi, MTex *mtex, Tex *tex, TexResult *texres, float Tnor, float *co, float *dx, float *dy, float *texvec, float *dxt, float *dyt)
1752 {
1753         TexResult ttexr = {0, 0, 0, 0, 0, texres->talpha, NULL};        // temp TexResult
1754         float tco[3], texv[3], cd, ud, vd, du, dv, idu, idv;
1755         const int fromrgb = ((tex->type == TEX_IMAGE) || ((tex->flag & TEX_COLORBAND)!=0));
1756         const float bf = -0.04f*Tnor*mtex->norfac;
1757         int rgbnor;
1758         // disable internal bump eval
1759         float* nvec = texres->nor;
1760         texres->nor = NULL;
1761         // du & dv estimates, constant value defaults
1762         du = dv = 0.01f;
1763
1764         // compute ortho basis around normal
1765         if (!compat_bump->nunvdone) {
1766                 // render normal is negated
1767                 negate_v3_v3(compat_bump->nn, shi->vn);
1768                 ortho_basis_v3v3_v3(compat_bump->nu, compat_bump->nv, compat_bump->nn);
1769                 compat_bump->nunvdone = TRUE;
1770         }
1771
1772         // two methods, either constant based on main image resolution,
1773         // (which also works without osa, though of course not always good (or even very bad) results),
1774         // or based on tex derivative max values (osa only). Not sure which is best...
1775
1776         if (!shi->osatex && (tex->type == TEX_IMAGE) && tex->ima) {
1777                 // in case we have no proper derivatives, fall back to
1778                 // computing du/dv it based on image size
1779                 ImBuf* ibuf = BKE_image_get_ibuf(tex->ima, &tex->iuser);
1780                 if (ibuf) {
1781                         du = 1.f/(float)ibuf->x;
1782                         dv = 1.f/(float)ibuf->y;
1783                 }
1784         }
1785         else if (shi->osatex) {
1786                 // we have derivatives, can compute proper du/dv
1787                 if (tex->type == TEX_IMAGE) {   // 2d image, use u & v max. of dx/dy 2d vecs
1788                         const float adx[2] = {fabsf(dx[0]), fabsf(dx[1])};
1789                         const float ady[2] = {fabsf(dy[0]), fabsf(dy[1])};
1790                         du = MAX2(adx[0], ady[0]);
1791                         dv = MAX2(adx[1], ady[1]);
1792                 }
1793                 else {  // 3d procedural, estimate from all dx/dy elems
1794                         const float adx[3] = {fabsf(dx[0]), fabsf(dx[1]), fabsf(dx[2])};
1795                         const float ady[3] = {fabsf(dy[0]), fabsf(dy[1]), fabsf(dy[2])};
1796                         du = MAX3(adx[0], adx[1], adx[2]);
1797                         dv = MAX3(ady[0], ady[1], ady[2]);
1798                 }
1799         }
1800
1801         // center, main return value
1802         texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
1803         rgbnor = multitex_mtex(shi, mtex, texvec, dxt, dyt, texres);
1804         cd = fromrgb ? (texres->tr + texres->tg + texres->tb)*0.33333333f : texres->tin;
1805
1806         if (mtex->texco == TEXCO_UV) {
1807                 // for the uv case, use the same value for both du/dv,
1808                 // since individually scaling the normal derivatives makes them useless...
1809                 du = MIN2(du, dv);
1810                 idu = (du < 1e-5f) ? bf : (bf/du);
1811
1812                 // +u val
1813                 tco[0] = co[0] + compat_bump->dudnu*du;
1814                 tco[1] = co[1] + compat_bump->dvdnu*du;
1815                 tco[2] = 0.f;
1816                 texco_mapping(shi, tex, mtex, tco, dx, dy, texv, dxt, dyt);
1817                 multitex_mtex(shi, mtex, texv, dxt, dyt, &ttexr);
1818                 ud = idu*(cd - (fromrgb ? (ttexr.tr + ttexr.tg + ttexr.tb)*0.33333333f : ttexr.tin));
1819
1820                 // +v val
1821                 tco[0] = co[0] + compat_bump->dudnv*du;
1822                 tco[1] = co[1] + compat_bump->dvdnv*du;
1823                 tco[2] = 0.f;
1824                 texco_mapping(shi, tex, mtex, tco, dx, dy, texv, dxt, dyt);
1825                 multitex_mtex(shi, mtex, texv, dxt, dyt, &ttexr);
1826                 vd = idu*(cd - (fromrgb ? (ttexr.tr + ttexr.tg + ttexr.tb)*0.33333333f : ttexr.tin));
1827         }
1828         else {
1829                 float tu[3], tv[3];
1830
1831                 copy_v3_v3(tu, compat_bump->nu);
1832                 copy_v3_v3(tv, compat_bump->nv);
1833
1834                 idu = (du < 1e-5f) ? bf : (bf/du);
1835                 idv = (dv < 1e-5f) ? bf : (bf/dv);
1836
1837                 if ((mtex->texco == TEXCO_ORCO) && shi->obr && shi->obr->ob) {
1838                         mul_mat3_m4_v3(shi->obr->ob->imat_ren, tu);
1839                         mul_mat3_m4_v3(shi->obr->ob->imat_ren, tv);
1840                         normalize_v3(tu);
1841                         normalize_v3(tv);
1842                 }
1843                 else if (mtex->texco == TEXCO_GLOB) {
1844                         mul_mat3_m4_v3(R.viewinv, tu);
1845                         mul_mat3_m4_v3(R.viewinv, tv);
1846                 }
1847                 else if (mtex->texco == TEXCO_OBJECT && mtex->object) {
1848                         mul_mat3_m4_v3(mtex->object->imat_ren, tu);
1849                         mul_mat3_m4_v3(mtex->object->imat_ren, tv);
1850                         normalize_v3(tu);
1851                         normalize_v3(tv);
1852                 }
1853
1854                 // +u val
1855                 tco[0] = co[0] + tu[0]*du;
1856                 tco[1] = co[1] + tu[1]*du;
1857                 tco[2] = co[2] + tu[2]*du;
1858                 texco_mapping(shi, tex, mtex, tco, dx, dy, texv, dxt, dyt);
1859                 multitex_mtex(shi, mtex, texv, dxt, dyt, &ttexr);
1860                 ud = idu*(cd - (fromrgb ? (ttexr.tr + ttexr.tg + ttexr.tb)*0.33333333f : ttexr.tin));
1861
1862                 // +v val
1863                 tco[0] = co[0] + tv[0]*dv;
1864                 tco[1] = co[1] + tv[1]*dv;
1865                 tco[2] = co[2] + tv[2]*dv;
1866                 texco_mapping(shi, tex, mtex, tco, dx, dy, texv, dxt, dyt);
1867                 multitex_mtex(shi, mtex, texv, dxt, dyt, &ttexr);
1868                 vd = idv*(cd - (fromrgb ? (ttexr.tr + ttexr.tg + ttexr.tb)*0.33333333f : ttexr.tin));
1869         }
1870
1871         // bumped normal
1872         compat_bump->nu[0] += ud*compat_bump->nn[0];
1873         compat_bump->nu[1] += ud*compat_bump->nn[1];
1874         compat_bump->nu[2] += ud*compat_bump->nn[2];
1875         compat_bump->nv[0] += vd*compat_bump->nn[0];
1876         compat_bump->nv[1] += vd*compat_bump->nn[1];
1877         compat_bump->nv[2] += vd*compat_bump->nn[2];
1878         cross_v3_v3v3(nvec, compat_bump->nu, compat_bump->nv);
1879
1880         nvec[0] = -nvec[0];
1881         nvec[1] = -nvec[1];
1882         nvec[2] = -nvec[2];
1883         texres->nor = nvec;
1884
1885         rgbnor |= TEX_NOR;
1886         return rgbnor;
1887 }
1888
1889 /* Improved bump code from later in 2.5 development cycle */
1890
1891 typedef struct NTapBump {
1892         int init_done;
1893         int iPrevBumpSpace;     // 0: uninitialized, 1: objectspace, 2: texturespace, 4: viewspace
1894         // bumpmapping
1895         float vNorg[3]; // backup copy of shi->vn
1896         float vNacc[3]; // original surface normal minus the surface gradient of every bump map which is encountered
1897         float vR1[3], vR2[3]; // cross products (sigma_y, original_normal), (original_normal, sigma_x)
1898         float sgn_det; // sign of the determinant of the matrix {sigma_x, sigma_y, original_normal}
1899         float fPrevMagnitude; // copy of previous magnitude, used for multiple bumps in different spaces
1900 } NTapBump;
1901
1902 static void ntap_bump_init(NTapBump *ntap_bump)
1903 {
1904         memset(ntap_bump, 0, sizeof(*ntap_bump));
1905 }
1906
1907 static int ntap_bump_compute(NTapBump *ntap_bump, ShadeInput *shi, MTex *mtex, Tex *tex, TexResult *texres, float Tnor, float *co, float *dx, float *dy, float *texvec, float *dxt, float *dyt)
1908 {
1909         TexResult ttexr = {0, 0, 0, 0, 0, texres->talpha, NULL};        // temp TexResult
1910
1911         const int fromrgb = ((tex->type == TEX_IMAGE) || ((tex->flag & TEX_COLORBAND)!=0));
1912
1913         // The negate on Hscale is done because the
1914         // normal in the renderer points inward which corresponds
1915         // to inverting the bump map. The normals are generated
1916         // this way in calc_vertexnormals(). Should this ever change
1917         // this negate must be removed.
1918         float Hscale = -Tnor*mtex->norfac;
1919
1920         int dimx=512, dimy=512;
1921         const int imag_tspace_dimension_x = 1024;               // only used for texture space variant
1922         float aspect = 1.0f;
1923
1924         // 2 channels for 2D texture and 3 for 3D textures.
1925         const int nr_channels = (mtex->texco == TEXCO_UV)? 2 : 3;
1926         int c, rgbnor, iBumpSpace;
1927         float dHdx, dHdy;
1928         int found_deriv_map = (tex->type==TEX_IMAGE) && (tex->imaflag & TEX_DERIVATIVEMAP);
1929
1930         // disable internal bump eval in sampler, save pointer
1931         float *nvec = texres->nor;
1932         texres->nor = NULL;
1933
1934         if (found_deriv_map==0) {
1935                 if ( mtex->texflag & MTEX_BUMP_TEXTURESPACE ) {
1936                         if (tex->ima)
1937                                 Hscale *= 13.0f; // appears to be a sensible default value
1938                 }
1939                 else
1940                         Hscale *= 0.1f; // factor 0.1 proved to look like the previous bump code
1941         }
1942
1943         if ( !ntap_bump->init_done ) {
1944                 copy_v3_v3(ntap_bump->vNacc, shi->vn);
1945                 copy_v3_v3(ntap_bump->vNorg, shi->vn);
1946                 ntap_bump->fPrevMagnitude = 1.0f;
1947                 ntap_bump->iPrevBumpSpace = 0;
1948
1949                 ntap_bump->init_done = TRUE;
1950         }
1951
1952         // resolve image dimensions
1953         if (found_deriv_map || (mtex->texflag&MTEX_BUMP_TEXTURESPACE)!=0) {
1954                 ImBuf* ibuf = BKE_image_get_ibuf(tex->ima, &tex->iuser);
1955                 if (ibuf) {
1956                         dimx = ibuf->x;
1957                         dimy = ibuf->y;
1958                         aspect = ((float) dimy) / dimx;
1959                 }
1960         }
1961
1962         if (found_deriv_map) {
1963                 float dBdu, dBdv, auto_bump = 1.0f;
1964                 float s = 1;            // negate this if flipped texture coordinate
1965                 texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
1966                 rgbnor = multitex_mtex(shi, mtex, texvec, dxt, dyt, texres);
1967
1968                 if (shi->obr->ob->derivedFinal) {
1969                         auto_bump = shi->obr->ob->derivedFinal->auto_bump_scale;
1970                 }
1971
1972                 {
1973                         float fVirtDim = sqrtf(fabsf((float) (dimx*dimy)*mtex->size[0]*mtex->size[1]));
1974                         auto_bump /= MAX2(fVirtDim, FLT_EPSILON);
1975                 }
1976
1977                 // this variant using a derivative map is described here
1978                 // http://mmikkelsen3d.blogspot.com/2011/07/derivative-maps.html
1979                 dBdu = auto_bump*Hscale*dimx*(2*texres->tr-1);
1980                 dBdv = auto_bump*Hscale*dimy*(2*texres->tg-1);
1981
1982                 dHdx = dBdu*dxt[0] + s * dBdv*dxt[1];
1983                 dHdy = dBdu*dyt[0] + s * dBdv*dyt[1];
1984         }
1985         else if (!(mtex->texflag & MTEX_5TAP_BUMP)) {
1986                 // compute height derivatives with respect to output image pixel coordinates x and y
1987                 float STll[3], STlr[3], STul[3];
1988                 float Hll, Hlr, Hul;
1989
1990                 texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
1991
1992                 for (c=0; c<nr_channels; c++) {
1993                         // dx contains the derivatives (du/dx, dv/dx)
1994                         // dy contains the derivatives (du/dy, dv/dy)
1995                         STll[c] = texvec[c];
1996                         STlr[c] = texvec[c]+dxt[c];
1997                         STul[c] = texvec[c]+dyt[c];
1998                 }
1999
2000                 // clear unused derivatives
2001                 for (c=nr_channels; c<3; c++) {
2002                         STll[c] = 0.0f;
2003                         STlr[c] = 0.0f;
2004                         STul[c] = 0.0f;
2005                 }
2006
2007                 // use texres for the center sample, set rgbnor
2008                 rgbnor = multitex_mtex(shi, mtex, STll, dxt, dyt, texres);
2009                 Hll = (fromrgb) ? rgb_to_grayscale(&texres->tr) : texres->tin;
2010
2011                 // use ttexr for the other 2 taps
2012                 multitex_mtex(shi, mtex, STlr, dxt, dyt, &ttexr);
2013                 Hlr = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2014
2015                 multitex_mtex(shi, mtex, STul, dxt, dyt, &ttexr);
2016                 Hul = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2017
2018                 dHdx = Hscale*(Hlr - Hll);
2019                 dHdy = Hscale*(Hul - Hll);
2020         }
2021         else {
2022                 /* same as above, but doing 5 taps, increasing quality at cost of speed */
2023                 float STc[3], STl[3], STr[3], STd[3], STu[3];
2024                 float /* Hc, */ /* UNUSED */  Hl, Hr, Hd, Hu;
2025
2026                 texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
2027
2028                 for (c=0; c<nr_channels; c++) {
2029                         STc[c] = texvec[c];
2030                         STl[c] = texvec[c] - 0.5f*dxt[c];
2031                         STr[c] = texvec[c] + 0.5f*dxt[c];
2032                         STd[c] = texvec[c] - 0.5f*dyt[c];
2033                         STu[c] = texvec[c] + 0.5f*dyt[c];
2034                 }
2035
2036                 // clear unused derivatives
2037                 for (c=nr_channels; c<3; c++) {
2038                         STc[c] = 0.0f;
2039                         STl[c] = 0.0f;
2040                         STr[c] = 0.0f;
2041                         STd[c] = 0.0f;
2042                         STu[c] = 0.0f;
2043                 }
2044
2045                 // use texres for the center sample, set rgbnor
2046                 rgbnor = multitex_mtex(shi, mtex, STc, dxt, dyt, texres);
2047                 /* Hc = (fromrgb) ? rgb_to_grayscale(&texres->tr) : texres->tin; */ /* UNUSED */
2048
2049                 // use ttexr for the other taps
2050                 multitex_mtex(shi, mtex, STl, dxt, dyt, &ttexr);
2051                 Hl = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2052                 multitex_mtex(shi, mtex, STr, dxt, dyt, &ttexr);
2053                 Hr = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2054                 multitex_mtex(shi, mtex, STd, dxt, dyt, &ttexr);
2055                 Hd = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2056                 multitex_mtex(shi, mtex, STu, dxt, dyt, &ttexr);
2057                 Hu = (fromrgb) ? rgb_to_grayscale(&ttexr.tr) : ttexr.tin;
2058
2059                 dHdx = Hscale*(Hr - Hl);
2060                 dHdy = Hscale*(Hu - Hd);
2061         }
2062
2063         // restore pointer
2064         texres->nor = nvec;
2065
2066         /* replaced newbump with code based on listing 1 and 2 of
2067          * [Mik10] Mikkelsen M. S.: Bump Mapping Unparameterized Surfaces on the GPU.
2068          * -> http://jbit.net/~sparky/sfgrad_bump/mm_sfgrad_bump.pdf */
2069
2070         if ( mtex->texflag & MTEX_BUMP_OBJECTSPACE )
2071                 iBumpSpace = 1;
2072         else if ( mtex->texflag & MTEX_BUMP_TEXTURESPACE )
2073                 iBumpSpace = 2;
2074         else
2075                 iBumpSpace = 4; // ViewSpace
2076
2077         if ( ntap_bump->iPrevBumpSpace != iBumpSpace ) {
2078
2079                 // initialize normal perturbation vectors
2080                 int xyz;
2081                 float fDet, abs_fDet, fMagnitude;
2082                 // object2view and inverted matrix
2083                 float obj2view[3][3], view2obj[3][3], tmp[4][4];
2084                 // local copies of derivatives and normal
2085                 float dPdx[3], dPdy[3], vN[3];
2086                 copy_v3_v3(dPdx, shi->dxco);
2087                 copy_v3_v3(dPdy, shi->dyco);
2088                 copy_v3_v3(vN, ntap_bump->vNorg);
2089
2090                 if ( mtex->texflag & MTEX_BUMP_OBJECTSPACE ) {
2091                         // TODO: these calculations happen for every pixel!
2092                         //      -> move to shi->obi
2093                         mult_m4_m4m4(tmp, R.viewmat, shi->obr->ob->obmat);
2094                         copy_m3_m4(obj2view, tmp); // use only upper left 3x3 matrix
2095                         invert_m3_m3(view2obj, obj2view);
2096
2097                         // generate the surface derivatives in object space
2098                         mul_m3_v3(view2obj, dPdx);
2099                         mul_m3_v3(view2obj, dPdy);
2100                         // generate the unit normal in object space
2101                         mul_transposed_m3_v3(obj2view, vN);
2102                         normalize_v3(vN);
2103                 }
2104
2105                 cross_v3_v3v3(ntap_bump->vR1, dPdy, vN);
2106                 cross_v3_v3v3(ntap_bump->vR2, vN, dPdx);
2107                 fDet = dot_v3v3(dPdx, ntap_bump->vR1);
2108                 ntap_bump->sgn_det = (fDet < 0)? -1.0f: 1.0f;
2109                 abs_fDet = ntap_bump->sgn_det * fDet;
2110
2111                 if ( mtex->texflag & MTEX_BUMP_TEXTURESPACE ) {
2112                         if (tex->ima) {
2113                                 // crazy hack solution that gives results similar to normal mapping - part 1
2114                                 normalize_v3(ntap_bump->vR1);
2115                                 normalize_v3(ntap_bump->vR2);
2116                                 abs_fDet = 1.0f;
2117                         }
2118                 }
2119
2120                 fMagnitude = abs_fDet;
2121                 if ( mtex->texflag & MTEX_BUMP_OBJECTSPACE ) {
2122                         // pre do transform of texres->nor by the inverse transposed of obj2view
2123                         mul_transposed_m3_v3(view2obj, vN);
2124                         mul_transposed_m3_v3(view2obj, ntap_bump->vR1);
2125                         mul_transposed_m3_v3(view2obj, ntap_bump->vR2);
2126
2127                         fMagnitude *= len_v3(vN);
2128                 }
2129
2130                 if (ntap_bump->fPrevMagnitude > 0.0f)
2131                         for (xyz=0; xyz<3; xyz++)
2132                                 ntap_bump->vNacc[xyz] *= fMagnitude / ntap_bump->fPrevMagnitude;
2133
2134                 ntap_bump->fPrevMagnitude = fMagnitude;
2135                 ntap_bump->iPrevBumpSpace = iBumpSpace;
2136         }
2137
2138         if ( mtex->texflag & MTEX_BUMP_TEXTURESPACE ) {
2139                 if (tex->ima) {
2140                         // crazy hack solution that gives results similar to normal mapping - part 2
2141                         float vec[2];
2142                         const float imag_tspace_dimension_y = aspect*imag_tspace_dimension_x;
2143
2144                         vec[0] = imag_tspace_dimension_x*dxt[0];
2145                         vec[1] = imag_tspace_dimension_y*dxt[1];
2146                         dHdx *= 1.0f/len_v2(vec);
2147                         vec[0] = imag_tspace_dimension_x*dyt[0];
2148                         vec[1] = imag_tspace_dimension_y*dyt[1];
2149                         dHdy *= 1.0f/len_v2(vec);
2150                 }
2151         }
2152
2153         // subtract the surface gradient from vNacc
2154         for (c=0; c<3; c++) {
2155                 float vSurfGrad_compi = ntap_bump->sgn_det * (dHdx * ntap_bump->vR1[c] + dHdy * ntap_bump->vR2[c]);
2156                 ntap_bump->vNacc[c] -= vSurfGrad_compi;
2157                 texres->nor[c] = ntap_bump->vNacc[c]; // copy
2158         }
2159
2160         rgbnor |= TEX_NOR;
2161         return rgbnor;
2162 }
2163
2164 void do_material_tex(ShadeInput *shi, Render *re)
2165 {
2166         CompatibleBump compat_bump;
2167         NTapBump ntap_bump;
2168         MTex *mtex;
2169         Tex *tex;
2170         TexResult texres= {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0, NULL};
2171         float *co = NULL, *dx = NULL, *dy = NULL;
2172         float fact, facm, factt, facmm, stencilTin=1.0;
2173         float texvec[3], dxt[3], dyt[3], tempvec[3], norvec[3], warpvec[3]={0.0f, 0.0f, 0.0f}, Tnor=1.0;
2174         int tex_nr, rgbnor= 0, warp_done = FALSE;
2175         int use_compat_bump = FALSE, use_ntap_bump = FALSE;
2176         int found_nmapping = 0, found_deriv_map = 0;
2177         int iFirstTimeNMap=1;
2178
2179         compatible_bump_init(&compat_bump);
2180         ntap_bump_init(&ntap_bump);
2181
2182         if (re->r.scemode & R_NO_TEX) return;
2183         /* here: test flag if there's a tex (todo) */
2184
2185         for (tex_nr=0; tex_nr<MAX_MTEX; tex_nr++) {
2186
2187                 /* separate tex switching */
2188                 if (shi->mat->septex & (1<<tex_nr)) continue;
2189
2190                 if (shi->mat->mtex[tex_nr]) {
2191                         mtex= shi->mat->mtex[tex_nr];
2192
2193                         tex= mtex->tex;
2194                         if (tex==0) continue;
2195
2196                         found_deriv_map = (tex->type==TEX_IMAGE) && (tex->imaflag & TEX_DERIVATIVEMAP);
2197                         use_compat_bump= (mtex->texflag & MTEX_COMPAT_BUMP);
2198                         use_ntap_bump = ((mtex->texflag & (MTEX_3TAP_BUMP|MTEX_5TAP_BUMP|MTEX_BICUBIC_BUMP))!=0 || found_deriv_map!=0) ? TRUE : FALSE;
2199
2200                         /* XXX texture node trees don't work for this yet */
2201                         if (tex->nodetree && tex->use_nodes) {
2202                                 use_compat_bump = FALSE;
2203                                 use_ntap_bump = FALSE;
2204                         }
2205
2206                         /* case displacement mapping */
2207                         if (shi->osatex == 0 && use_ntap_bump) {
2208                                 use_ntap_bump = FALSE;
2209                                 use_compat_bump = TRUE;
2210                         }
2211
2212                         /* case ocean */
2213                         if (tex->type == TEX_OCEAN) {
2214                                 use_ntap_bump = FALSE;
2215                                 use_compat_bump = FALSE;
2216                         }
2217
2218                         /* which coords */
2219                         if (mtex->texco==TEXCO_ORCO) {
2220                                 if (mtex->texflag & MTEX_DUPLI_MAPTO) {
2221                                         co= shi->duplilo; dx= dxt; dy= dyt;
2222                                         dxt[0]= dxt[1]= dxt[2]= 0.0f;
2223                                         dyt[0]= dyt[1]= dyt[2]= 0.0f;
2224                                 }
2225                                 else {
2226                                         co= shi->lo; dx= shi->dxlo; dy= shi->dylo;
2227                                 }
2228                         }
2229                         else if (mtex->texco==TEXCO_STICKY) {
2230                                 co= shi->sticky; dx= shi->dxsticky; dy= shi->dysticky;
2231                         }
2232                         else if (mtex->texco==TEXCO_OBJECT) {
2233                                 Object *ob= mtex->object;
2234                                 if (ob) {
2235                                         co= tempvec;
2236                                         dx= dxt;
2237                                         dy= dyt;
2238                                         copy_v3_v3(tempvec, shi->co);
2239                                         if (mtex->texflag & MTEX_OB_DUPLI_ORIG)
2240                                                 if (shi->obi && shi->obi->duplitexmat)
2241                                                         mul_m4_v3(shi->obi->duplitexmat, tempvec);
2242                                         mul_m4_v3(ob->imat_ren, tempvec);
2243                                         if (shi->osatex) {
2244                                                 copy_v3_v3(dxt, shi->dxco);
2245                                                 copy_v3_v3(dyt, shi->dyco);
2246                                                 mul_mat3_m4_v3(ob->imat_ren, dxt);
2247                                                 mul_mat3_m4_v3(ob->imat_ren, dyt);
2248                                         }
2249                                 }
2250                                 else {
2251                                         /* if object doesn't exist, do not use orcos (not initialized) */
2252                                         co= shi->co;
2253                                         dx= shi->dxco; dy= shi->dyco;
2254                                 }
2255                         }
2256                         else if (mtex->texco==TEXCO_REFL) {
2257                                 calc_R_ref(shi);
2258                                 co= shi->ref; dx= shi->dxref; dy= shi->dyref;
2259                         }
2260                         else if (mtex->texco==TEXCO_NORM) {
2261                                 co= shi->orn; dx= shi->dxno; dy= shi->dyno;
2262                         }
2263                         else if (mtex->texco==TEXCO_TANGENT) {
2264                                 co= shi->tang; dx= shi->dxno; dy= shi->dyno;
2265                         }
2266                         else if (mtex->texco==TEXCO_GLOB) {
2267                                 co= shi->gl; dx= shi->dxgl; dy= shi->dygl;
2268                         }
2269                         else if (mtex->texco==TEXCO_UV) {
2270                                 if (mtex->texflag & MTEX_DUPLI_MAPTO) {
2271                                         co= shi->dupliuv; dx= dxt; dy= dyt;
2272                                         dxt[0]= dxt[1]= dxt[2]= 0.0f;
2273                                         dyt[0]= dyt[1]= dyt[2]= 0.0f;
2274                                 }
2275                                 else {
2276                                         ShadeInputUV *suv= &shi->uv[shi->actuv];
2277                                         int i = shi->actuv;
2278
2279                                         if (mtex->uvname[0] != 0) {
2280                                                 for (i = 0; i < shi->totuv; i++) {
2281                                                         if (strcmp(shi->uv[i].name, mtex->uvname)==0) {
2282                                                                 suv= &shi->uv[i];
2283                                                                 break;
2284                                                         }
2285                                                 }
2286                                         }
2287
2288                                         co= suv->uv;
2289                                         dx= suv->dxuv;
2290                                         dy= suv->dyuv;
2291
2292                                         compatible_bump_uv_derivs(&compat_bump, shi, mtex, i);
2293                                 }
2294                         }
2295                         else if (mtex->texco==TEXCO_WINDOW) {
2296                                 co= shi->winco; dx= shi->dxwin; dy= shi->dywin;
2297                         }
2298                         else if (mtex->texco==TEXCO_STRAND) {
2299                                 co= tempvec; dx= dxt; dy= dyt;
2300                                 co[0]= shi->strandco;
2301                                 co[1]= co[2]= 0.0f;
2302                                 dx[0]= shi->dxstrand;
2303                                 dx[1]= dx[2]= 0.0f;
2304                                 dy[0]= shi->dystrand;
2305                                 dy[1]= dy[2]= 0.0f;
2306                         }
2307                         else if (mtex->texco==TEXCO_STRESS) {
2308                                 co= tempvec; dx= dxt; dy= dyt;
2309                                 co[0]= shi->stress;
2310                                 co[1]= co[2]= 0.0f;
2311                                 dx[0]= 0.0f;
2312                                 dx[1]= dx[2]= 0.0f;
2313                                 dy[0]= 0.0f;
2314                                 dy[1]= dy[2]= 0.0f;
2315                         }
2316                         else continue;  // can happen when texco defines disappear and it renders old files
2317
2318                         /* the pointer defines if bumping happens */
2319                         if (mtex->mapto & (MAP_NORM|MAP_WARP)) {
2320                                 texres.nor= norvec;
2321                                 norvec[0]= norvec[1]= norvec[2]= 0.0;
2322                         }
2323                         else texres.nor= NULL;
2324
2325                         if (warp_done) {
2326                                 add_v3_v3v3(tempvec, co, warpvec);
2327                                 co= tempvec;
2328                         }
2329
2330                         /* XXX texture node trees don't work for this yet */
2331                         if (texres.nor && !((tex->type==TEX_IMAGE) && (tex->imaflag & TEX_NORMALMAP))) {
2332                                 if (use_compat_bump) {
2333                                         rgbnor = compatible_bump_compute(&compat_bump, shi, mtex, tex,
2334                                                 &texres, Tnor*stencilTin, co, dx, dy, texvec, dxt, dyt);
2335                                 }
2336                                 else if (use_ntap_bump) {
2337                                         rgbnor = ntap_bump_compute(&ntap_bump, shi, mtex, tex,
2338                                                 &texres, Tnor*stencilTin, co, dx, dy, texvec, dxt, dyt);
2339                                 }
2340                                 else {
2341                                         texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
2342                                         rgbnor = multitex_mtex(shi, mtex, texvec, dxt, dyt, &texres);
2343                                 }
2344                         }
2345                         else {
2346                                 texco_mapping(shi, tex, mtex, co, dx, dy, texvec, dxt, dyt);
2347                                 rgbnor = multitex_mtex(shi, mtex, texvec, dxt, dyt, &texres);
2348                         }
2349
2350                         /* texture output */
2351
2352                         if ( (rgbnor & TEX_RGB) && (mtex->texflag & MTEX_RGBTOINT)) {
2353                                 texres.tin = rgb_to_grayscale(&texres.tr);
2354                                 rgbnor -= TEX_RGB;
2355                         }
2356                         if (mtex->texflag & MTEX_NEGATIVE) {
2357                                 if (rgbnor & TEX_RGB) {
2358                                         texres.tr= 1.0f-texres.tr;
2359                                         texres.tg= 1.0f-texres.tg;
2360                                         texres.tb= 1.0f-texres.tb;
2361                                 }
2362                                 texres.tin= 1.0f-texres.tin;
2363                         }
2364                         if (mtex->texflag & MTEX_STENCIL) {
2365                                 if (rgbnor & TEX_RGB) {
2366                                         fact= texres.ta;
2367                                         texres.ta*= stencilTin;
2368                                         stencilTin*= fact;
2369                                 }
2370                                 else {
2371                                         fact= texres.tin;
2372                                         texres.tin*= stencilTin;
2373                                         stencilTin*= fact;
2374                                 }
2375                         }
2376                         else {
2377                                 Tnor*= stencilTin;
2378                         }
2379
2380                         if (texres.nor) {
2381                                 if ((rgbnor & TEX_NOR)==0) {
2382                                         /* make our own normal */
2383                                         if (rgbnor & TEX_RGB) {
2384                                                 copy_v3_v3(texres.nor, &texres.tr);
2385                                         }
2386                                         else {
2387                                                 float co_nor= 0.5*cos(texres.tin-0.5f);
2388                                                 float si= 0.5*sin(texres.tin-0.5f);
2389                                                 float f1, f2;
2390
2391                                                 f1= shi->vn[0];
2392                                                 f2= shi->vn[1];
2393                                                 texres.nor[0]= f1*co_nor+f2*si;
2394                                                 f1= shi->vn[1];
2395                                                 f2= shi->vn[2];
2396                                                 texres.nor[1]= f1*co_nor+f2*si;
2397                                                 texres.nor[2]= f2*co_nor-f1*si;
2398                                         }
2399                                 }
2400                                 // warping, local space
2401                                 if (mtex->mapto & MAP_WARP) {
2402                                         float *warpnor= texres.nor, warpnor_[3];
2403
2404                                         if (use_ntap_bump) {
2405                                                 copy_v3_v3(warpnor_, texres.nor);
2406                                                 warpnor= warpnor_;
2407                                                 normalize_v3(warpnor_);
2408                                         }
2409                                         warpvec[0]= mtex->warpfac*warpnor[0];
2410                                         warpvec[1]= mtex->warpfac*warpnor[1];
2411                                         warpvec[2]= mtex->warpfac*warpnor[2];
2412                                         warp_done = TRUE;
2413                                 }
2414 #if 0
2415                                 if (mtex->texflag & MTEX_VIEWSPACE) {
2416                                         // rotate to global coords
2417                                         if (mtex->texco==TEXCO_ORCO || mtex->texco==TEXCO_UV) {
2418                                                 if (shi->vlr && shi->obr && shi->obr->ob) {
2419                                                         float len= normalize_v3(texres.nor);
2420                                                         // can be optimized... (ton)
2421                                                         mul_mat3_m4_v3(shi->obr->ob->obmat, texres.nor);
2422                                                         mul_mat3_m4_v3(re->viewmat, texres.nor);
2423                                                         normalize_v3(texres.nor);
2424                                                         mul_v3_fl(texres.nor, len);
2425                                                 }
2426                                         }
2427                                 }
2428 #endif
2429                         }
2430
2431                         /* mapping */
2432                         if (mtex->mapto & (MAP_COL | MAP_COLSPEC | MAP_COLMIR)) {
2433                                 float tcol[3];
2434
2435                                 /* stencil maps on the texture control slider, not texture intensity value */
2436                                 copy_v3_v3(tcol, &texres.tr);
2437
2438                                 if ((rgbnor & TEX_RGB) == 0) {
2439                                         copy_v3_v3(tcol, &mtex->r);
2440                                 }
2441                                 else if (mtex->mapto & MAP_ALPHA) {
2442                                         texres.tin = stencilTin;
2443                                 }
2444                                 else {
2445                                         texres.tin = texres.ta;
2446                                 }
2447
2448                                 /* inverse gamma correction */
2449                                 if (tex->type==TEX_IMAGE) {
2450                                         Image *ima = tex->ima;
2451                                         ImBuf *ibuf = BKE_image_get_ibuf(ima, &tex->iuser);
2452
2453                                         /* don't linearize float buffers, assumed to be linear */
2454                                         if (ibuf && !(ibuf->rect_float) && re->r.color_mgt_flag & R_COLOR_MANAGEMENT)
2455                                                 srgb_to_linearrgb_v3_v3(tcol, tcol);
2456                                 }
2457
2458                                 if (mtex->mapto & MAP_COL) {
2459                                         float colfac= mtex->colfac*stencilTin;
2460                                         texture_rgb_blend(&shi->r, tcol, &shi->r, texres.tin, colfac, mtex->blendtype);
2461                                 }
2462                                 if (mtex->mapto & MAP_COLSPEC) {
2463                                         float colspecfac= mtex->colspecfac*stencilTin;
2464                                         texture_rgb_blend(&shi->specr, tcol, &shi->specr, texres.tin, colspecfac, mtex->blendtype);
2465                                 }
2466                                 if (mtex->mapto & MAP_COLMIR) {
2467                                         float mirrfac= mtex->mirrfac*stencilTin;
2468
2469                                         // exception for envmap only
2470                                         if (tex->type==TEX_ENVMAP && mtex->blendtype==MTEX_BLEND) {
2471                                                 fact= texres.tin*mirrfac;
2472                                                 facm= 1.0f- fact;
2473                                                 shi->refcol[0]= fact + facm*shi->refcol[0];
2474                                                 shi->refcol[1]= fact*tcol[0] + facm*shi->refcol[1];
2475                                                 shi->refcol[2]= fact*tcol[1] + facm*shi->refcol[2];
2476                                                 shi->refcol[3]= fact*tcol[2] + facm*shi->refcol[3];
2477                                         }
2478                                         else {
2479                                                 texture_rgb_blend(&shi->mirr, tcol, &shi->mirr, texres.tin, mirrfac, mtex->blendtype);
2480                                         }
2481                                 }
2482                         }
2483                         if ( (mtex->mapto & MAP_NORM) ) {
2484                                 if (texres.nor) {
2485                                         float norfac= mtex->norfac;
2486
2487                                         /* we need to code blending modes for normals too once.. now 1 exception hardcoded */
2488
2489                                         if ((tex->type==TEX_IMAGE) && (tex->imaflag & TEX_NORMALMAP)) {
2490
2491                                                 found_nmapping = 1;
2492
2493                                                 /* qdn: for normalmaps, to invert the normalmap vector,
2494                                                  * it is better to negate x & y instead of subtracting the vector as was done before */
2495                                                 if (norfac < 0.0f) {
2496                                                         texres.nor[0] = -texres.nor[0];
2497                                                         texres.nor[1] = -texres.nor[1];
2498                                                 }
2499                                                 fact = Tnor*fabsf(norfac);
2500                                                 if (fact>1.f) fact = 1.f;
2501                                                 facm = 1.f-fact;
2502                                                 if (mtex->normapspace == MTEX_NSPACE_TANGENT) {
2503                                                         /* qdn: tangent space */
2504                                                         float B[3], tv[3];
2505                                                         const float * no = iFirstTimeNMap!=0 ? shi->nmapnorm : shi->vn;
2506                                                         iFirstTimeNMap=0;
2507                                                         cross_v3_v3v3(B, no, shi->nmaptang);    /* bitangent */
2508                                                         mul_v3_fl(B, shi->nmaptang[3]);
2509                                                         /* transform norvec from tangent space to object surface in camera space */
2510                                                         tv[0] = texres.nor[0]*shi->nmaptang[0] + texres.nor[1]*B[0] + texres.nor[2]*no[0];
2511                                                         tv[1] = texres.nor[0]*shi->nmaptang[1] + texres.nor[1]*B[1] + texres.nor[2]*no[1];
2512                                                         tv[2] = texres.nor[0]*shi->nmaptang[2] + texres.nor[1]*B[2] + texres.nor[2]*no[2];
2513                                                         shi->vn[0]= facm*no[0] + fact*tv[0];
2514                                                         shi->vn[1]= facm*no[1] + fact*tv[1];
2515                                                         shi->vn[2]= facm*no[2] + fact*tv[2];
2516                                                 }
2517                                                 else {
2518                                                         float nor[3];
2519
2520                                                         copy_v3_v3(nor, texres.nor);
2521
2522                                                         if (mtex->normapspace == MTEX_NSPACE_CAMERA);
2523                                                         else if (mtex->normapspace == MTEX_NSPACE_WORLD) {
2524                                                                 mul_mat3_m4_v3(re->viewmat, nor);
2525                                                         }
2526                                                         else if (mtex->normapspace == MTEX_NSPACE_OBJECT) {
2527                                                                 if (shi->obr && shi->obr->ob)
2528                                                                         mul_mat3_m4_v3(shi->obr->ob->obmat, nor);
2529                                                                 mul_mat3_m4_v3(re->viewmat, nor);
2530                                                         }
2531
2532                                                         normalize_v3(nor);
2533
2534                                                         /* qdn: worldspace */
2535                                                         shi->vn[0]= facm*shi->vn[0] + fact*nor[0];
2536                                                         shi->vn[1]= facm*shi->vn[1] + fact*nor[1];
2537                                                         shi->vn[2]= facm*shi->vn[2] + fact*nor[2];
2538                                                 }
2539                                         }
2540                                         else {
2541                                                 /* XXX texture node trees don't work for this yet */
2542                                                 if (use_compat_bump || use_ntap_bump) {
2543                                                         shi->vn[0] = texres.nor[0];
2544                                                         shi->vn[1] = texres.nor[1];
2545                                                         shi->vn[2] = texres.nor[2];
2546                                                 }
2547                                                 else {
2548                                                         float nor[3], dot;
2549
2550                                                         if (shi->mat->mode & MA_TANGENT_V) {
2551                                                                 shi->tang[0]+= Tnor*norfac*texres.nor[0];
2552                                                                 shi->tang[1]+= Tnor*norfac*texres.nor[1];
2553                                                                 shi->tang[2]+= Tnor*norfac*texres.nor[2];
2554                                                         }
2555
2556                                                         /* prevent bump to become negative normal */
2557                                                         nor[0]= Tnor*norfac*texres.nor[0];
2558                                                         nor[1]= Tnor*norfac*texres.nor[1];
2559                                                         nor[2]= Tnor*norfac*texres.nor[2];
2560
2561                                                         dot= 0.5f + 0.5f * dot_v3v3(nor, shi->vn);
2562
2563                                                         shi->vn[0]+= dot*nor[0];
2564                                                         shi->vn[1]+= dot*nor[1];
2565                                                         shi->vn[2]+= dot*nor[2];
2566                                                 }
2567                                         }
2568                                         normalize_v3(shi->vn);
2569
2570                                         /* this makes sure the bump is passed on to the next texture */
2571                                         shi->orn[0]= -shi->vn[0];
2572                                         shi->orn[1]= -shi->vn[1];
2573                                         shi->orn[2]= -shi->vn[2];
2574                                 }
2575                         }
2576
2577                         if ( mtex->mapto & MAP_DISPLACE ) {
2578                                 /* Now that most textures offer both Nor and Intensity, allow  */
2579                                 /* both to work, and let user select with slider.   */
2580                                 if (texres.nor) {
2581                                         float norfac= mtex->norfac;
2582
2583                                         shi->displace[0]+= 0.2f*Tnor*norfac*texres.nor[0];
2584                                         shi->displace[1]+= 0.2f*Tnor*norfac*texres.nor[1];
2585                                         shi->displace[2]+= 0.2f*Tnor*norfac*texres.nor[2];
2586                                 }
2587
2588                                 if (rgbnor & TEX_RGB) {
2589                                         texres.tin = rgb_to_grayscale(&texres.tr);
2590                                 }
2591
2592                                 factt= (0.5f-texres.tin)*mtex->dispfac*stencilTin; facmm= 1.0f-factt;
2593
2594                                 if (mtex->blendtype==MTEX_BLEND) {
2595                                         shi->displace[0]= factt*shi->vn[0] + facmm*shi->displace[0];
2596                                         shi->displace[1]= factt*shi->vn[1] + facmm*shi->displace[1];
2597                                         shi->displace[2]= factt*shi->vn[2] + facmm*shi->displace[2];
2598                                 }
2599                                 else if (mtex->blendtype==MTEX_MUL) {
2600                                         shi->displace[0]*= factt*shi->vn[0];
2601                                         shi->displace[1]*= factt*shi->vn[1];
2602                                         shi->displace[2]*= factt*shi->vn[2];
2603                                 }
2604                                 else { /* add or sub */
2605                                         if (mtex->blendtype==MTEX_SUB) factt= -factt;
2606                                         shi->displace[0]+= factt*shi->vn[0];
2607                                         shi->displace[1]+= factt*shi->vn[1];
2608                                         shi->displace[2]+= factt*shi->vn[2];
2609                                 }
2610                         }
2611
2612                         if (mtex->mapto & MAP_VARS) {
2613                                 /* stencil maps on the texture control slider, not texture intensity value */
2614
2615                                 if (rgbnor & TEX_RGB) {
2616                                         if (texres.talpha) texres.tin = texres.ta;
2617                                         else               texres.tin = rgb_to_grayscale(&texres.tr);
2618                                 }
2619
2620                                 if (mtex->mapto & MAP_REF) {
2621                                         float difffac= mtex->difffac*stencilTin;
2622
2623                                         shi->refl= texture_value_blend(mtex->def_var, shi->refl, texres.tin, difffac, mtex->blendtype);
2624                                         if (shi->refl<0.0f) shi->refl= 0.0f;
2625                                 }
2626                                 if (mtex->mapto & MAP_SPEC) {
2627                                         float specfac= mtex->specfac*stencilTin;
2628
2629                                         shi->spec= texture_value_blend(mtex->def_var, shi->spec, texres.tin, specfac, mtex->blendtype);
2630                                         if (shi->spec<0.0f) shi->spec= 0.0f;
2631                                 }
2632                                 if (mtex->mapto & MAP_EMIT) {
2633                                         float emitfac= mtex->emitfac*stencilTin;
2634
2635                                         shi->emit= texture_value_blend(mtex->def_var, shi->emit, texres.tin, emitfac, mtex->blendtype);
2636                                         if (shi->emit<0.0f) shi->emit= 0.0f;
2637                                 }
2638                                 if (mtex->mapto & MAP_ALPHA) {
2639                                         float alphafac= mtex->alphafac*stencilTin;
2640
2641                                         shi->alpha= texture_value_blend(mtex->def_var, shi->alpha, texres.tin, alphafac, mtex->blendtype);
2642                                         if (shi->alpha<0.0f) shi->alpha= 0.0f;
2643                                         else if (shi->alpha>1.0f) shi->alpha= 1.0f;
2644                                 }
2645                                 if (mtex->mapto & MAP_HAR) {
2646                                         float har;  // have to map to 0-1
2647                                         float hardfac= mtex->hardfac*stencilTin;
2648
2649                                         har= ((float)shi->har)/128.0f;
2650                                         har= 128.0f*texture_value_blend(mtex->def_var, har, texres.tin, hardfac, mtex->blendtype);
2651
2652                                         if (har<1.0f) shi->har= 1;
2653                                         else if (har>511) shi->har= 511;
2654                                         else shi->har= (int)har;
2655                                 }
2656                                 if (mtex->mapto & MAP_RAYMIRR) {
2657                                         float raymirrfac= mtex->raymirrfac*stencilTin;
2658
2659                                         shi->ray_mirror= texture_value_blend(mtex->def_var, shi->ray_mirror, texres.tin, raymirrfac, mtex->blendtype);
2660                                         if (shi->ray_mirror<0.0f) shi->ray_mirror= 0.0f;
2661                                         else if (shi->ray_mirror>1.0f) shi->ray_mirror= 1.0f;
2662                                 }
2663                                 if (mtex->mapto & MAP_TRANSLU) {
2664                                         float translfac= mtex->translfac*stencilTin;
2665
2666                                         shi->translucency= texture_value_blend(mtex->def_var, shi->translucency, texres.tin, translfac, mtex->blendtype);
2667                                         if (shi->translucency<0.0f) shi->translucency= 0.0f;
2668                                         else if (shi->translucency>1.0f) shi->translucency= 1.0f;
2669                                 }
2670                                 if (mtex->mapto & MAP_AMB) {
2671                                         float ambfac= mtex->ambfac*stencilTin;
2672
2673                                         shi->amb= texture_value_blend(mtex->def_var, shi->amb, texres.tin, ambfac, mtex->blendtype);
2674                                         if (shi->amb<0.0f) shi->amb= 0.0f;
2675                                         else if (shi->amb>1.0f) shi->amb= 1.0f;
2676
2677                                         shi->ambr= shi->amb*re->wrld.ambr;
2678                                         shi->ambg= shi->amb*re->wrld.ambg;
2679                                         shi->ambb= shi->amb*re->wrld.ambb;
2680                                 }
2681                         }
2682                 }
2683         }
2684         if ((use_compat_bump || use_ntap_bump || found_nmapping) && (shi->mat->mode & MA_TANGENT_V) != 0) {
2685                 const float fnegdot = -dot_v3v3(shi->vn, shi->tang);
2686                 // apply Gram-Schmidt projection
2687                 madd_v3_v3fl(shi->tang,  shi->vn, fnegdot);
2688                 normalize_v3(shi->tang);
2689         }
2690 }
2691
2692
2693 void do_volume_tex(ShadeInput *shi, const float *xyz, int mapto_flag, float col_r[3], float *val, Render *re)
2694 {
2695         MTex *mtex;
2696         Tex *tex;
2697         TexResult texres= {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0, NULL};
2698         int tex_nr, rgbnor= 0;
2699         float co[3], texvec[3];
2700         float fact, stencilTin=1.0;
2701
2702         if (re->r.scemode & R_NO_TEX) return;
2703         /* here: test flag if there's a tex (todo) */
2704
2705         for (tex_nr=0; tex_nr<MAX_MTEX; tex_nr++) {
2706                 /* separate tex switching */
2707                 if (shi->mat->septex & (1<<tex_nr)) continue;
2708
2709                 if (shi->mat->mtex[tex_nr]) {
2710