src/rt/o_cone.c

#ifndef lint
static const char RCSid[] = "$Id: o_cone.c,v 2.12 2023/03/16 00:25:24 greg Exp $";
#endif
/*
 *  o_cone.c - routine to determine ray intersection with cones.
 */

#include "copyright.h"

#include  "ray.h"
#include  "otypes.h"
#include  "rtotypes.h"
#include  "cone.h"


int
o_cone(                 /* intersect ray with cone */
        OBJREC  *o,
        RAY  *r
)
{
        FVECT  rox, rdx;
        double  a, b, c;
        double  root[2];
        int  nroots, rn;
        CONE  *co;
        int  i;

                                                /* get cone structure */
        co = getcone(o, 1);
        if (co == NULL)
                objerror(o, INTERNAL, "unexpected illegal");

        /*
         *     To intersect a ray with a cone, we transform the
         *  ray into the cone's normalized space.  This greatly
         *  simplifies the computation.
         *     For a cone or cup, normalization results in the
         *  equation:
         *
         *              x*x + y*y - z*z == 0
         *
         *     For a cylinder or tube, the normalized equation is:
         *
         *              x*x + y*y - r*r == 0
         *
         *     A normalized ring obeys the following set of equations:
         *
         *              z == 0                  &&
         *              x*x + y*y >= r0*r0      &&
         *              x*x + y*y <= r1*r1
         */

                                        /* transform ray */
        multp3(rox, r->rorg, co->tm);
        multv3(rdx, r->rdir, co->tm);
                                        /* compute intersection */

        if ((o->otype == OBJ_CONE) | (o->otype == OBJ_CUP)) {

                a = rdx[0]*rdx[0] + rdx[1]*rdx[1] - rdx[2]*rdx[2];
                b = 2.0*(rdx[0]*rox[0] + rdx[1]*rox[1] - rdx[2]*rox[2]);
                c = rox[0]*rox[0] + rox[1]*rox[1] - rox[2]*rox[2];

        } else if ((o->otype == OBJ_CYLINDER) | (o->otype == OBJ_TUBE)) {

                a = rdx[0]*rdx[0] + rdx[1]*rdx[1];
                b = 2.0*(rdx[0]*rox[0] + rdx[1]*rox[1]);
                c = rox[0]*rox[0] + rox[1]*rox[1] - CO_R0(co)*CO_R0(co);

        } else { /* OBJ_RING */

                if ((rdx[2] <= FTINY) & (rdx[2] >= -FTINY))
                        return(0);                      /* parallel */
                root[0] = -rox[2]/rdx[2];
                if (rayreject(o, r, root[0], -rdx[2]))
                        return(0);                      /* have better */
                b = root[0]*rdx[0] + rox[0];
                c = root[0]*rdx[1] + rox[1];
                a = b*b + c*c;
                if (a > CO_R1(co)*CO_R1(co) || a < CO_R0(co)*CO_R0(co))
                        return(0);                      /* outside radii */
                r->ro = o;
                r->rot = root[0];
                VSUM(r->rop, r->rorg, r->rdir, r->rot);
                VCOPY(r->ron, co->ad);
                r->rod = -rdx[2];
                r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
                r->uv[0] = r->uv[1] = 0.0;
                r->rox = NULL;
                return(1);                              /* good */
        }
                                        /* roots for cone, cup, cyl., tube */
        nroots = quadratic(root, a, b, c);

        for (rn = 0; rn < nroots; rn++) {       /* check real roots */
                if (root[rn] <= FTINY)
                        continue;               /* too small */
                if (root[rn] > r->rot + FTINY)
                        break;                  /* too big */
                                                /* check endpoints */
                VSUM(rox, r->rorg, r->rdir, root[rn]);
                VSUB(rdx, rox, CO_P0(co));
                b = DOT(rdx, co->ad); 
                if (b < 0.0)
                        continue;               /* before p0 */
                if (b > co->al)
                        continue;               /* after p1 */
                if (rayreject(o, r, root[rn], 0))
                        break;                  /* previous hit better */
                r->ro = o;
                r->rot = root[rn];
                VCOPY(r->rop, rox);
                                                /* get normal */
                if (o->otype == OBJ_CYLINDER)
                        a = CO_R0(co);
                else if (o->otype == OBJ_TUBE)
                        a = -CO_R0(co);
                else { /* OBJ_CONE || OBJ_CUP */
                        c = CO_R1(co) - CO_R0(co);
                        a = CO_R0(co) + b*c/co->al;
                        if (o->otype == OBJ_CUP) {
                                c = -c;
                                a = -a;
                        }
                }
                for (i = 0; i < 3; i++)
                        r->ron[i] = (rdx[i] - b*co->ad[i])/a;
                if ((o->otype == OBJ_CONE) | (o->otype == OBJ_CUP))
                        for (i = 0; i < 3; i++)
                                r->ron[i] = (co->al*r->ron[i] - c*co->ad[i])
                                                / co->sl;
                a = DOT(r->ron, r->ron);
                if ((a > 1.+FTINY) | (a < 1.-FTINY)) {
                        c = 1./(.5 + .5*a);     /* avoid numerical error */
                        r->ron[0] *= c; r->ron[1] *= c; r->ron[2] *= c;
                }
                r->rod = -DOT(r->rdir, r->ron);
                r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
                r->uv[0] = r->uv[1] = 0.0;
                r->rox = NULL;
                return(1);                      /* good */
        }
        return(0);
}
Revision:	2.13
Committed:	Tue Nov 5 00:20:02 2024 UTC (11 months, 3 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad6R0, HEAD
Changes since 2.12:	+6 -6 lines
Log Message:	perf: trivial performance improvements
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.13	static const char RCSid[] = "$Id: o_cone.c,v 2.12 2023/03/16 00:25:24 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* o_cone.c - routine to determine ray intersection with cones.
6	greg	2.2	*/
7
8	greg	2.3	#include "copyright.h"
9	greg	1.1
10			#include "ray.h"
11			#include "otypes.h"
12	schorsch	2.5	#include "rtotypes.h"
13	greg	1.1	#include "cone.h"
14
15
16	greg	2.8	int
17	schorsch	2.5	o_cone( /* intersect ray with cone */
18			OBJREC *o,
19	greg	2.8	RAY *r
20	schorsch	2.5	)
21	greg	1.1	{
22			FVECT rox, rdx;
23			double a, b, c;
24			double root[2];
25			int nroots, rn;
26	greg	2.8	CONE *co;
27			int i;
28	greg	1.1
29			/* get cone structure */
30			co = getcone(o, 1);
31	greg	2.9	if (co == NULL)
32			objerror(o, INTERNAL, "unexpected illegal");
33	greg	1.1
34			/*
35			* To intersect a ray with a cone, we transform the
36			* ray into the cone's normalized space. This greatly
37			* simplifies the computation.
38			* For a cone or cup, normalization results in the
39			* equation:
40			*
41			* xx + yy - z*z == 0
42			*
43			* For a cylinder or tube, the normalized equation is:
44			*
45			* xx + yy - r*r == 0
46			*
47			* A normalized ring obeys the following set of equations:
48			*
49			* z == 0 &&
50			* xx + yy >= r0*r0 &&
51			* xx + yy <= r1*r1
52			*/
53
54			/* transform ray */
55			multp3(rox, r->rorg, co->tm);
56			multv3(rdx, r->rdir, co->tm);
57			/* compute intersection */
58
59	greg	2.13	if ((o->otype == OBJ_CONE) \| (o->otype == OBJ_CUP)) {
60	greg	1.1
61			a = rdx[0]rdx[0] + rdx[1]rdx[1] - rdx[2]*rdx[2];
62			b = 2.0(rdx[0]rox[0] + rdx[1]rox[1] - rdx[2]rox[2]);
63			c = rox[0]rox[0] + rox[1]rox[1] - rox[2]*rox[2];
64
65	greg	2.13	} else if ((o->otype == OBJ_CYLINDER) \| (o->otype == OBJ_TUBE)) {
66	greg	1.1
67			a = rdx[0]rdx[0] + rdx[1]rdx[1];
68			b = 2.0(rdx[0]rox[0] + rdx[1]*rox[1]);
69			c = rox[0]rox[0] + rox[1]rox[1] - CO_R0(co)*CO_R0(co);
70
71			} else { /* OBJ_RING */
72
73	greg	2.10	if ((rdx[2] <= FTINY) & (rdx[2] >= -FTINY))
74	greg	1.1	return(0); /* parallel */
75			root[0] = -rox[2]/rdx[2];
76	greg	2.12	if (rayreject(o, r, root[0], -rdx[2]))
77	greg	2.10	return(0); /* have better */
78	greg	1.1	b = root[0]*rdx[0] + rox[0];
79			c = root[0]*rdx[1] + rox[1];
80			a = bb + cc;
81	greg	2.13	if (a > CO_R1(co)CO_R1(co) \|\| a < CO_R0(co)CO_R0(co))
82	greg	1.1	return(0); /* outside radii */
83			r->ro = o;
84			r->rot = root[0];
85	greg	2.7	VSUM(r->rop, r->rorg, r->rdir, r->rot);
86	greg	1.1	VCOPY(r->ron, co->ad);
87			r->rod = -rdx[2];
88	greg	2.11	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
89			r->uv[0] = r->uv[1] = 0.0;
90	greg	1.3	r->rox = NULL;
91	greg	1.1	return(1); /* good */
92			}
93			/* roots for cone, cup, cyl., tube */
94			nroots = quadratic(root, a, b, c);
95
96			for (rn = 0; rn < nroots; rn++) { /* check real roots */
97			if (root[rn] <= FTINY)
98			continue; /* too small */
99	greg	2.10	if (root[rn] > r->rot + FTINY)
100	greg	1.1	break; /* too big */
101			/* check endpoints */
102	greg	2.7	VSUM(rox, r->rorg, r->rdir, root[rn]);
103			VSUB(rdx, rox, CO_P0(co));
104	greg	1.1	b = DOT(rdx, co->ad);
105			if (b < 0.0)
106			continue; /* before p0 */
107			if (b > co->al)
108			continue; /* after p1 */
109	greg	2.12	if (rayreject(o, r, root[rn], 0))
110	greg	2.10	break; /* previous hit better */
111	greg	1.1	r->ro = o;
112			r->rot = root[rn];
113			VCOPY(r->rop, rox);
114			/* get normal */
115			if (o->otype == OBJ_CYLINDER)
116			a = CO_R0(co);
117			else if (o->otype == OBJ_TUBE)
118			a = -CO_R0(co);
119			else { /* OBJ_CONE \|\| OBJ_CUP */
120			c = CO_R1(co) - CO_R0(co);
121			a = CO_R0(co) + b*c/co->al;
122			if (o->otype == OBJ_CUP) {
123			c = -c;
124			a = -a;
125			}
126			}
127			for (i = 0; i < 3; i++)
128			r->ron[i] = (rdx[i] - b*co->ad[i])/a;
129	greg	2.13	if ((o->otype == OBJ_CONE) \| (o->otype == OBJ_CUP))
130	greg	1.1	for (i = 0; i < 3; i++)
131			r->ron[i] = (co->alr->ron[i] - cco->ad[i])
132	greg	2.7	/ co->sl;
133	greg	2.6	a = DOT(r->ron, r->ron);
134	greg	2.13	if ((a > 1.+FTINY) \| (a < 1.-FTINY)) {
135	greg	2.6	c = 1./(.5 + .5a); / avoid numerical error */
136			r->ron[0] = c; r->ron[1] = c; r->ron[2] *= c;
137			}
138	greg	1.1	r->rod = -DOT(r->rdir, r->ron);
139	greg	2.4	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
140			r->uv[0] = r->uv[1] = 0.0;
141	greg	1.3	r->rox = NULL;
142	greg	1.1	return(1); /* good */
143			}
144			return(0);
145			}