gfx/povray/colour.c

   1 /****************************************************************************
   2 *                   colour.c
   3 *
   4 *  This module implements routines to manipulate colours.
   5 *
   6 *  from Persistence of Vision(tm) Ray Tracer
   7 *  Copyright 1996,1999 Persistence of Vision Team
   8 *---------------------------------------------------------------------------
   9 *  NOTICE: This source code file is provided so that users may experiment
  10 *  with enhancements to POV-Ray and to port the software to platforms other
  11 *  than those supported by the POV-Ray Team.  There are strict rules under
  12 *  which you are permitted to use this file.  The rules are in the file
  13 *  named POVLEGAL.DOC which should be distributed with this file.
  14 *  If POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  15 *  Team Coordinator by email to team-coord@povray.org or visit us on the web at
  16 *  http://www.povray.org. The latest version of POV-Ray may be found at this site.
  17 *
  18 * This program is based on the popular DKB raytracer version 2.12.
  19 * DKBTrace was originally written by David K. Buck.
  20 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21 *
  22 *****************************************************************************/
  23
  24 #include "frame.h"
  25 #include "vector.h"
  26 #include "povproto.h"
  27 #include "colour.h"
  28 #include "pigment.h"
  29 #include "normal.h"
  30 #include "texture.h"
  31
  32
  33 /*****************************************************************************
  34 * Local preprocessor defines
  35 ******************************************************************************/
  36
  37
  38
  39 /*****************************************************************************
  40 * Local typedefs
  41 ******************************************************************************/
  42
  43
  44
  45 /*****************************************************************************
  46 * Local variables
  47 ******************************************************************************/
  48
  49
  50 /*****************************************************************************
  51 * Static functions
  52 ******************************************************************************/
  53
  54
  55
  56 /*****************************************************************************
  57 *
  58 * FUNCTION
  59 *
  60 * INPUT
  61 *
  62 * OUTPUT
  63 *
  64 * RETURNS
  65 *
  66 * AUTHOR
  67 *
  68 *   POV-Ray Team
  69 *
  70 * DESCRIPTION
  71 *
  72 *   -
  73 *
  74 * CHANGES
  75 *
  76 *   -
  77 *
  78 ******************************************************************************/
  79
  80 COLOUR *Create_Colour ()
  81 {
  82   COLOUR *New;
  83
  84   New = (COLOUR *)POV_MALLOC(sizeof (COLOUR), "color");
  85
  86   Make_Colour (*New, 0.0, 0.0, 0.0);
  87
  88   return (New);
  89 }
  90
  91
  92
  93 /*****************************************************************************
  94 *
  95 * FUNCTION
  96 *
  97 * INPUT
  98 *
  99 * OUTPUT
 100 *
 101 * RETURNS
 102 *
 103 * AUTHOR
 104 *
 105 *   POV-Ray Team
 106 *
 107 * DESCRIPTION
 108 *
 109 *   -
 110 *
 111 * CHANGES
 112 *
 113 *   -
 114 *
 115 ******************************************************************************/
 116
 117 COLOUR *Copy_Colour (COLOUR Old)
 118 {
 119   COLOUR *New;
 120
 121   if (Old != NULL)
 122   {
 123     New = Create_Colour ();
 124
 125     Assign_Colour(*New,Old);
 126   }
 127   else
 128   {
 129     New = NULL;
 130   }
 131
 132   return (New);
 133 }
 134
 135
 136
 137 /*****************************************************************************
 138 *
 139 * FUNCTION
 140 *
 141 * INPUT
 142 *
 143 * OUTPUT
 144 *
 145 * RETURNS
 146 *
 147 * AUTHOR
 148 *
 149 *   POV-Ray Team
 150 *
 151 * DESCRIPTION
 152 *
 153 *   -
 154 *
 155 * CHANGES
 156 *
 157 *   Aug 1995 : Use POV_CALLOC to initialize entries. [DB]
 158 *
 159 ******************************************************************************/
 160
 161 BLEND_MAP_ENTRY *Create_BMap_Entries (int Map_Size)
 162 {
 163   BLEND_MAP_ENTRY *New;
 164
 165   New = (BLEND_MAP_ENTRY *)POV_CALLOC((size_t)Map_Size, sizeof (BLEND_MAP_ENTRY), "blend map entry");
 166
 167   return (New);
 168 }
 169
 170
 171
 172 /*****************************************************************************
 173 *
 174 * FUNCTION
 175 *
 176 * INPUT
 177 *
 178 * OUTPUT
 179 *
 180 * RETURNS
 181 *
 182 * AUTHOR
 183 *
 184 *   POV-Ray Team
 185 *
 186 * DESCRIPTION
 187 *
 188 *
 189 * CHANGES
 190 *
 191 ******************************************************************************/
 192
 193 BLEND_MAP_ENTRY *Copy_BMap_Entries (BLEND_MAP_ENTRY *Old, int Map_Size, int  Type)
 194 {
 195   int i;
 196   BLEND_MAP_ENTRY *New;
 197
 198   if (Old != NULL)
 199   {
 200     New = Create_BMap_Entries (Map_Size);
 201
 202     for (i = 0; i < Map_Size; i++)
 203     {
 204       switch (Type)
 205       {
 206         case PIGMENT_TYPE:
 207
 208           New[i].Vals.Pigment = Copy_Pigment(Old[i].Vals.Pigment);
 209
 210           break;
 211
 212         case NORMAL_TYPE:
 213
 214           New[i].Vals.Tnormal = Copy_Tnormal(Old[i].Vals.Tnormal);
 215
 216           break;
 217
 218         case TEXTURE_TYPE:
 219
 220           New[i].Vals.Texture = Copy_Textures(Old[i].Vals.Texture);
 221
 222           break;
 223
 224         case COLOUR_TYPE:
 225         case SLOPE_TYPE:
 226
 227           New[i] = Old[i];
 228
 229           break;
 230       }
 231     }
 232   }
 233   else
 234   {
 235     New = NULL;
 236   }
 237
 238   return (New);
 239 }
 240
 241
 242
 243 /*****************************************************************************
 244 *
 245 * FUNCTION
 246 *
 247 *   Create_Blend_Map
 248 *
 249 * INPUT
 250 *
 251 * OUTPUT
 252 *
 253 * RETURNS
 254 *
 255 * AUTHOR
 256 *
 257 *   POV-Ray Team
 258 *
 259 * DESCRIPTION
 260 *
 261 *   -
 262 *
 263 * CHANGES
 264 *
 265 *   -
 266 *
 267 ******************************************************************************/
 268
 269 BLEND_MAP *Create_Blend_Map ()
 270 {
 271   BLEND_MAP *New;
 272
 273   New = (BLEND_MAP *)POV_MALLOC(sizeof (BLEND_MAP), "blend map");
 274
 275   New->Users = 1;
 276
 277   New->Number_Of_Entries = 0;
 278
 279   New->Type = COLOUR_TYPE;
 280
 281   New->Blend_Map_Entries = NULL;
 282
 283   New->Transparency_Flag = FALSE;
 284
 285   return (New);
 286 }
 287
 288
 289
 290 /*****************************************************************************
 291 *
 292 * FUNCTION
 293 *
 294 *   Copy_Blend_Map
 295 *
 296 * INPUT
 297 *
 298 * OUTPUT
 299 *
 300 * RETURNS
 301 *
 302 * AUTHOR
 303 *
 304 *   POV-Ray Team
 305 *
 306 * DESCRIPTION
 307 *
 308 *   -
 309 *
 310 * CHANGES
 311 *
 312 *   -
 313 *
 314 ******************************************************************************/
 315
 316 BLEND_MAP *Copy_Blend_Map (BLEND_MAP *Old)
 317 {
 318   BLEND_MAP *New;
 319
 320   New = Old;
 321
 322   /*
 323    * Do not increase the users field if it is negative.
 324    *
 325    * A negative users field incicates a reference to a static
 326    * or global memory area in the data segment, not on the heap!
 327    * Thus it must not be deleted later.
 328    */
 329
 330   if ((New != NULL) && (New->Users >= 0))
 331   {
 332     New->Users++;
 333   }
 334
 335   return (New);
 336 }
 337
 338
 339
 340 /*****************************************************************************
 341 *
 342 * FUNCTION
 343 *
 344 *   Colour_Distance
 345 *
 346 * INPUT
 347 *
 348 * OUTPUT
 349 *
 350 * RETURNS
 351 *
 352 * AUTHOR
 353 *
 354 *   POV-Ray Team
 355 *
 356 * DESCRIPTION
 357 *
 358 *   -
 359 *
 360 * CHANGES
 361 *
 362 *   -
 363 *
 364 ******************************************************************************/
 365
 366 DBL Colour_Distance (COLOUR colour1, COLOUR  colour2)
 367 {
 368   return (fabs(colour1[RED]   - colour2[RED]) +
 369           fabs(colour1[GREEN] - colour2[GREEN]) +
 370           fabs(colour1[BLUE]  - colour2[BLUE]));
 371 }
 372
 373
 374
 375 /*****************************************************************************
 376 *
 377 * FUNCTION
 378 *
 379 *   Add_Colour
 380 *
 381 * INPUT
 382 *
 383 * OUTPUT
 384 *
 385 * RETURNS
 386 *
 387 * AUTHOR
 388 *
 389 *   POV-Ray Team
 390 *
 391 * DESCRIPTION
 392 *
 393 *   -
 394 *
 395 * CHANGES
 396 *
 397 *   -
 398 *
 399 ******************************************************************************/
 400
 401 void Add_Colour (COLOUR result, COLOUR  colour1, COLOUR  colour2)
 402 {
 403   result[RED]    = colour1[RED]    + colour2[RED];
 404   result[GREEN]  = colour1[GREEN]  + colour2[GREEN];
 405   result[BLUE]   = colour1[BLUE]   + colour2[BLUE];
 406   result[FILTER] = colour1[FILTER] + colour2[FILTER];
 407   result[TRANSM] = colour1[TRANSM] + colour2[TRANSM];
 408 }
 409
 410
 411
 412 /*****************************************************************************
 413 *
 414 * FUNCTION
 415 *
 416 *   Scale_Colour
 417 *
 418 * INPUT
 419 *
 420 * OUTPUT
 421 *
 422 * RETURNS
 423 *
 424 * AUTHOR
 425 *
 426 *   POV-Ray Team
 427 *
 428 * DESCRIPTION
 429 *
 430 *   -
 431 *
 432 * CHANGES
 433 *
 434 *   -
 435 *
 436 ******************************************************************************/
 437
 438 void Scale_Colour (COLOUR result, COLOUR  colour, DBL factor)
 439 {
 440   result[RED]    = colour[RED]    * factor;
 441   result[GREEN]  = colour[GREEN]  * factor;
 442   result[BLUE]   = colour[BLUE]   * factor;
 443   result[FILTER] = colour[FILTER] * factor;
 444   result[TRANSM] = colour[TRANSM] * factor;
 445 }
 446
 447
 448
 449 /*****************************************************************************
 450 *
 451 * FUNCTION
 452 *
 453 *   Clip_Colour
 454 *
 455 * INPUT
 456 *
 457 * OUTPUT
 458 *
 459 * RETURNS
 460 *
 461 * AUTHOR
 462 *
 463 *   POV-Ray Team
 464 *
 465 * DESCRIPTION
 466 *
 467 *   -
 468 *
 469 * CHANGES
 470 *
 471 *   -
 472 *
 473 ******************************************************************************/
 474
 475 void Clip_Colour (COLOUR result, COLOUR  colour)
 476 {
 477   if (colour[RED] > 1.0)
 478   {
 479     result[RED] = 1.0;
 480   }
 481   else
 482   {
 483     if (colour[RED] < 0.0)
 484     {
 485       result[RED] = 0.0;
 486     }
 487     else
 488     {
 489       result[RED] = colour[RED];
 490     }
 491   }
 492
 493   if (colour[GREEN] > 1.0)
 494   {
 495     result[GREEN] = 1.0;
 496   }
 497   else
 498   {
 499     if (colour[GREEN] < 0.0)
 500     {
 501       result[GREEN] = 0.0;
 502     }
 503     else
 504     {
 505       result[GREEN] = colour[GREEN];
 506     }
 507   }
 508
 509   if (colour[BLUE] > 1.0)
 510   {
 511     result[BLUE] = 1.0;
 512   }
 513   else
 514   {
 515     if (colour[BLUE] < 0.0)
 516     {
 517       result[BLUE] = 0.0;
 518     }
 519     else
 520     {
 521       result[BLUE] = colour[BLUE];
 522     }
 523   }
 524
 525   if (colour[FILTER] > 1.0)
 526   {
 527     result[FILTER] = 1.0;
 528   }
 529   else
 530   {
 531     if (colour[FILTER] < 0.0)
 532     {
 533       result[FILTER] = 0.0;
 534     }
 535     else
 536     {
 537       result[FILTER] = colour[FILTER];
 538     }
 539   }
 540
 541   if (colour[TRANSM] > 1.0)
 542   {
 543     result[TRANSM] = 1.0;
 544   }
 545   else
 546   {
 547     if (colour[TRANSM] < 0.0)
 548     {
 549       result[TRANSM] = 0.0;
 550     }
 551     else
 552     {
 553       result[TRANSM] = colour[TRANSM];
 554     }
 555   }
 556 }
 557
 558
 559
 560 /*****************************************************************************
 561 *
 562 * FUNCTION
 563 *
 564 *   Destroy_Blend_Map
 565 *
 566 * INPUT
 567 *
 568 * OUTPUT
 569 *
 570 * RETURNS
 571 *
 572 * AUTHOR
 573 *
 574 *   POV-Ray Team
 575 *
 576 * DESCRIPTION
 577 *
 578 *   -
 579 *
 580 * CHANGES
 581 *
 582 *   -
 583 *
 584 ******************************************************************************/
 585
 586 void Destroy_Blend_Map (BLEND_MAP *BMap)
 587 {
 588   int i;
 589
 590   if (BMap != NULL)
 591   {
 592     if (--(BMap->Users) == 0)
 593     {
 594       for (i = 0; i < BMap->Number_Of_Entries; i++)
 595       {
 596         switch (BMap->Type)
 597         {
 598            case PIGMENT_TYPE:
 599            case DENSITY_TYPE:
 600              Destroy_Pigment(BMap->Blend_Map_Entries[i].Vals.Pigment);
 601              break;
 602
 603            case NORMAL_TYPE:
 604              Destroy_Tnormal(BMap->Blend_Map_Entries[i].Vals.Tnormal);
 605              break;
 606
 607            case TEXTURE_TYPE:
 608              Destroy_Textures(BMap->Blend_Map_Entries[i].Vals.Texture);
 609         }
 610       }
 611
 612       POV_FREE (BMap->Blend_Map_Entries);
 613
 614       POV_FREE (BMap);
 615     }
 616   }
 617 }
 618