gfx/povray/normal.c

   1 /****************************************************************************
   2 *                normal.c
   3 *
   4 *  This module implements solid texturing functions that perturb the surface
   5 *  normal to create a bumpy effect.
   6 *
   7 *  from Persistence of Vision(tm) Ray Tracer
   8 *  Copyright 1996,1999 Persistence of Vision Team
   9 *---------------------------------------------------------------------------
  10 *  NOTICE: This source code file is provided so that users may experiment
  11 *  with enhancements to POV-Ray and to port the software to platforms other
  12 *  than those supported by the POV-Ray Team.  There are strict rules under
  13 *  which you are permitted to use this file.  The rules are in the file
  14 *  named POVLEGAL.DOC which should be distributed with this file.
  15 *  If POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  16 *  Team Coordinator by email to team-coord@povray.org or visit us on the web at
  17 *  http://www.povray.org. The latest version of POV-Ray may be found at this site.
  18 *
  19 * This program is based on the popular DKB raytracer version 2.12.
  20 * DKBTrace was originally written by David K. Buck.
  21 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  22 *
  23 *****************************************************************************/
  24
  25 /*
  26  * Some texture ideas garnered from SIGGRAPH '85 Volume 19 Number 3,
  27  * "An Image Synthesizer" By Ken Perlin.
  28  *
  29  * Further Ideas Garnered from "The RenderMan Companion" (Addison Wesley)
  30  */
  31
  32 #include "frame.h"
  33 #include "vector.h"
  34 #include "povproto.h"
  35 #include "texture.h"
  36 #include "image.h"
  37 #include "matrices.h"
  38 #include "normal.h"
  39 #include "povray.h"
  40 #include "txttest.h"
  41 #include "pigment.h"
  42
  43
  44
  45 /*****************************************************************************
  46 * Local preprocessor defines
  47 ******************************************************************************/
  48
  49
  50
  51 /*****************************************************************************
  52 * Local typedefs
  53 ******************************************************************************/
  54
  55
  56
  57 /*****************************************************************************
  58 * Local constants
  59 ******************************************************************************/
  60
  61 static CONST
  62 VECTOR Pyramid_Vect [4]= {{ 0.942809041,-0.333333333, 0.0},
  63                           {-0.471404521,-0.333333333, 0.816496581},
  64                           {-0.471404521,-0.333333333,-0.816496581},
  65                           { 0.0        , 1.0        , 0.0}};
  66
  67
  68 /*****************************************************************************
  69 * Static functions
  70 ******************************************************************************/
  71
  72 static void ripples (VECTOR EPoint, TNORMAL *Tnormal, VECTOR Vector);
  73 static void waves (VECTOR EPoint, TNORMAL *Tnormal, VECTOR Vector);
  74 static void bumps (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal);
  75 static void dents (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal);
  76 static void wrinkles (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal);
  77 static void quilted (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal);
  78 static DBL Hermite_Cubic (DBL T1,UV_VECT UV1,UV_VECT UV2);
  79 static DBL Do_Slope_Map (DBL value, BLEND_MAP *Blend_Map);
  80 static void Do_Average_Normals (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal);
  81
  82
  83 /*****************************************************************************
  84 *
  85 * FUNCTION
  86 *
  87 *   ripples
  88 *
  89 * INPUT
  90 *
  91 * OUTPUT
  92 *
  93 * RETURNS
  94 *
  95 * AUTHOR
  96 *
  97 *   POV-Ray Team
  98 *
  99 * DESCRIPTION
 100 *
 101 * CHANGES
 102 *
 103 ******************************************************************************/
 104
 105 static void ripples (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 106 {
 107   register unsigned int i;
 108   register DBL length, scalar, index;
 109   VECTOR point;
 110
 111   for (i = 0 ; i < Number_Of_Waves ; i++)
 112   {
 113     VSub (point, EPoint, Wave_Sources[i]);
 114     VLength (length, point);
 115
 116     if (length == 0.0)
 117       length = 1.0;
 118
 119     index = length * Tnormal->Frequency + Tnormal->Phase;
 120
 121     scalar = cycloidal(index) * Tnormal ->Amount;
 122
 123     VAddScaledEq(normal, scalar / (length * (DBL)Number_Of_Waves), point);
 124   }
 125 }
 126
 127
 128
 129 /*****************************************************************************
 130 *
 131 * FUNCTION
 132 *
 133 *   waves
 134 *
 135 * INPUT
 136 *
 137 * OUTPUT
 138 *
 139 * RETURNS
 140 *
 141 * AUTHOR
 142 *
 143 *   POV-Ray Team
 144 *
 145 * DESCRIPTION
 146 *
 147 * CHANGES
 148 *
 149 ******************************************************************************/
 150
 151 static void waves (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 152 {
 153   register unsigned int i;
 154   register DBL length, scalar, index, sinValue ;
 155   VECTOR point;
 156
 157   for (i = 0 ; i < Number_Of_Waves ; i++)
 158   {
 159     VSub (point, EPoint, Wave_Sources[i]);
 160
 161     VLength (length, point);
 162
 163     if (length == 0.0)
 164     {
 165       length = 1.0;
 166     }
 167
 168     index = length * Tnormal->Frequency * frequency[i] + Tnormal->Phase;
 169
 170     sinValue = cycloidal(index);
 171
 172     scalar = sinValue * Tnormal->Amount / frequency[i];
 173
 174     VAddScaledEq(normal, scalar / (length * (DBL)Number_Of_Waves), point);
 175   }
 176 }
 177
 178
 179
 180 /*****************************************************************************
 181 *
 182 * FUNCTION
 183 *
 184 *   bumps
 185 *
 186 * INPUT
 187 *
 188 * OUTPUT
 189 *
 190 * RETURNS
 191 *
 192 * AUTHOR
 193 *
 194 *   POV-Ray Team
 195 *
 196 * DESCRIPTION
 197 *
 198 * CHANGES
 199 *
 200 ******************************************************************************/
 201
 202 static void bumps (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 203 {
 204   VECTOR bump_turb;
 205
 206   /* Get normal displacement value. */
 207
 208   DNoise (bump_turb, EPoint);
 209
 210   /* Displace "normal". */
 211
 212   VAddScaledEq(normal, Tnormal->Amount, bump_turb);
 213 }
 214
 215
 216
 217 /*****************************************************************************
 218 *
 219 * FUNCTION
 220 *
 221 * INPUT
 222 *
 223 * OUTPUT
 224 *
 225 * RETURNS
 226 *
 227 * AUTHOR
 228 *
 229 *   POV-Ray Team
 230 *
 231 * DESCRIPTION
 232 *   Dents is similar to bumps, but uses noise() to control the amount of
 233 *   dnoise() perturbation of the object normal...
 234 *
 235 * CHANGES
 236 *
 237 ******************************************************************************/
 238
 239 static void dents (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 240 {
 241   DBL noise;
 242   VECTOR stucco_turb;
 243
 244   noise = Noise (EPoint);
 245
 246   noise = noise * noise * noise * Tnormal->Amount;
 247
 248   /* Get normal displacement value. */
 249
 250   DNoise(stucco_turb, EPoint);
 251
 252   /* Displace "normal". */
 253
 254   VAddScaledEq(normal, noise, stucco_turb);
 255 }
 256
 257
 258
 259
 260 /*****************************************************************************
 261 *
 262 * FUNCTION
 263 *
 264 * INPUT
 265 *
 266 * OUTPUT
 267 *
 268 * RETURNS
 269 *
 270 * AUTHOR
 271 *
 272 *   POV-Ray Team
 273 *
 274 * DESCRIPTION
 275 *
 276 *   Wrinkles - This is my implementation of the dented() routine, using
 277 *   a surface iterative fractal derived from DTurbulence.
 278 *
 279 *   This is a 3-D version (thanks to DNoise()...) of the usual version
 280 *   using the singular Noise()...
 281 *
 282 *   Seems to look a lot like wrinkles, however... (hmmm)
 283 *
 284 *   Idea garnered from the April 89 Byte Graphics Supplement on RenderMan,
 285 *   refined from "The RenderMan Companion, by Steve Upstill of Pixar,
 286 *   (C) 1990 Addison-Wesley.
 287 *
 288 * CHANGES
 289 *
 290 ******************************************************************************/
 291
 292 static void wrinkles (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 293 {
 294   register int i;
 295   register DBL scale = 1.0;
 296   VECTOR result, value, value2;
 297
 298   Make_Vector(result, 0.0, 0.0, 0.0);
 299
 300   for (i = 0; i < 10; scale *= 2.0, i++)
 301   {
 302     VScale(value2,EPoint,scale);
 303     DNoise(value, value2);
 304
 305     result[X] += fabs(value[X] / scale);
 306     result[Y] += fabs(value[Y] / scale);
 307     result[Z] += fabs(value[Z] / scale);
 308   }
 309
 310   /* Displace "normal". */
 311
 312   VAddScaledEq(normal, Tnormal->Amount, result);
 313 }
 314
 315
 316 /*****************************************************************************
 317 *
 318 * FUNCTION
 319 *
 320 *   quilted
 321 *
 322 * INPUT
 323 *
 324 * OUTPUT
 325 *
 326 * RETURNS
 327 *
 328 * AUTHOR
 329 *
 330 *   Dan Farmer '94
 331 *
 332 * DESCRIPTION
 333 *
 334 * CHANGES
 335 *
 336 ******************************************************************************/
 337
 338 static void quilted (VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
 339 {
 340   VECTOR value;
 341   DBL t;
 342
 343   value[X] = EPoint[X]-FLOOR(EPoint[X])-0.5;
 344   value[Y] = EPoint[Y]-FLOOR(EPoint[Y])-0.5;
 345   value[Z] = EPoint[Z]-FLOOR(EPoint[Z])-0.5;
 346
 347   t = sqrt(value[X]*value[X]+value[Y]*value[Y]+value[Z]*value[Z]);
 348
 349   t = quilt_cubic(t, Tnormal->Vals.Quilted.Control0, Tnormal->Vals.Quilted.Control1);
 350
 351   value[X] *= t;
 352   value[Y] *= t;
 353   value[Z] *= t;
 354
 355   VAddScaledEq (normal, Tnormal->Amount,value);
 356 }
 357
 358 /*****************************************************************************
 359 *
 360 * FUNCTION
 361 *
 362 *   Create_Tnormal
 363 *
 364 * INPUT
 365 *
 366 * OUTPUT
 367 *
 368 * RETURNS
 369 *
 370 *   pointer to the created Tnormal
 371 *
 372 * AUTHOR
 373 *
 374 *   POV-Ray Team
 375 *
 376 * DESCRIPTION   : Allocate memory for new Tnormal and initialize it to
 377 *                 system default values.
 378 *
 379 * CHANGES
 380 *
 381 ******************************************************************************/
 382
 383
 384 TNORMAL *Create_Tnormal ()
 385 {
 386   TNORMAL *New;
 387
 388   New = (TNORMAL *)POV_MALLOC(sizeof(TNORMAL), "normal");
 389
 390   Init_TPat_Fields((TPATTERN *)New);
 391
 392   New->Amount = 0.5;
 393
 394   return (New);
 395 }
 396
 397
 398
 399 /*****************************************************************************
 400 *
 401 * FUNCTION
 402 *
 403 *   Copy_Tnormal
 404 *
 405 * INPUT
 406 *
 407 * OUTPUT
 408 *
 409 * RETURNS
 410 *
 411 * AUTHOR
 412 *
 413 *   POV-Ray Team
 414 *
 415 * DESCRIPTION
 416 *
 417 * CHANGES
 418 *
 419 ******************************************************************************/
 420
 421 TNORMAL *Copy_Tnormal (TNORMAL *Old)
 422 {
 423   TNORMAL *New;
 424
 425   if (Old != NULL)
 426   {
 427     New = Create_Tnormal();
 428
 429     Copy_TPat_Fields ((TPATTERN *)New, (TPATTERN *)Old);
 430
 431     New->Amount = Old->Amount;
 432   }
 433   else
 434   {
 435     New = NULL;
 436   }
 437
 438   return (New);
 439 }
 440
 441
 442
 443 /*****************************************************************************
 444 *
 445 * FUNCTION
 446 *
 447 *   Destroy_Tnormal
 448 *
 449 * INPUT
 450 *
 451 * OUTPUT
 452 *
 453 * RETURNS
 454 *
 455 * AUTHOR
 456 *
 457 *   POV-Ray Team
 458 *
 459 * DESCRIPTION
 460 *
 461 * CHANGES
 462 *
 463 ******************************************************************************/
 464
 465 void Destroy_Tnormal(TNORMAL *Tnormal)
 466 {
 467   if (Tnormal != NULL)
 468   {
 469     Destroy_TPat_Fields ((TPATTERN *)Tnormal);
 470
 471     POV_FREE(Tnormal);
 472   }
 473 }
 474
 475
 476
 477 /*****************************************************************************
 478 *
 479 * FUNCTION
 480 *
 481 *   Post_Tnormal
 482 *
 483 * INPUT
 484 *
 485 * OUTPUT
 486 *
 487 * RETURNS
 488 *
 489 * AUTHOR
 490 *
 491 *   POV-Ray Team
 492 *
 493 * DESCRIPTION
 494 *
 495 * CHANGES
 496 *
 497 ******************************************************************************/
 498
 499 void Post_Tnormal (TNORMAL *Tnormal)
 500 {
 501   int i;
 502   BLEND_MAP *Map;
 503
 504   if (Tnormal != NULL)
 505   {
 506     if (Tnormal->Flags & POST_DONE)
 507     {
 508       return;
 509     }
 510
 511     if (Tnormal->Type == NO_PATTERN)
 512     {
 513       Error("No normal type given.");
 514     }
 515
 516     Tnormal->Flags |= POST_DONE;
 517
 518     if ((Map = Tnormal->Blend_Map) != NULL)
 519     {
 520       for (i = 0; i < Map->Number_Of_Entries; i++)
 521       {
 522         switch (Map->Type)
 523         {
 524           case PIGMENT_TYPE:
 525
 526             Post_Pigment(Map->Blend_Map_Entries[i].Vals.Pigment);
 527
 528             break;
 529
 530           case NORMAL_TYPE:
 531
 532             Post_Tnormal(Map->Blend_Map_Entries[i].Vals.Tnormal);
 533
 534             break;
 535
 536           case TEXTURE_TYPE:
 537
 538             Post_Textures(Map->Blend_Map_Entries[i].Vals.Texture);
 539
 540             break;
 541
 542           case SLOPE_TYPE:
 543           case COLOUR_TYPE:
 544           case PATTERN_TYPE:
 545
 546             break;
 547
 548           default:
 549
 550             Error("Unknown pattern type in Post_Tnormal.");
 551         }
 552       }
 553     }
 554   }
 555 }
 556
 557
 558
 559 /*****************************************************************************
 560 *
 561 * FUNCTION
 562 *
 563 *   Perturb_Normal
 564 *
 565 * INPUT
 566 *
 567 * OUTPUT
 568 *
 569 * RETURNS
 570 *
 571 * AUTHOR
 572 *
 573 *   POV-Ray Team
 574 *
 575 * DESCRIPTION
 576 *
 577 * CHANGES
 578 *
 579 ******************************************************************************/
 580
 581 #define DELTA 0.02
 582
 583 void Perturb_Normal(VECTOR Layer_Normal, TNORMAL *Tnormal, VECTOR  EPoint)
 584 {
 585   VECTOR TPoint,P1;
 586   DBL value1,value2,Amount;
 587   int i;
 588   BLEND_MAP *Blend_Map;
 589   BLEND_MAP_ENTRY *Prev, *Cur;
 590
 591   if (Tnormal==NULL)
 592   {
 593     return;
 594   }
 595
 596   /* If normal_map present, use it and return */
 597
 598   if ((Blend_Map=Tnormal->Blend_Map) != NULL)
 599   {
 600     if ((Blend_Map->Type == NORMAL_TYPE) && (Tnormal->Type != AVERAGE_PATTERN))
 601     {
 602       value1 = Evaluate_TPat((TPATTERN *)Tnormal,EPoint);
 603
 604       Search_Blend_Map (value1,Blend_Map,&Prev,&Cur);
 605
 606       Assign_Vector(P1,Layer_Normal);
 607
 608       Warp_EPoint (TPoint, EPoint, (TPATTERN *)Tnormal);
 609       Perturb_Normal(Layer_Normal,Cur->Vals.Tnormal,TPoint);
 610
 611       if (Prev != Cur)
 612       {
 613         Perturb_Normal(P1,Prev->Vals.Tnormal,TPoint);
 614
 615         value2 = (value1-Prev->value)/(Cur->value-Prev->value);
 616         value1 = 1.0-value2;
 617
 618         VLinComb2(Layer_Normal,value1,P1,value2,Layer_Normal)
 619       }
 620
 621       VNormalizeEq(Layer_Normal);
 622
 623       return;
 624     }
 625   }
 626
 627   /* No normal_map. */
 628
 629   if (Tnormal->Type <= LAST_NORM_ONLY_PATTERN)
 630   {
 631     Warp_EPoint (TPoint, EPoint, (TPATTERN *)Tnormal);
 632     switch (Tnormal->Type)
 633       {
 634        case BITMAP_PATTERN: bump_map (TPoint, Tnormal, Layer_Normal); break;
 635        case BUMPS_PATTERN:  bumps (TPoint, Tnormal, Layer_Normal);    break;
 636        case DENTS_PATTERN:  dents (TPoint, Tnormal, Layer_Normal);    break;
 637        case RIPPLES_PATTERN:ripples (TPoint, Tnormal, Layer_Normal);  break;
 638        case WAVES_PATTERN:  waves (TPoint, Tnormal, Layer_Normal);    break;
 639        case WRINKLES_PATTERN:wrinkles (TPoint, Tnormal, Layer_Normal);break;
 640        case QUILTED_PATTERN:quilted (TPoint, Tnormal, Layer_Normal);  break;
 641        case AVERAGE_PATTERN: Do_Average_Normals (TPoint, Tnormal, Layer_Normal);  break;
 642        default:
 643          Error("Normal pattern not yet implemented.");
 644       }
 645   }
 646   else
 647   {
 648     Amount=Tnormal->Amount * -5.0; /*fudge factor*/
 649
 650 /* Note, even though DELTA and Pyramid_Vect are constants, we may later
 651    make DELTA a user-defined parameter.  Good optimising compilers
 652    should merge the constants anyway. */
 653
 654     for(i=0; i<=3; i++)
 655     {
 656       VAddScaled(P1,EPoint,DELTA,Pyramid_Vect[i]);
 657       value1 = Do_Slope_Map(Evaluate_TPat((TPATTERN *)Tnormal,P1),Blend_Map);
 658       VAddScaledEq(Layer_Normal,value1*Amount,Pyramid_Vect[i]);
 659     }
 660
 661   }
 662
 663   VNormalizeEq(Layer_Normal);
 664 }
 665
 666
 667
 668 /*****************************************************************************
 669 *
 670 * FUNCTION
 671 *
 672 * INPUT
 673 *
 674 * OUTPUT
 675 *
 676 * RETURNS
 677 *
 678 * AUTHOR
 679 *
 680 * DESCRIPTION
 681 *
 682 * CHANGES
 683 *
 684 ******************************************************************************/
 685
 686 static DBL Do_Slope_Map (DBL value,BLEND_MAP *Blend_Map)
 687 {
 688   DBL Result;
 689   BLEND_MAP_ENTRY *Prev, *Cur;
 690
 691   if (Blend_Map == NULL)
 692   {
 693     return(value);
 694   }
 695
 696   Search_Blend_Map (value,Blend_Map,&Prev,&Cur);
 697
 698   if (Prev == Cur)
 699   {
 700      return(Cur->Vals.Point_Slope[0]);
 701   }
 702
 703   Result = (value-Prev->value)/(Cur->value-Prev->value);
 704
 705   return(Hermite_Cubic(Result,Prev->Vals.Point_Slope,Cur->Vals.Point_Slope));
 706 }
 707
 708
 709
 710 /*****************************************************************************
 711 *
 712 * FUNCTION
 713 *
 714 * INPUT
 715 *
 716 * OUTPUT
 717 *
 718 * RETURNS
 719 *
 720 * AUTHOR
 721 *
 722 * DESCRIPTION
 723 *
 724 * CHANGES
 725 *
 726 ******************************************************************************/
 727
 728 #define S1 UV1[1]
 729 #define S2 UV2[1]
 730 #define P1 UV1[0]
 731 #define P2 UV2[0]
 732
 733 static DBL Hermite_Cubic(DBL T1,UV_VECT UV1,UV_VECT UV2)
 734 {
 735   DBL TT=T1*T1;
 736   DBL TTT=TT*T1;
 737   DBL rv;        /* simplified equation for poor Symantec */
 738
 739   rv  = TTT*(S1+S2+2.0*(P1-P2));
 740   rv += -TT*(2.0*S1+S2+3.0*(P1-P2));
 741   rv += T1*S1 +P1;
 742
 743   return (rv);
 744 }
 745
 746
 747
 748 /*****************************************************************************
 749 *
 750 * FUNCTION
 751 *
 752 * INPUT
 753 *
 754 * OUTPUT
 755 *
 756 * RETURNS
 757 *
 758 * AUTHOR
 759 *
 760 * DESCRIPTION
 761 *
 762 * CHANGES
 763 *
 764 ******************************************************************************/
 765
 766 static void Do_Average_Normals (VECTOR EPoint,TNORMAL *Tnormal,VECTOR normal)
 767 {
 768    int i;
 769    BLEND_MAP *Map = Tnormal->Blend_Map;
 770    SNGL Value;
 771    SNGL Total = 0.0;
 772    VECTOR V1,V2;
 773
 774    Make_Vector (V1, 0.0, 0.0, 0.0);
 775
 776    for (i = 0; i < Map->Number_Of_Entries; i++)
 777    {
 778      Value = Map->Blend_Map_Entries[i].value;
 779
 780      Assign_Vector(V2,normal);
 781
 782      Perturb_Normal(V2,Map->Blend_Map_Entries[i].Vals.Tnormal,EPoint);
 783
 784      VAddScaledEq(V1,Value,V2);
 785
 786      Total += Value;
 787    }
 788
 789    VInverseScale(normal,V1,Total);
 790 }