gfx/povray/cones.c

   1 /****************************************************************************
   2 *                cones.c
   3 *
   4 *  This module implements the cone primitive.
   5 *  This file was written by Alexander Enzmann.    He wrote the code for
   6 *  cones 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 "cones.h"
  32 #include "matrices.h"
  33 #include "objects.h"
  34
  35
  36
  37 /*****************************************************************************
  38 * Local preprocessor defines
  39 ******************************************************************************/
  40
  41 #define Cone_Tolerance 1.0e-6
  42
  43 #define close(x, y) (fabs(x-y) < EPSILON ? 1 : 0)
  44
  45 /* Part of the cone/cylinder hit. [DB 9/94] */
  46
  47 #define BASE_HIT 1
  48 #define CAP_HIT  2
  49 #define SIDE_HIT 3
  50
  51
  52
  53 /*****************************************************************************
  54 * Local typedefs
  55 ******************************************************************************/
  56
  57 typedef struct Cone_Intersection_Structure CONE_INT;
  58
  59 struct Cone_Intersection_Structure
  60 {
  61   DBL d;  /* Distance of intersection point               */
  62   int t;  /* Type of intersection: base/cap plane or side */
  63 };
  64
  65
  66
  67 /*****************************************************************************
  68 * Static functions
  69 ******************************************************************************/
  70
  71 static int intersect_cone (RAY *Ray, CONE *Cone, CONE_INT *Depths);
  72 static void Destroy_Cone (OBJECT *Object);
  73 static int All_Cone_Intersections (OBJECT *Object, RAY *Ray, ISTACK *Depth_Stack);
  74 static int Inside_Cone (VECTOR point, OBJECT *Object);
  75 static void Cone_Normal (VECTOR Result, OBJECT *Object, INTERSECTION *Inter);
  76 static CONE *Copy_Cone (OBJECT *Object);
  77 static void Translate_Cone (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  78 static void Rotate_Cone (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  79 static void Scale_Cone (OBJECT *Object, VECTOR Vector, TRANSFORM *Trans);
  80 static void Transform_Cone (OBJECT *Object, TRANSFORM *Trans);
  81 static void Invert_Cone (OBJECT *Object);
  82
  83
  84 /*****************************************************************************
  85 * Local variables
  86 ******************************************************************************/
  87
  88 static METHODS Cone_Methods =
  89 {
  90   All_Cone_Intersections,
  91   Inside_Cone, Cone_Normal,
  92   (COPY_METHOD)Copy_Cone, Translate_Cone, Rotate_Cone, Scale_Cone, Transform_Cone,
  93   Invert_Cone, Destroy_Cone
  94 };
  95
  96
  97
  98 /*****************************************************************************
  99 *
 100 * FUNCTION
 101 *
 102 *   All_Cone_Intersections
 103 *
 104 * INPUT
 105 *
 106 * OUTPUT
 107 *
 108 * RETURNS
 109 *
 110 * AUTHOR
 111 *
 112 *   Alexander Enzmann
 113 *
 114 * DESCRIPTION
 115 *
 116 *   -
 117 *
 118 * CHANGES
 119 *
 120 *   -
 121 *
 122 ******************************************************************************/
 123
 124 static int All_Cone_Intersections(OBJECT *Object, RAY *Ray, ISTACK *Depth_Stack)
 125 {
 126   int Intersection_Found, cnt, i;
 127   VECTOR IPoint;
 128   CONE_INT I[4];
 129
 130   Intersection_Found = FALSE;
 131
 132   if ((cnt = intersect_cone(Ray, (CONE *)Object, I)) != 0)
 133   {
 134     for (i = 0; i < cnt; i++)
 135     {
 136       VEvaluateRay(IPoint, Ray->Initial, I[i].d, Ray->Direction);
 137
 138       if (Point_In_Clip(IPoint, Object->Clip))
 139       {
 140         push_entry_i1(I[i].d,IPoint,Object,I[i].t,Depth_Stack);
 141
 142         Intersection_Found = TRUE;
 143       }
 144     }
 145   }
 146
 147   return (Intersection_Found);
 148 }
 149
 150
 151
 152 /*****************************************************************************
 153 *
 154 * FUNCTION
 155 *
 156 *   intersect_cone
 157 *
 158 * INPUT
 159 *
 160 * OUTPUT
 161 *
 162 * RETURNS
 163 *
 164 * AUTHOR
 165 *
 166 *   Alexander Enzmann
 167 *
 168 * DESCRIPTION
 169 *
 170 *   -
 171 *
 172 * CHANGES
 173 *
 174 *   -
 175 *
 176 ******************************************************************************/
 177
 178 static int intersect_cone(RAY *Ray, CONE *Cone, CONE_INT *Intersection)
 179 {
 180   int i = 0;
 181   DBL a, b, c, z, t1, t2, len;
 182   DBL d;
 183   VECTOR P, D;
 184
 185   Increase_Counter(stats[Ray_Cone_Tests]);
 186
 187   /* Transform the ray into the cones space */
 188
 189   MInvTransPoint(P, Ray->Initial, Cone->Trans);
 190   MInvTransDirection(D, Ray->Direction, Cone->Trans);
 191
 192   VLength(len, D);
 193   VInverseScaleEq(D, len);
 194
 195   if (Test_Flag(Cone, CYLINDER_FLAG))
 196   {
 197     /* Solve intersections with a cylinder */
 198
 199     a = D[X] * D[X] + D[Y] * D[Y];
 200
 201     if (a > EPSILON)
 202     {
 203       b = P[X] * D[X] + P[Y] * D[Y];
 204
 205       c = P[X] * P[X] + P[Y] * P[Y] - 1.0;
 206
 207       d = b * b - a * c;
 208
 209       if (d >= 0.0)
 210       {
 211         d = sqrt(d);
 212
 213         t1 = (-b + d) / a;
 214         t2 = (-b - d) / a;
 215
 216         z = P[Z] + t1 * D[Z];
 217
 218         if ((t1 > Cone_Tolerance) && (t1 < Max_Distance) && (z >= 0.0) && (z <= 1.0))
 219         {
 220           Intersection[i].d   = t1 / len;
 221           Intersection[i++].t = SIDE_HIT;
 222         }
 223
 224         z = P[Z] + t2 * D[Z];
 225
 226         if ((t2 > Cone_Tolerance) && (t1 < Max_Distance) && (z >= 0.0) && (z <= 1.0))
 227         {
 228           Intersection[i].d   = t2 / len;
 229           Intersection[i++].t = SIDE_HIT;
 230         }
 231       }
 232     }
 233   }
 234   else
 235   {
 236     /* Solve intersections with a cone */
 237
 238     a = D[X] * D[X] + D[Y] * D[Y] - D[Z] * D[Z];
 239
 240     b = D[X] * P[X] + D[Y] * P[Y] - D[Z] * P[Z];
 241
 242     c = P[X] * P[X] + P[Y] * P[Y] - P[Z] * P[Z];
 243
 244     if (fabs(a) < EPSILON)
 245     {
 246       if (fabs(b) > EPSILON)
 247       {
 248         /* One intersection */
 249
 250         t1 = -0.5 * c / b;
 251
 252         z = P[Z] + t1 * D[Z];
 253
 254         if ((t1 > Cone_Tolerance) && (t1 < Max_Distance) && (z >= Cone->dist) && (z <= 1.0))
 255         {
 256           Intersection[i].d   = t1 / len;
 257           Intersection[i++].t = SIDE_HIT;
 258         }
 259       }
 260     }
 261     else
 262     {
 263       /* Check hits against the side of the cone */
 264
 265       d = b * b - a * c;
 266
 267       if (d >= 0.0)
 268       {
 269         d = sqrt(d);
 270
 271         t1 = (-b - d) / a;
 272         t2 = (-b + d) / a;
 273
 274         z = P[Z] + t1 * D[Z];
 275
 276         if ((t1 > Cone_Tolerance) && (t1 < Max_Distance) && (z >= Cone->dist) && (z <= 1.0))
 277         {
 278           Intersection[i].d   = t1 / len;
 279           Intersection[i++].t = SIDE_HIT;
 280         }
 281
 282         z = P[Z] + t2 * D[Z];
 283
 284         if ((t2 > Cone_Tolerance) && (t1 < Max_Distance) && (z >= Cone->dist) && (z <= 1.0))
 285         {
 286           Intersection[i].d   = t2 / len;
 287           Intersection[i++].t = SIDE_HIT;
 288         }
 289       }
 290     }
 291   }
 292
 293   if (Test_Flag(Cone, CLOSED_FLAG) && (fabs(D[Z]) > EPSILON))
 294   {
 295     d = (1.0 - P[Z]) / D[Z];
 296
 297     a = (P[X] + d * D[X]);
 298
 299     b = (P[Y] + d * D[Y]);
 300
 301     if (((Sqr(a) + Sqr(b)) <= 1.0) && (d > Cone_Tolerance) && (d < Max_Distance))
 302     {
 303       Intersection[i].d   = d / len;
 304       Intersection[i++].t = CAP_HIT;
 305     }
 306
 307     d = (Cone->dist - P[Z]) / D[Z];
 308
 309     a = (P[X] + d * D[X]);
 310
 311     b = (P[Y] + d * D[Y]);
 312
 313     if ((Sqr(a) + Sqr(b)) <= (Test_Flag(Cone, CYLINDER_FLAG) ? 1.0 : Sqr(Cone->dist))
 314       && (d > Cone_Tolerance) && (d < Max_Distance))
 315     {
 316       Intersection[i].d   = d / len;
 317       Intersection[i++].t = BASE_HIT;
 318     }
 319   }
 320
 321   if (i)
 322   {
 323     Increase_Counter(stats[Ray_Cone_Tests_Succeeded]);
 324   }
 325
 326   return (i);
 327 }
 328
 329
 330
 331 /*****************************************************************************
 332 *
 333 * FUNCTION
 334 *
 335 *   Inside_Cone
 336 *
 337 * INPUT
 338 *
 339 * OUTPUT
 340 *
 341 * RETURNS
 342 *
 343 * AUTHOR
 344 *
 345 *   Alexander Enzmann
 346 *
 347 * DESCRIPTION
 348 *
 349 *   -
 350 *
 351 * CHANGES
 352 *
 353 *   -
 354 *
 355 ******************************************************************************/
 356
 357 static int Inside_Cone(VECTOR IPoint, OBJECT *Object)
 358 {
 359   CONE *Cone = (CONE *)Object;
 360   DBL w2, z2, offset = (Test_Flag(Cone, CLOSED_FLAG) ? -EPSILON : EPSILON);
 361   VECTOR New_Point;
 362
 363   /* Transform the point into the cones space */
 364
 365   MInvTransPoint(New_Point, IPoint, Cone->Trans);
 366
 367   /* Test to see if we are inside the cone */
 368
 369   w2 = New_Point[X] * New_Point[X] + New_Point[Y] * New_Point[Y];
 370
 371   if (Test_Flag(Cone, CYLINDER_FLAG))
 372   {
 373     /* Check to see if we are inside a cylinder */
 374
 375     if ((w2 > 1.0 + offset) ||
 376         (New_Point[Z] < 0.0 - offset) ||
 377         (New_Point[Z] > 1.0 + offset))
 378     {
 379       return (Test_Flag(Cone, INVERTED_FLAG));
 380     }
 381     else
 382     {
 383       return (!Test_Flag(Cone, INVERTED_FLAG));
 384     }
 385   }
 386   else
 387   {
 388     /* Check to see if we are inside a cone */
 389
 390     z2 = New_Point[Z] * New_Point[Z];
 391
 392     if ((w2 > z2 + offset) ||
 393         (New_Point[Z] < Cone->dist - offset) ||
 394         (New_Point[Z] > 1.0+offset))
 395     {
 396       return (Test_Flag(Cone, INVERTED_FLAG));
 397     }
 398     else
 399     {
 400       return (!Test_Flag(Cone, INVERTED_FLAG));
 401     }
 402   }
 403 }
 404
 405
 406
 407 /*****************************************************************************
 408 *
 409 * FUNCTION
 410 *
 411 *   Cone_Normal
 412 *
 413 * INPUT
 414 *
 415 * OUTPUT
 416 *
 417 * RETURNS
 418 *
 419 * AUTHOR
 420 *
 421 *   Alexander Enzmann
 422 *
 423 * DESCRIPTION
 424 *
 425 *   -
 426 *
 427 * CHANGES
 428 *
 429 *   -
 430 *
 431 ******************************************************************************/
 432
 433 static void Cone_Normal(VECTOR Result, OBJECT *Object, INTERSECTION *Inter)
 434 {
 435   CONE *Cone = (CONE *)Object;
 436
 437   /* Transform the point into the cones space */
 438
 439   MInvTransPoint(Result, Inter->IPoint, Cone->Trans);
 440
 441   /* Calculating the normal is real simple in canonical cone space */
 442
 443   switch (Inter->i1)
 444   {
 445     case SIDE_HIT:
 446
 447       if (Test_Flag(Cone, CYLINDER_FLAG))
 448       {
 449         Result[Z] = 0.0;
 450       }
 451       else
 452       {
 453         Result[Z] = -Result[Z];
 454       }
 455
 456       break;
 457
 458     case BASE_HIT:
 459
 460       Make_Vector(Result, 0.0, 0.0, -1.0)
 461
 462       break;
 463
 464     case CAP_HIT:
 465
 466       Make_Vector(Result, 0.0, 0.0, 1.0)
 467
 468       break;
 469   }
 470
 471   /* Transform the point out of the cones space */
 472
 473   MTransNormal(Result, Result, Cone->Trans);
 474
 475   VNormalize(Result, Result);
 476 }
 477
 478
 479
 480 /*****************************************************************************
 481 *
 482 * FUNCTION
 483 *
 484 *   Translate_Cone
 485 *
 486 * INPUT
 487 *
 488 * OUTPUT
 489 *
 490 * RETURNS
 491 *
 492 * AUTHOR
 493 *
 494 *   Alexander Enzmann
 495 *
 496 * DESCRIPTION
 497 *
 498 *   -
 499 *
 500 * CHANGES
 501 *
 502 *   -
 503 *
 504 ******************************************************************************/
 505
 506 static void Translate_Cone(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 507 {
 508   Transform_Cone(Object, Trans);
 509 }
 510
 511
 512
 513 /*****************************************************************************
 514 *
 515 * FUNCTION
 516 *
 517 *   Rotate_Cone
 518 *
 519 * INPUT
 520 *
 521 * OUTPUT
 522 *
 523 * RETURNS
 524 *
 525 * AUTHOR
 526 *
 527 *   Alexander Enzmann
 528 *
 529 * DESCRIPTION
 530 *
 531 *   -
 532 *
 533 * CHANGES
 534 *
 535 *   -
 536 *
 537 ******************************************************************************/
 538
 539 static void Rotate_Cone(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 540 {
 541   Transform_Cone(Object, Trans);
 542 }
 543
 544
 545
 546 /*****************************************************************************
 547 *
 548 * FUNCTION
 549 *
 550 *   Scale_Cone
 551 *
 552 * INPUT
 553 *
 554 * OUTPUT
 555 *
 556 * RETURNS
 557 *
 558 * AUTHOR
 559 *
 560 *   Alexander Enzmann
 561 *
 562 * DESCRIPTION
 563 *
 564 *   -
 565 *
 566 * CHANGES
 567 *
 568 *   -
 569 *
 570 ******************************************************************************/
 571
 572 static void Scale_Cone(OBJECT *Object, VECTOR Vector, TRANSFORM *Trans)
 573 {
 574   Transform_Cone(Object, Trans);
 575 }
 576
 577
 578
 579 /*****************************************************************************
 580 *
 581 * FUNCTION
 582 *
 583 *   Transform_Cone
 584 *
 585 * INPUT
 586 *
 587 * OUTPUT
 588 *
 589 * RETURNS
 590 *
 591 * AUTHOR
 592 *
 593 *   Alexander Enzmann
 594 *
 595 * DESCRIPTION
 596 *
 597 *   -
 598 *
 599 * CHANGES
 600 *
 601 *   -
 602 *
 603 ******************************************************************************/
 604
 605 static void Transform_Cone(OBJECT *Object, TRANSFORM *Trans)
 606 {
 607   CONE *Cone = (CONE *)Object;
 608
 609   Compose_Transforms(Cone->Trans, Trans);
 610
 611   Compute_Cone_BBox(Cone);
 612 }
 613
 614
 615
 616 /*****************************************************************************
 617 *
 618 * FUNCTION
 619 *
 620 *   Invert_Cone
 621 *
 622 * INPUT
 623 *
 624 * OUTPUT
 625 *
 626 * RETURNS
 627 *
 628 * AUTHOR
 629 *
 630 *   Alexander Enzmann
 631 *
 632 * DESCRIPTION
 633 *
 634 *   -
 635 *
 636 * CHANGES
 637 *
 638 *   -
 639 *
 640 ******************************************************************************/
 641
 642 static void Invert_Cone(OBJECT *Object)
 643 {
 644   Invert_Flag(Object, INVERTED_FLAG);
 645 }
 646
 647
 648
 649 /*****************************************************************************
 650 *
 651 * FUNCTION
 652 *
 653 *   Create_Cone
 654 *
 655 * INPUT
 656 *
 657 * OUTPUT
 658 *
 659 * RETURNS
 660 *
 661 * AUTHOR
 662 *
 663 *   Alexander Enzmann
 664 *
 665 * DESCRIPTION
 666 *
 667 *   -
 668 *
 669 * CHANGES
 670 *
 671 *   -
 672 *
 673 ******************************************************************************/
 674
 675 CONE *Create_Cone()
 676 {
 677   CONE *New;
 678
 679   New = (CONE *)POV_MALLOC(sizeof(CONE), "cone");
 680
 681   INIT_OBJECT_FIELDS(New, CONE_OBJECT, &Cone_Methods)
 682
 683   Make_Vector(New->apex, 0.0, 0.0, 1.0);
 684   Make_Vector(New->base, 0.0, 0.0, 0.0);
 685
 686   New->apex_radius = 1.0;
 687   New->base_radius = 0.0;
 688
 689   New->dist = 0.0;
 690
 691   New->Trans = Create_Transform();
 692
 693   /* Cone/Cylinder has capped ends by default. */
 694
 695   Set_Flag(New, CLOSED_FLAG);
 696
 697   /* Default bounds */
 698
 699   Make_BBox(New->BBox, -1.0, -1.0, 0.0, 2.0, 2.0, 1.0);
 700
 701   return (New);
 702 }
 703
 704
 705
 706 /*****************************************************************************
 707 *
 708 * FUNCTION
 709 *
 710 *   Copy_Cone
 711 *
 712 * INPUT
 713 *
 714 * OUTPUT
 715 *
 716 * RETURNS
 717 *
 718 * AUTHOR
 719 *
 720 *   Alexander Enzmann
 721 *
 722 * DESCRIPTION
 723 *
 724 *   -
 725 *
 726 * CHANGES
 727 *
 728 *   -
 729 *
 730 ******************************************************************************/
 731
 732 static CONE *Copy_Cone(OBJECT *Object)
 733 {
 734   CONE *New;
 735
 736   New = Create_Cone();
 737
 738   /* Get rid of the transformation created in Create_Cone(). */
 739
 740   Destroy_Transform(New->Trans);
 741
 742   /* Copy cone. */
 743
 744   *New = *((CONE *)Object);
 745
 746   New->Trans = Copy_Transform(((CONE *)Object)->Trans);
 747
 748   return (New);
 749 }
 750
 751
 752
 753 /*****************************************************************************
 754 *
 755 * FUNCTION
 756 *
 757 *   Create_Cylinder
 758 *
 759 * INPUT
 760 *
 761 * OUTPUT
 762 *
 763 * RETURNS
 764 *
 765 * AUTHOR
 766 *
 767 *   Alexander Enzmann
 768 *
 769 * DESCRIPTION
 770 *
 771 *   -
 772 *
 773 * CHANGES
 774 *
 775 *   -
 776 *
 777 ******************************************************************************/
 778
 779 CONE *Create_Cylinder()
 780 {
 781   CONE *New;
 782
 783   New = (CONE *)POV_MALLOC(sizeof(CONE), "cone");
 784
 785   INIT_OBJECT_FIELDS(New, CONE_OBJECT, &Cone_Methods)
 786
 787   Make_Vector(New->apex, 0.0, 0.0, 1.0);
 788   Make_Vector(New->base, 0.0, 0.0, 0.0);
 789
 790   New->apex_radius = 1.0;
 791   New->base_radius = 1.0;
 792   New->dist        = 0.0;
 793
 794   New->Trans = Create_Transform();
 795
 796   Set_Flag(New, CYLINDER_FLAG); /* This is a cylinder. */
 797   Set_Flag(New, CLOSED_FLAG);   /* Has capped ends.    */
 798
 799   /* Default bounds */
 800
 801   Make_BBox(New->BBox, -1.0, -1.0, 0.0, 2.0, 2.0, 1.0);
 802
 803   return (New);
 804 }
 805
 806
 807
 808 /*****************************************************************************
 809 *
 810 * FUNCTION
 811 *
 812 *   Compute_Cone_Data
 813 *
 814 * INPUT
 815 *
 816 * OUTPUT
 817 *
 818 * RETURNS
 819 *
 820 * AUTHOR
 821 *
 822 *   Alexander Enzmann
 823 *
 824 * DESCRIPTION
 825 *
 826 *   -
 827 *
 828 * CHANGES
 829 *
 830 *   Feb 1996: check for equal sized ends (cylinder) first [AED]
 831 *
 832 ******************************************************************************/
 833
 834 void Compute_Cone_Data(OBJECT *Object)
 835 {
 836   DBL tlen, len, tmpf;
 837   VECTOR tmpv, axis, origin;
 838   CONE *Cone = (CONE *)Object;
 839
 840   /* Process the primitive specific information */
 841
 842   if (fabs(Cone->apex_radius - Cone->base_radius) < EPSILON)
 843   {
 844     /* What we are dealing with here is really a cylinder */
 845
 846     Set_Flag(Cone, CYLINDER_FLAG);
 847
 848     Compute_Cylinder_Data(Object);
 849
 850     return;
 851   }
 852
 853   if (Cone->apex_radius < Cone->base_radius)
 854   {
 855     /* Want the bigger end at the top */
 856
 857     Assign_Vector(tmpv,Cone->base);
 858     Assign_Vector(Cone->base,Cone->apex);
 859     Assign_Vector(Cone->apex,tmpv);
 860
 861     tmpf = Cone->base_radius;
 862     Cone->base_radius = Cone->apex_radius;
 863     Cone->apex_radius = tmpf;
 864   }
 865
 866   /* Find the axis and axis length */
 867
 868   VSub(axis, Cone->apex, Cone->base);
 869
 870   VLength(len, axis);
 871
 872   if (len < EPSILON)
 873   {
 874     Error("Degenerate cone/cylinder.\n");
 875   }
 876   else
 877   {
 878     VInverseScaleEq(axis, len)
 879   }
 880
 881   /* Determine alignment */
 882
 883   tmpf = Cone->base_radius * len / (Cone->apex_radius - Cone->base_radius);
 884
 885   VScale(origin, axis, tmpf);
 886
 887   VSub(origin, Cone->base, origin);
 888
 889   tlen = tmpf + len;
 890
 891   Cone->dist = tmpf / tlen;
 892
 893   Compute_Coordinate_Transform(Cone->Trans, origin, axis, Cone->apex_radius, tlen);
 894
 895   /* Recalculate the bounds */
 896
 897   Compute_Cone_BBox(Cone);
 898 }
 899
 900
 901
 902 /*****************************************************************************
 903 *
 904 * FUNCTION
 905 *
 906 *   Compute_Cylinder_Data
 907 *
 908 * INPUT
 909 *
 910 * OUTPUT
 911 *
 912 * RETURNS
 913 *
 914 * AUTHOR
 915 *
 916 *   Alexander Enzmann
 917 *
 918 * DESCRIPTION
 919 *
 920 *   -
 921 *
 922 * CHANGES
 923 *
 924 *   -
 925 *
 926 ******************************************************************************/
 927
 928 void Compute_Cylinder_Data(OBJECT *Object)
 929 {
 930   DBL tmpf;
 931   VECTOR axis;
 932   CONE *Cone = (CONE *)Object;
 933
 934   VSub(axis, Cone->apex, Cone->base);
 935
 936   VLength(tmpf, axis);
 937
 938   if (tmpf < EPSILON)
 939   {
 940     Error("Degenerate cylinder, base point = apex point.\n");
 941   }
 942   else
 943   {
 944     VInverseScaleEq(axis, tmpf)
 945
 946     Compute_Coordinate_Transform(Cone->Trans, Cone->base, axis, Cone->apex_radius, tmpf);
 947   }
 948
 949   Cone->dist = 0.0;
 950
 951   /* Recalculate the bounds */
 952
 953   Compute_Cone_BBox(Cone);
 954 }
 955
 956
 957
 958
 959 /*****************************************************************************
 960 *
 961 * FUNCTION
 962 *
 963 *   Destroy_Cone
 964 *
 965 * INPUT
 966 *
 967 * OUTPUT
 968 *
 969 * RETURNS
 970 *
 971 * AUTHOR
 972 *
 973 *   Alexander Enzmann
 974 *
 975 * DESCRIPTION
 976 *
 977 *   -
 978 *
 979 * CHANGES
 980 *
 981 *   -
 982 *
 983 ******************************************************************************/
 984
 985 static void Destroy_Cone(OBJECT *Object)
 986 {
 987   Destroy_Transform(((CONE *)Object)->Trans);
 988
 989   POV_FREE (Object);
 990 }
 991
 992
 993
 994 /*****************************************************************************
 995 *
 996 * FUNCTION
 997 *
 998 *   Compute_Cone_BBox
 999 *
1000 * INPUT
1001 *
1002 *   Cone - Cone/Cylinder
1003 *
1004 * OUTPUT
1005 *
1006 *   Cone
1007 *
1008 * RETURNS
1009 *
1010 * AUTHOR
1011 *
1012 *   Dieter Bayer
1013 *
1014 * DESCRIPTION
1015 *
1016 *   Calculate the bounding box of a cone or cylinder.
1017 *
1018 * CHANGES
1019 *
1020 *   Aug 1994 : Creation.
1021 *
1022 ******************************************************************************/
1023
1024 void Compute_Cone_BBox(CONE *Cone)
1025 {
1026   Make_BBox(Cone->BBox, -1.0, -1.0, 0.0, 2.0, 2.0, 1.0);
1027
1028   Recompute_BBox(&Cone->BBox, Cone->Trans);
1029 }
1030