src/ot/bbox.c

#ifndef lint
static const char RCSid[] = "$Id: bbox.c,v 2.6 2005/06/14 17:10:06 greg Exp $";
#endif
/*
 *  bbox.c - routines for bounding box computation.
 */

#include  "copyright.h"

#include  "standard.h"
#include  "object.h"
#include  "octree.h"
#include  "otypes.h"
#include  "face.h"
#include  "cone.h"
#include  "instance.h"
#include  "mesh.h"
#include  "oconv.h"


static void point2bbox(FVECT  p, FVECT  bbmin, FVECT  bbmax);
static void circle2bbox(FVECT  cent, FVECT  norm, double  rad, FVECT  bbmin, FVECT  bbmax);


void
add2bbox(               /* expand bounding box to fit object */
        register OBJREC  *o,
        FVECT  bbmin,
        FVECT  bbmax
)
{
        CONE  *co;
        FACE  *fo;
        INSTANCE  *io;
        MESHINST  *mi;
        FVECT  v;
        register int  i, j;

        switch (o->otype) {
        case OBJ_SPHERE:
        case OBJ_BUBBLE:
                if (o->oargs.nfargs != 4)
                        objerror(o, USER, "bad arguments");
                for (i = 0; i < 3; i++) {
                        VCOPY(v, o->oargs.farg);
                        v[i] -= o->oargs.farg[3];
                        point2bbox(v, bbmin, bbmax);
                        v[i] += 2.0 * o->oargs.farg[3];
                        point2bbox(v, bbmin, bbmax);
                }
                break;
        case OBJ_FACE:
                fo = getface(o);
                j = fo->nv;
                while (j--)
                        point2bbox(VERTEX(fo,j), bbmin, bbmax);
                break;
        case OBJ_CONE:
        case OBJ_CUP:
        case OBJ_CYLINDER:
        case OBJ_TUBE:
        case OBJ_RING:
                co = getcone(o, 0);
                if (co == NULL)
                        break;
                if (o->otype != OBJ_RING)
                        circle2bbox(CO_P0(co), co->ad, CO_R0(co), bbmin, bbmax);
                circle2bbox(CO_P1(co), co->ad, CO_R1(co), bbmin, bbmax);
                break;
        case OBJ_INSTANCE:
                io = getinstance(o, IO_BOUNDS);
                for (j = 0; j < 8; j++) {
                        for (i = 0; i < 3; i++) {
                                v[i] = io->obj->scube.cuorg[i];
                                if (j & 1<<i)
                                        v[i] += io->obj->scube.cusize;
                        }
                        multp3(v, v, io->x.f.xfm);
                        point2bbox(v, bbmin, bbmax);
                }
                break;
        case OBJ_MESH:
                mi = getmeshinst(o, IO_BOUNDS);
                for (j = 0; j < 8; j++) {
                        for (i = 0; i < 3; i++) {
                                v[i] = mi->msh->mcube.cuorg[i];
                                if (j & 1<<i)
                                        v[i] += mi->msh->mcube.cusize;
                        }
                        multp3(v, v, mi->x.f.xfm);
                        point2bbox(v, bbmin, bbmax);
                }
                break;
        }
}


static void
point2bbox(             /* expand bounding box to fit point */
        register FVECT  p,
        register FVECT  bbmin,
        register FVECT  bbmax
)
{
        register int  i;

        for (i = 0; i < 3; i++) {
                if (p[i] < bbmin[i])
                        bbmin[i] = p[i];
                if (p[i] > bbmax[i])
                        bbmax[i] = p[i];
        }
}


static void
circle2bbox(    /* expand bbox to fit circle */
        FVECT  cent,
        FVECT  norm,
        double  rad,
        FVECT  bbmin,
        FVECT  bbmax
)
{
        double  d, r;
        register int  i;

        for (i = 0; i < 3; i++) {
                r = sqrt(1. - norm[i]*norm[i]);
                d = cent[i] + r*rad;
                if (d > bbmax[i])
                        bbmax[i] = d;
                d = cent[i] - r*rad;
                if (d < bbmin[i])
                        bbmin[i] = d;
        }
}
Revision:	2.7
Committed:	Fri Sep 16 15:09:21 2016 UTC (7 years, 7 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad5R2, rad5R1, rad5R3, HEAD
Changes since 2.6:	+3 -1 lines
Log Message:	Added checks for illegal cones/rings/cylinders
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.7	static const char RCSid[] = "$Id: bbox.c,v 2.6 2005/06/14 17:10:06 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* bbox.c - routines for bounding box computation.
6	greg	2.2	*/
7
8	greg	2.4	#include "copyright.h"
9	greg	1.1
10			#include "standard.h"
11			#include "object.h"
12	greg	2.2	#include "octree.h"
13	greg	1.1	#include "otypes.h"
14			#include "face.h"
15			#include "cone.h"
16	schorsch	2.5	#include "instance.h"
17			#include "mesh.h"
18			#include "oconv.h"
19	greg	1.1
20
21	schorsch	2.5	static void point2bbox(FVECT p, FVECT bbmin, FVECT bbmax);
22			static void circle2bbox(FVECT cent, FVECT norm, double rad, FVECT bbmin, FVECT bbmax);
23	greg	2.4
24	greg	1.1
25	schorsch	2.5	void
26			add2bbox( /* expand bounding box to fit object */
27			register OBJREC *o,
28			FVECT bbmin,
29			FVECT bbmax
30			)
31	greg	1.1	{
32	greg	1.2	CONE *co;
33			FACE *fo;
34			INSTANCE *io;
35	greg	2.4	MESHINST *mi;
36	greg	1.1	FVECT v;
37			register int i, j;
38
39			switch (o->otype) {
40			case OBJ_SPHERE:
41			case OBJ_BUBBLE:
42			if (o->oargs.nfargs != 4)
43			objerror(o, USER, "bad arguments");
44			for (i = 0; i < 3; i++) {
45			VCOPY(v, o->oargs.farg);
46			v[i] -= o->oargs.farg[3];
47			point2bbox(v, bbmin, bbmax);
48			v[i] += 2.0 * o->oargs.farg[3];
49			point2bbox(v, bbmin, bbmax);
50			}
51			break;
52			case OBJ_FACE:
53			fo = getface(o);
54			j = fo->nv;
55			while (j--)
56			point2bbox(VERTEX(fo,j), bbmin, bbmax);
57			break;
58			case OBJ_CONE:
59			case OBJ_CUP:
60			case OBJ_CYLINDER:
61			case OBJ_TUBE:
62			case OBJ_RING:
63			co = getcone(o, 0);
64	greg	2.7	if (co == NULL)
65			break;
66	greg	1.1	if (o->otype != OBJ_RING)
67			circle2bbox(CO_P0(co), co->ad, CO_R0(co), bbmin, bbmax);
68			circle2bbox(CO_P1(co), co->ad, CO_R1(co), bbmin, bbmax);
69			break;
70			case OBJ_INSTANCE:
71	greg	1.3	io = getinstance(o, IO_BOUNDS);
72	greg	1.1	for (j = 0; j < 8; j++) {
73			for (i = 0; i < 3; i++) {
74			v[i] = io->obj->scube.cuorg[i];
75			if (j & 1<<i)
76			v[i] += io->obj->scube.cusize;
77			}
78	greg	1.4	multp3(v, v, io->x.f.xfm);
79	greg	2.4	point2bbox(v, bbmin, bbmax);
80			}
81			break;
82			case OBJ_MESH:
83			mi = getmeshinst(o, IO_BOUNDS);
84			for (j = 0; j < 8; j++) {
85			for (i = 0; i < 3; i++) {
86			v[i] = mi->msh->mcube.cuorg[i];
87			if (j & 1<<i)
88			v[i] += mi->msh->mcube.cusize;
89			}
90			multp3(v, v, mi->x.f.xfm);
91	greg	1.1	point2bbox(v, bbmin, bbmax);
92			}
93			break;
94			}
95			}
96
97
98	schorsch	2.5	static void
99			point2bbox( /* expand bounding box to fit point */
100			register FVECT p,
101			register FVECT bbmin,
102			register FVECT bbmax
103			)
104	greg	1.1	{
105			register int i;
106
107			for (i = 0; i < 3; i++) {
108			if (p[i] < bbmin[i])
109			bbmin[i] = p[i];
110			if (p[i] > bbmax[i])
111			bbmax[i] = p[i];
112			}
113			}
114
115
116	schorsch	2.5	static void
117			circle2bbox( /* expand bbox to fit circle */
118			FVECT cent,
119			FVECT norm,
120			double rad,
121			FVECT bbmin,
122			FVECT bbmax
123			)
124	greg	1.1	{
125	greg	2.6	double d, r;
126			register int i;
127	greg	1.1
128			for (i = 0; i < 3; i++) {
129	greg	2.6	r = sqrt(1. - norm[i]*norm[i]);
130			d = cent[i] + r*rad;
131			if (d > bbmax[i])
132			bbmax[i] = d;
133			d = cent[i] - r*rad;
134			if (d < bbmin[i])
135			bbmin[i] = d;
136	greg	1.1	}
137			}