src/rt/m_clip.c

#ifndef lint
static const char       RCSid[] = "$Id: m_clip.c,v 2.12 2017/04/08 00:09:35 greg Exp $";
#endif
/*
 *  m_clip.c - routine for clipped (cut) objects.
 */

#include "copyright.h"

#include  "ray.h"
#include  "rtotypes.h"

/*
 *  Clipping objects permit holes and sections to be taken out
 *  of other objects. 
 *
 *  The argument is the clipped materials;
 *  the first is used to shade upon exit.
 *
 *  In the simple case of the first argument being "void", we
 *  just add or subtract (depending on whether we're coming or going)
 *  the list of modifiers to the ray's "newcset", which will then
 *  take over for "clipset" on penetration.  Any surface modifier
 *  names found in "clipset" will be treated as invisible in raycont().
 *
 *  In the more complicated case of a non-void material as the
 *  first argument, we have to backtrack up the ray tree to count
 *  the number of times we've penetrated the front side of one of
 *  the surfaces we care about.  This relies on outward-facing
 *  surface normals and closed objects, so is somewhat error-prone.
 */


int
m_clip(                 /* clip objects from ray */
        OBJREC  *m,
        RAY  *r
)
{
        OBJECT  cset[MAXSET+1], *modset;
        OBJECT  obj, mod;
        int  entering;
        int  i;

        obj = objndx(m);
        if ((modset = (OBJECT *)m->os) == NULL) {
                if (m->oargs.nsargs < 1 || m->oargs.nsargs > MAXSET)
                        objerror(m, USER, "bad # arguments");
                modset = (OBJECT *)malloc((m->oargs.nsargs+1)*sizeof(OBJECT));
                if (modset == NULL)
                        error(SYSTEM, "out of memory in m_clip");
                modset[0] = 0;
                for (i = 0; i < m->oargs.nsargs; i++) {
                        if (!strcmp(m->oargs.sarg[i], VOIDID))
                                continue;
                        if ((mod = lastmod(obj, m->oargs.sarg[i])) == OVOID) {
                                sprintf(errmsg, "unknown modifier \"%s\"",
                                                m->oargs.sarg[i]);
                                objerror(m, WARNING, errmsg);
                                continue;
                        }
                        if (inset(modset, mod)) {
                                objerror(m, WARNING, "duplicate modifier");
                                continue;
                        }
                        insertelem(modset, mod);
                }
                m->os = (char *)modset;
        }
        if (r == NULL)
                return(0);                      /* just initializing */
        if (r->clipset != NULL)
                setcopy(cset, r->clipset);
        else
                cset[0] = 0;

        entering = (r->rod > 0.0);              /* entering clipped region? */

        for (i = modset[0]; i > 0; i--)
                if (entering) {
                        if (!inset(cset, modset[i])) {
                                if (cset[0] >= MAXSET)
                                        error(INTERNAL, "set overflow in m_clip");
                                insertelem(cset, modset[i]);
                        }
                } else if (inset(cset, modset[i]))
                        deletelem(cset, modset[i]);

                                        /* compute ray value */
        r->newcset = cset;
        if (strcmp(m->oargs.sarg[0], VOIDID)) {
                int  inside = 0;
                const RAY  *rp;
                                        /* check for penetration */
                for (rp = r; rp->parent != NULL; rp = rp->parent)
                        if ((rp->rtype == RAYREFL) & (rp->parent->ro != NULL)
                                        && inset(modset, rp->parent->ro->omod)) {
                                if (rp->parent->rod > 0.0)
                                        inside++;
                                else
                                        inside--;
                        }
                if (inside > 0) {       /* we just hit the object */
                        flipsurface(r);
                        return(rayshade(r, lastmod(obj, m->oargs.sarg[0])));
                }
        }
        raytrans(r);                    /* else transfer ray */
        return(1);
}
Revision:	2.13
Committed:	Sat May 4 03:14:04 2019 UTC (5 years ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad5R3
Changes since 2.12:	+2 -2 lines
Log Message:	Minor optimization shouldn't affect behavior
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.13	static const char RCSid[] = "$Id: m_clip.c,v 2.12 2017/04/08 00:09:35 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* m_clip.c - routine for clipped (cut) objects.
6	greg	2.5	*/
7
8	greg	2.6	#include "copyright.h"
9	greg	1.1
10			#include "ray.h"
11	schorsch	2.8	#include "rtotypes.h"
12	greg	1.1
13			/*
14			* Clipping objects permit holes and sections to be taken out
15	greg	2.12	* of other objects.
16	greg	1.1	*
17			* The argument is the clipped materials;
18			* the first is used to shade upon exit.
19	greg	2.12	*
20			* In the simple case of the first argument being "void", we
21			* just add or subtract (depending on whether we're coming or going)
22			* the list of modifiers to the ray's "newcset", which will then
23			* take over for "clipset" on penetration. Any surface modifier
24			* names found in "clipset" will be treated as invisible in raycont().
25			*
26			* In the more complicated case of a non-void material as the
27			* first argument, we have to backtrack up the ray tree to count
28			* the number of times we've penetrated the front side of one of
29			* the surfaces we care about. This relies on outward-facing
30			* surface normals and closed objects, so is somewhat error-prone.
31	greg	1.1	*/
32
33
34	greg	2.11	int
35	schorsch	2.8	m_clip( /* clip objects from ray */
36	greg	2.11	OBJREC *m,
37			RAY *r
38	schorsch	2.8	)
39	greg	1.1	{
40			OBJECT cset[MAXSET+1], *modset;
41	gwlarson	2.4	OBJECT obj, mod;
42	greg	1.1	int entering;
43	greg	2.11	int i;
44	greg	1.1
45	gwlarson	2.4	obj = objndx(m);
46	greg	1.1	if ((modset = (OBJECT *)m->os) == NULL) {
47			if (m->oargs.nsargs < 1 \|\| m->oargs.nsargs > MAXSET)
48			objerror(m, USER, "bad # arguments");
49			modset = (OBJECT )malloc((m->oargs.nsargs+1)sizeof(OBJECT));
50			if (modset == NULL)
51			error(SYSTEM, "out of memory in m_clip");
52			modset[0] = 0;
53			for (i = 0; i < m->oargs.nsargs; i++) {
54			if (!strcmp(m->oargs.sarg[i], VOIDID))
55			continue;
56	greg	2.3	if ((mod = lastmod(obj, m->oargs.sarg[i])) == OVOID) {
57	greg	1.1	sprintf(errmsg, "unknown modifier \"%s\"",
58			m->oargs.sarg[i]);
59			objerror(m, WARNING, errmsg);
60			continue;
61			}
62			if (inset(modset, mod)) {
63			objerror(m, WARNING, "duplicate modifier");
64			continue;
65			}
66			insertelem(modset, mod);
67			}
68	greg	1.2	m->os = (char *)modset;
69	greg	1.1	}
70	greg	2.10	if (r == NULL)
71			return(0); /* just initializing */
72	greg	1.1	if (r->clipset != NULL)
73			setcopy(cset, r->clipset);
74			else
75			cset[0] = 0;
76
77	greg	2.11	entering = (r->rod > 0.0); /* entering clipped region? */
78	greg	1.1
79	greg	2.11	for (i = modset[0]; i > 0; i--)
80	greg	1.1	if (entering) {
81			if (!inset(cset, modset[i])) {
82			if (cset[0] >= MAXSET)
83			error(INTERNAL, "set overflow in m_clip");
84			insertelem(cset, modset[i]);
85			}
86	greg	2.11	} else if (inset(cset, modset[i]))
87			deletelem(cset, modset[i]);
88
89	greg	1.1	/* compute ray value */
90			r->newcset = cset;
91			if (strcmp(m->oargs.sarg[0], VOIDID)) {
92			int inside = 0;
93	greg	2.11	const RAY *rp;
94	greg	1.1	/* check for penetration */
95			for (rp = r; rp->parent != NULL; rp = rp->parent)
96	greg	2.13	if ((rp->rtype == RAYREFL) & (rp->parent->ro != NULL)
97	schorsch	2.7	&& inset(modset, rp->parent->ro->omod)) {
98	greg	1.1	if (rp->parent->rod > 0.0)
99			inside++;
100			else
101			inside--;
102	schorsch	2.7	}
103	greg	1.1	if (inside > 0) { /* we just hit the object */
104			flipsurface(r);
105	gwlarson	2.4	return(rayshade(r, lastmod(obj, m->oargs.sarg[0])));
106	greg	1.1	}
107			}
108			raytrans(r); /* else transfer ray */
109	greg	2.2	return(1);
110	greg	1.1	}