gfx/povray/boxes.c

   1 /****************************************************************************
   2 *                boxes.c
   3 *
   4 *  This module implements the box primitive.
   5 *  This file was written by Alexander Enzmann.  He wrote the code for
   6 *  boxes and generously provided us these enhancements.
   7 *
   8 *  from Persistence of Vision(tm) Ray Tracer
   9 *  Copyright 1996,1999 Persistence of Vision Team
  10 *---------------------------------------------------------------------------
  11 *  NOTICE: This source code file is provided so that users may experiment
  12 *  with enhancements to POV-Ray and to port the software to platforms other
  13 *  than those supported by the POV-Ray Team.  There are strict rules under
  14 *  which you are permitted to use this file.  The rules are in the file
  15 *  named POVLEGAL.DOC which should be distributed with this file.
  16 *  If POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  17 *  Team Coordinator by email to team-coord@povray.org or visit us on the web at
  18 *  http://www.povray.org. The latest version of POV-Ray may be found at this site.
  19 *
  20 * This program is based on the popular DKB raytracer version 2.12.
  21 * DKBTrace was originally written by David K. Buck.
  22 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  23 *
  24 *****************************************************************************/
  25
  26 #include "frame.h"
  27 #include "povray.h"
  28 #include "vector.h"
  29 #include "povproto.h"
  30 #include "bbox.h"
  31 #include "boxes.h"
  32 #include "matrices.h"
  33 #include "objects.h"
  34
  35
  36
  37 /*****************************************************************************
  38 * Local preprocessor defines
  39 ******************************************************************************/
  40
  41 /* Minimal intersection depth. */
  42
  43 #define DEPTH_TOLERANCE 1.0e-6
  44
  45 /* Two values are equal if their difference is small than CLOSE_TOLERANCE. */
  46
  47 #define CLOSE_TOLERANCE 1.0e-6
  48
  49 /* Side hit. */
  50
  51 #define SIDE_X_0 1
  52 #define SIDE_X_1 2
  53 #define SIDE_Y_0 3
  54 #define SIDE_Y_1 4
  55 #define SIDE_Z_0 5
  56 #define SIDE_Z_1 6
  57
  58
  59
  60 /*****************************************************************************
  61 * Static functions
  62 ******************************************************************************/
  63 static int  All_Box_Intersections (OBJECT *Object, RAY *Ray, ISTACK *Depth_Stack);
  64 static int  Inside_Box (VECTOR point, OBJECT *Object);
  65 static void Box_Normal (VECTOR Result, OBJECT *Object, INTERSECTION *Inter);
  66 static void Translate_Box (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  67 static void Rotate_Box (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  68 static void Scale_Box (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  69 static void Transform_Box (OBJECT *Object, TRANSFORM *Trans);
  70 static void Invert_Box (OBJECT *Object);
  71
  72
  73
  74 /*****************************************************************************
  75 * Local variables
  76 ******************************************************************************/
  77
  78 METHODS Box_Methods =
  79 {
  80   All_Box_Intersections,
  81   Inside_Box, Box_Normal,
  82   (COPY_METHOD)Copy_Box, Translate_Box, Rotate_Box, Scale_Box, Transform_Box,
  83   Invert_Box, Destroy_Box
  84 };
  85
  86
  87
  88 /*****************************************************************************
  89 *
  90 * FUNCTION
  91 *
  92 *   All_Box_Intersections
  93 *
  94 * INPUT
  95 *
  96 * OUTPUT
  97 *
  98 * RETURNS
  99 *
 100 * AUTHOR
 101 *
 102 *   Alexander Enzmann
 103 *
 104 * DESCRIPTION
 105 *
 106 *   -
 107 *
 108 * CHANGES
 109 *
 110 *   -
 111 *
 112 ******************************************************************************/
 113
 114 static int All_Box_Intersections(OBJECT *Object, RAY *Ray, ISTACK *Depth_Stack)
 115 {
 116   int Intersection_Found;
 117   int Side1, Side2;
 118   DBL Depth1, Depth2;
 119   VECTOR IPoint;
 120
 121   Increase_Counter(stats[Ray_Box_Tests]);
 122
 123   Intersection_Found = FALSE;
 124
 125   if (Intersect_Box(Ray, (BOX *)Object, &Depth1, &Depth2, &Side1, &Side2))
 126   {
 127     if (Depth1 > DEPTH_TOLERANCE)
 128     {
 129       VEvaluateRay(IPoint, Ray->Initial, Depth1, Ray->Direction);
 130
 131       if (Point_In_Clip(IPoint, Object->Clip))
 132       {
 133         push_entry_i1(Depth1,IPoint,Object,Side1,Depth_Stack);
 134
 135         Intersection_Found = TRUE;
 136       }
 137     }
 138
 139     VEvaluateRay(IPoint, Ray->Initial, Depth2, Ray->Direction);
 140
 141     if (Point_In_Clip(IPoint, Object->Clip))
 142     {
 143       push_entry_i1(Depth2,IPoint,Object,Side2,Depth_Stack);
 144
 145       Intersection_Found = TRUE;
 146     }
 147   }
 148
 149   if (Intersection_Found)
 150   {
 151     Increase_Counter(stats[Ray_Box_Tests_Succeeded]);
 152   }
 153
 154   return (Intersection_Found);
 155 }
 156
 157
 158
 159 /*****************************************************************************
 160 *
 161 * FUNCTION
 162 *
 163 *   Intersect_Box
 164 *
 165 * INPUT
 166 *
 167 * OUTPUT
 168 *
 169 * RETURNS
 170 *
 171 * AUTHOR
 172 *
 173 *   Alexander Enzmann
 174 *
 175 * DESCRIPTION
 176 *
 177 *   -
 178 *
 179 * CHANGES
 180 *
 181 *   Sep 1994 : Added code to decide which side was hit in the case
 182 *              intersection points are close to each other. This removes
 183 *              some ugly artefacts one could observe at the corners of
 184 *              boxes due to the usage of the wrong normal vector. [DB]
 185 *
 186 ******************************************************************************/
 187
 188 int Intersect_Box(RAY *Ray, BOX *box, DBL *Depth1, DBL  *Depth2, int *Side1, int  *Side2)
 189 {
 190   int smin = 0, smax = 0;    /* Side hit for min/max intersection. */
 191   DBL t, tmin, tmax;
 192   VECTOR P, D;
 193
 194   /* Transform the point into the boxes space */
 195
 196   if (box->Trans != NULL)
 197   {
 198     MInvTransPoint(P, Ray->Initial, box->Trans);
 199     MInvTransDirection(D, Ray->Direction, box->Trans);
 200   }
 201   else
 202   {
 203     Assign_Vector(P, Ray->Initial);
 204     Assign_Vector(D, Ray->Direction);
 205   }
 206
 207   tmin = 0.0;
 208   tmax = BOUND_HUGE;
 209
 210   /*
 211    * Sides first.
 212    */
 213
 214   if (D[X] < -EPSILON)
 215   {
 216     t = (box->bounds[0][X] - P[X]) / D[X];
 217
 218     if (t < tmin) return(FALSE);
 219
 220     if (t <= tmax)
 221     {
 222       smax = SIDE_X_0;
 223       tmax = t;
 224     }
 225
 226     t = (box->bounds[1][X] - P[X]) / D[X];
 227
 228     if (t >= tmin)
 229     {
 230       if (t > tmax) return(FALSE);
 231
 232       smin = SIDE_X_1;
 233       tmin = t;
 234     }
 235   }
 236   else
 237   {
 238     if (D[X] > EPSILON)
 239     {
 240       t = (box->bounds[1][X] - P[X]) / D[X];
 241
 242       if (t < tmin) return(FALSE);
 243
 244       if (t <= tmax)
 245       {
 246         smax = SIDE_X_1;
 247         tmax = t;
 248       }
 249
 250       t = (box->bounds[0][X] - P[X]) / D[X];
 251
 252       if (t >= tmin)
 253       {
 254         if (t > tmax) return(FALSE);
 255
 256         smin = SIDE_X_0;
 257         tmin = t;
 258       }
 259     }
 260     else
 261     {
 262       if ((P[X] < box->bounds[0][X]) || (P[X] > box->bounds[1][X]))
 263       {
 264         return(FALSE);
 265       }
 266     }
 267   }
 268
 269   /*
 270    * Check Top/Bottom.
 271    */
 272
 273   if (D[Y] < -EPSILON)
 274   {
 275     t = (box->bounds[0][Y] - P[Y]) / D[Y];
 276
 277     if (t < tmin) return(FALSE);
 278
 279     if (t <= tmax - CLOSE_TOLERANCE)
 280     {
 281       smax = SIDE_Y_0;
 282       tmax = t;
 283     }
 284     else
 285     {
 286       /*
 287        * If intersection points are close to each other find out
 288        * which side to use, i.e. is most probably hit. [DB 9/94]
 289        */
 290
 291       if (t <= tmax + CLOSE_TOLERANCE)
 292       {
 293         if (-D[Y] > fabs(D[X])) smax = SIDE_Y_0;
 294       }
 295     }
 296
 297     t = (box->bounds[1][Y] - P[Y]) / D[Y];
 298
 299     if (t >= tmin + CLOSE_TOLERANCE)
 300     {
 301       if (t > tmax) return(FALSE);
 302
 303       smin = SIDE_Y_1;
 304       tmin = t;
 305     }
 306     else
 307     {
 308       /*
 309        * If intersection points are close to each other find out
 310        * which side to use, i.e. is most probably hit. [DB 9/94]
 311        */
 312
 313       if (t >= tmin - CLOSE_TOLERANCE)
 314       {
 315         if (-D[Y] > fabs(D[X])) smin = SIDE_Y_1;
 316       }
 317     }
 318   }
 319   else
 320   {
 321     if (D[Y] > EPSILON)
 322     {
 323       t = (box->bounds[1][Y] - P[Y]) / D[Y];
 324
 325       if (t < tmin) return(FALSE);
 326
 327       if (t <= tmax - CLOSE_TOLERANCE)
 328       {
 329         smax = SIDE_Y_1;
 330         tmax = t;
 331       }
 332       else
 333       {
 334         /*
 335          * If intersection points are close to each other find out
 336          * which side to use, i.e. is most probably hit. [DB 9/94]
 337          */
 338
 339         if (t <= tmax + CLOSE_TOLERANCE)
 340         {
 341           if (D[Y] > fabs(D[X])) smax = SIDE_Y_1;
 342         }
 343       }
 344
 345       t = (box->bounds[0][Y] - P[Y]) / D[Y];
 346
 347       if (t >= tmin + CLOSE_TOLERANCE)
 348       {
 349         if (t > tmax) return(FALSE);
 350
 351         smin = SIDE_Y_0;
 352         tmin = t;
 353       }
 354       else
 355       {
 356         /*
 357          * If intersection points are close to each other find out
 358          * which side to use, i.e. is most probably hit. [DB 9/94]
 359          */
 360
 361         if (t >= tmin - CLOSE_TOLERANCE)
 362         {
 363           if (D[Y] > fabs(D[X])) smin = SIDE_Y_0;
 364         }
 365       }
 366     }
 367     else
 368     {
 369       if ((P[Y] < box->bounds[0][Y]) || (P[Y] > box->bounds[1][Y]))
 370       {
 371         return(FALSE);
 372       }
 373     }
 374   }
 375
 376   /* Now front/back */
 377
 378   if (D[Z] < -EPSILON)
 379   {
 380     t = (box->bounds[0][Z] - P[Z]) / D[Z];
 381
 382     if (t < tmin) return(FALSE);
 383
 384     if (t <= tmax - CLOSE_TOLERANCE)
 385     {
 386       smax = SIDE_Z_0;
 387       tmax = t;
 388     }
 389     else
 390     {
 391       /*
 392        * If intersection points are close to each other find out
 393        * which side to use, i.e. is most probably hit. [DB 9/94]
 394        */
 395
 396       if (t <= tmax + CLOSE_TOLERANCE)
 397       {
 398         switch (smax)
 399         {
 400           case SIDE_X_0 :
 401           case SIDE_X_1 : if (-D[Z] > fabs(D[X])) smax = SIDE_Z_0; break;
 402
 403           case SIDE_Y_0 :
 404           case SIDE_Y_1 : if (-D[Z] > fabs(D[Y])) smax = SIDE_Z_0; break;
 405         }
 406       }
 407     }
 408
 409     t = (box->bounds[1][Z] - P[Z]) / D[Z];
 410
 411     if (t >= tmin + CLOSE_TOLERANCE)
 412     {
 413       if (t > tmax) return(FALSE);
 414
 415       smin = SIDE_Z_1;
 416       tmin = t;
 417     }
 418     else
 419     {
 420       /*
 421        * If intersection points are close to each other find out
 422        * which side to use, i.e. is most probably hit. [DB 9/94]
 423        */
 424
 425       if (t >= tmin - CLOSE_TOLERANCE)
 426       {
 427         switch (smin)
 428         {
 429           case SIDE_X_0 :
 430           case SIDE_X_1 : if (-D[Z] > fabs(D[X])) smin = SIDE_Z_1; break;
 431
 432           case SIDE_Y_0 :
 433           case SIDE_Y_1 : if (-D[Z] > fabs(D[Y])) smin = SIDE_Z_1; break;
 434         }
 435       }
 436     }
 437   }
 438   else
 439   {
 440     if (D[Z] > EPSILON)
 441     {
 442       t = (box->bounds[1][Z] - P[Z]) / D[Z];
 443
 444       if (t < tmin) return(FALSE);
 445
 446       if (t <= tmax - CLOSE_TOLERANCE)
 447       {
 448         smax = SIDE_Z_1;
 449         tmax = t;
 450       }
 451       else
 452       {
 453         /*
 454          * If intersection points are close to each other find out
 455          * which side to use, i.e. is most probably hit. [DB 9/94]
 456          */
 457
 458         if (t <= tmax + CLOSE_TOLERANCE)
 459         {
 460           switch (smax)
 461           {
 462             case SIDE_X_0 :
 463             case SIDE_X_1 : if (D[Z] > fabs(D[X])) smax = SIDE_Z_1; break;
 464
 465             case SIDE_Y_0 :
 466             case SIDE_Y_1 : if (D[Z] > fabs(D[Y])) smax = SIDE_Z_1; break;
 467           }
 468         }
 469       }
 470
 471       t = (box->bounds[0][Z] - P[Z]) / D[Z];
 472
 473       if (t >= tmin + CLOSE_TOLERANCE)
 474       {
 475         if (t > tmax) return(FALSE);
 476
 477         smin = SIDE_Z_0;
 478         tmin = t;
 479       }
 480       else
 481       {
 482         /*
 483          * If intersection points are close to each other find out
 484          * which side to use, i.e. is most probably hit. [DB 9/94]
 485          */
 486
 487         if (t >= tmin - CLOSE_TOLERANCE)
 488         {
 489           switch (smin)
 490           {
 491             case SIDE_X_0 :
 492             case SIDE_X_1 : if (D[Z] > fabs(D[X])) smin = SIDE_Z_0; break;
 493
 494             case SIDE_Y_0 :
 495             case SIDE_Y_1 : if (D[Z] > fabs(D[Y])) smin = SIDE_Z_0; break;
 496           }
 497         }
 498       }
 499     }
 500     else
 501     {
 502       if ((P[Z] < box->bounds[0][Z]) || (P[Z] > box->bounds[1][Z]))
 503       {
 504         return(FALSE);
 505       }
 506     }
 507   }
 508
 509   if (tmax < DEPTH_TOLERANCE)
 510   {
 511     return (FALSE);
 512   }
 513
 514   *Depth1 = tmin;
 515   *Depth2 = tmax;
 516
 517   *Side1 = smin;
 518   *Side2 = smax;
 519
 520   return(TRUE);
 521 }
 522
 523
 524
 525 /*****************************************************************************
 526 *
 527 * FUNCTION
 528 *
 529 *   Inside_Box
 530 *
 531 * INPUT
 532 *
 533 * OUTPUT
 534 *
 535 * RETURNS
 536 *
 537 * AUTHOR
 538 *
 539 *   Alexander Enzmann
 540 *
 541 * DESCRIPTION
 542 *
 543 *   -
 544 *
 545 * CHANGES
 546 *
 547 *   -
 548 *
 549 ******************************************************************************/
 550
 551 static int Inside_Box(VECTOR IPoint, OBJECT *Object)
 552 {
 553   VECTOR New_Point;
 554   BOX *box = (BOX *) Object;
 555
 556   /* Transform the point into box space. */
 557
 558   if (box->Trans != NULL)
 559   {
 560     MInvTransPoint(New_Point, IPoint, box->Trans);
 561   }
 562   else
 563   {
 564     Assign_Vector(New_Point,IPoint);
 565   }
 566
 567   /* Test to see if we are outside the box. */
 568
 569   if ((New_Point[X] < box->bounds[0][X]) || (New_Point[X] > box->bounds[1][X]))
 570   {
 571     return (Test_Flag(box, INVERTED_FLAG));
 572   }
 573
 574   if ((New_Point[Y] < box->bounds[0][Y]) || (New_Point[Y] > box->bounds[1][Y]))
 575   {
 576     return (Test_Flag(box, INVERTED_FLAG));
 577   }
 578
 579   if ((New_Point[Z] < box->bounds[0][Z]) || (New_Point[Z] > box->bounds[1][Z]))
 580   {
 581     return (Test_Flag(box, INVERTED_FLAG));
 582   }
 583
 584   /* Inside the box. */
 585
 586   return (!Test_Flag(box, INVERTED_FLAG));
 587 }
 588
 589
 590
 591 /*****************************************************************************
 592 *
 593 * FUNCTION
 594 *
 595 *   Box_Normal
 596 *
 597 * INPUT
 598 *
 599 * OUTPUT
 600 *
 601 * RETURNS
 602 *
 603 * AUTHOR
 604 *
 605 *   Alexander Enzmann
 606 *
 607 * DESCRIPTION
 608 *
 609 *   -
 610 *
 611 * CHANGES
 612 *
 613 *   -
 614 *
 615 ******************************************************************************/
 616
 617 static void Box_Normal(VECTOR Result, OBJECT *Object, INTERSECTION *Inter)
 618 {
 619   switch (Inter->i1)
 620   {
 621     case SIDE_X_0: Make_Vector(Result, -1.0,  0.0,  0.0); break;
 622     case SIDE_X_1: Make_Vector(Result,  1.0,  0.0,  0.0); break;
 623     case SIDE_Y_0: Make_Vector(Result,  0.0, -1.0,  0.0); break;
 624     case SIDE_Y_1: Make_Vector(Result,  0.0,  1.0,  0.0); break;
 625     case SIDE_Z_0: Make_Vector(Result,  0.0,  0.0, -1.0); break;
 626     case SIDE_Z_1: Make_Vector(Result,  0.0,  0.0,  1.0); break;
 627
 628     default: Error("Unknown box side in Box_Normal().\n");
 629   }
 630
 631   /* Transform the point into the boxes space. */
 632
 633   if (((BOX *)Object)->Trans != NULL)
 634   {
 635     MTransNormal(Result, Result, ((BOX *)Object)->Trans);
 636
 637     VNormalize(Result, Result);
 638   }
 639 }
 640
 641
 642
 643 /*****************************************************************************
 644 *
 645 * FUNCTION
 646 *
 647 *   Translate_Box
 648 *
 649 * INPUT
 650 *
 651 * OUTPUT
 652 *
 653 * RETURNS
 654 *
 655 * AUTHOR
 656 *
 657 *   Alexander Enzmann
 658 *
 659 * DESCRIPTION
 660 *
 661 *   -
 662 *
 663 * CHANGES
 664 *
 665 *   -
 666 *
 667 ******************************************************************************/
 668
 669 static void Translate_Box(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 670 {
 671   if (((BOX *)Object)->Trans == NULL)
 672   {
 673     VAddEq(((BOX *)Object)->bounds[0], Vector);
 674
 675     VAddEq(((BOX *)Object)->bounds[1], Vector);
 676
 677     Compute_Box_BBox((BOX *)Object);
 678   }
 679   else
 680   {
 681     Transform_Box(Object, Trans);
 682   }
 683 }
 684
 685
 686
 687 /*****************************************************************************
 688 *
 689 * FUNCTION
 690 *
 691 *   Rotate_Box
 692 *
 693 * INPUT
 694 *
 695 * OUTPUT
 696 *
 697 * RETURNS
 698 *
 699 * AUTHOR
 700 *
 701 *   Alexander Enzmann
 702 *
 703 * DESCRIPTION
 704 *
 705 *   -
 706 *
 707 * CHANGES
 708 *
 709 *   -
 710 *
 711 ******************************************************************************/
 712
 713 static void Rotate_Box(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 714 {
 715   Transform_Box(Object, Trans);
 716 }
 717
 718
 719
 720 /*****************************************************************************
 721 *
 722 * FUNCTION
 723 *
 724 *   Scale_Box
 725 *
 726 * INPUT
 727 *
 728 * OUTPUT
 729 *
 730 * RETURNS
 731 *
 732 * AUTHOR
 733 *
 734 *   Alexander Enzmann
 735 *
 736 * DESCRIPTION
 737 *
 738 *   -
 739 *
 740 * CHANGES
 741 *
 742 *   -
 743 *
 744 ******************************************************************************/
 745
 746 static void Scale_Box(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 747 {
 748   DBL temp;
 749   BOX *Box = (BOX *)Object;
 750
 751   if (((BOX *)Object)->Trans == NULL)
 752   {
 753     VEvaluateEq(Box->bounds[0], Vector);
 754     VEvaluateEq(Box->bounds[1], Vector);
 755
 756     if (Box->bounds[0][X] > Box->bounds[1][X])
 757     {
 758       temp = Box->bounds[0][X];
 759
 760       Box->bounds[0][X] = Box->bounds[1][X];
 761       Box->bounds[1][X] = temp;
 762     }
 763
 764     if (Box->bounds[0][Y] > Box->bounds[1][Y])
 765     {
 766       temp = Box->bounds[0][Y];
 767
 768       Box->bounds[0][Y] = Box->bounds[1][Y];
 769       Box->bounds[1][Y] = temp;
 770     }
 771
 772     if (Box->bounds[0][Z] > Box->bounds[1][Z])
 773     {
 774       temp = Box->bounds[0][Z];
 775
 776       Box->bounds[0][Z] = Box->bounds[1][Z];
 777       Box->bounds[1][Z] = temp;
 778     }
 779
 780     Compute_Box_BBox((BOX *)Object);
 781   }
 782   else
 783   {
 784     Transform_Box(Object, Trans);
 785   }
 786 }
 787
 788
 789
 790 /*****************************************************************************
 791 *
 792 * FUNCTION
 793 *
 794 *   Invert_Box
 795 *
 796 * INPUT
 797 *
 798 * OUTPUT
 799 *
 800 * RETURNS
 801 *
 802 * AUTHOR
 803 *
 804 *   Alexander Enzmann
 805 *
 806 * DESCRIPTION
 807 *
 808 *   -
 809 *
 810 * CHANGES
 811 *
 812 *   -
 813 *
 814 ******************************************************************************/
 815
 816 static void Invert_Box(OBJECT *Object)
 817 {
 818   Invert_Flag(Object, INVERTED_FLAG);
 819 }
 820
 821
 822
 823 /*****************************************************************************
 824 *
 825 * FUNCTION
 826 *
 827 *   Transform_Box
 828 *
 829 * INPUT
 830 *
 831 * OUTPUT
 832 *
 833 * RETURNS
 834 *
 835 * AUTHOR
 836 *
 837 *   Alexander Enzmann
 838 *
 839 * DESCRIPTION
 840 *
 841 *   -
 842 *
 843 * CHANGES
 844 *
 845 *   -
 846 *
 847 ******************************************************************************/
 848
 849 static void Transform_Box(OBJECT *Object, TRANSFORM *Trans)
 850 {
 851   BOX *box = (BOX *)Object;
 852
 853   if (box->Trans == NULL)
 854   {
 855     box->Trans = Create_Transform();
 856   }
 857
 858   Compose_Transforms(box->Trans, Trans);
 859
 860   Compute_Box_BBox(box);
 861 }
 862
 863
 864
 865 /*****************************************************************************
 866 *
 867 * FUNCTION
 868 *
 869 *   Create_Box
 870 *
 871 * INPUT
 872 *
 873 * OUTPUT
 874 *
 875 * RETURNS
 876 *
 877 * AUTHOR
 878 *
 879 *   Alexander Enzmann
 880 *
 881 * DESCRIPTION
 882 *
 883 *   -
 884 *
 885 * CHANGES
 886 *
 887 *   -
 888 *
 889 ******************************************************************************/
 890
 891 BOX *Create_Box()
 892 {
 893   BOX *New;
 894
 895   New = (BOX *)POV_MALLOC(sizeof(BOX), "box");
 896
 897   INIT_OBJECT_FIELDS(New, BOX_OBJECT, &Box_Methods)
 898
 899   Make_Vector(New->bounds[0], -1.0, -1.0, -1.0);
 900   Make_Vector(New->bounds[1],  1.0,  1.0,  1.0);
 901
 902   Make_BBox(New->BBox, -1.0, -1.0, -1.0, 2.0, 2.0, 2.0);
 903
 904   New->Trans = NULL;
 905
 906   return (New);
 907 }
 908
 909
 910
 911 /*****************************************************************************
 912 *
 913 * FUNCTION
 914 *
 915 *   Copy_Box
 916 *
 917 * INPUT
 918 *
 919 * OUTPUT
 920 *
 921 * RETURNS
 922 *
 923 * AUTHOR
 924 *
 925 *   Alexander Enzmann
 926 *
 927 * DESCRIPTION
 928 *
 929 *   -
 930 *
 931 * CHANGES
 932 *
 933 *   -
 934 *
 935 ******************************************************************************/
 936
 937 BOX *Copy_Box(OBJECT *Object)
 938 {
 939   BOX *New;
 940
 941   New  = Create_Box();
 942
 943   /* Copy box. */
 944
 945   *New = *((BOX *)Object);
 946
 947   New->Trans = Copy_Transform(((BOX *)Object)->Trans);
 948
 949   return (New);
 950 }
 951
 952
 953
 954 /*****************************************************************************
 955 *
 956 * FUNCTION
 957 *
 958 *   Destroy_Box
 959 *
 960 * INPUT
 961 *
 962 * OUTPUT
 963 *
 964 * RETURNS
 965 *
 966 * AUTHOR
 967 *
 968 *   Alexander Enzmann
 969 *
 970 * DESCRIPTION
 971 *
 972 *   -
 973 *
 974 * CHANGES
 975 *
 976 *   -
 977 *
 978 ******************************************************************************/
 979
 980 void Destroy_Box(OBJECT *Object)
 981 {
 982   Destroy_Transform(((BOX *)Object)->Trans);
 983
 984   POV_FREE (Object);
 985 }
 986
 987
 988
 989 /*****************************************************************************
 990 *
 991 * FUNCTION
 992 *
 993 *   Compute_Box_BBox
 994 *
 995 * INPUT
 996 *
 997 *   Box - Box
 998 *
 999 * OUTPUT
1000 *
1001 *   Box
1002 *
1003 * RETURNS
1004 *
1005 * AUTHOR
1006 *
1007 *   Dieter Bayer
1008 *
1009 * DESCRIPTION
1010 *
1011 *   Calculate the bounding box of a box.
1012 *
1013 * CHANGES
1014 *
1015 *   Aug 1994 : Creation.
1016 *
1017 ******************************************************************************/
1018
1019 void Compute_Box_BBox(BOX *Box)
1020 {
1021   Assign_BBox_Vect(Box->BBox.Lower_Left, Box->bounds[0]);
1022
1023   VSub(Box->BBox.Lengths, Box->bounds[1], Box->bounds[0]);
1024
1025   if (Box->Trans != NULL)
1026   {
1027     Recompute_BBox(&Box->BBox, Box->Trans);
1028   }
1029 }
1030