ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/readoct.c

Comparing ray/src/common/readoct.c (file contents):
Revision 1.13 by greg, Mon Aug 5 08:58:52 1991 UTC vs.
Revision 2.31 by greg, Sat May 4 00:32:47 2019 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1991 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  readoct.c - routines to read octree information.
9	–	*
10	–	*     7/30/85
6		*/
7
8	<	#include  "standard.h"
8	>	#include "copyright.h"
9
10	<	#include  "octree.h"
10	>	#include  <stdio.h>
11	>	#include  <time.h>
12
13	+	#include  "platform.h"
14	+	#include  "paths.h"
15	+	#include  "standard.h"
16	+	#include  "octree.h"
17		#include  "object.h"
18	–
18		#include  "otypes.h"
19	+	#include  "resolu.h"
20
21	<	extern double  atof();
22	<	static double  getflt();
23	<	static long  getint();
24	<	static char  *getstr();
25	<	static OCTREE  getfullnode(), gettree();
21	>	static double  ogetflt(void);
22	>	static long  ogetint(int);
23	>	static char  *ogetstr(char *);
24	>	static int  nonsurfintree(OCTREE ot);
25	>	static void  octerror(int  etyp, char  *msg);
26	>	static void  skiptree(void);
27	>	static OCTREE  getfullnode(void), gettree(void);
28
29	<	static char  *infn;                     /* input file name */
29	>	static char  *infn;                     /* input file specification */
30		static FILE  *infp;                     /* input file stream */
31	+	static int  objsize;                    /* size of stored OBJECT's */
32		static OBJECT  objorig;                 /* zeroeth object */
33	<	static short  otypmap[NUMOTYPE+8];      /* object type map */
33	>	static OBJECT  fnobjects;               /* number of objects in this file */
34
35
36		int
37	<	readoct(fname, load, scene, ofn)        /* read in octree from file */
38	<	char  *fname;
39	<	int  load;
40	<	CUBE  *scene;
41	<	char  *ofn[];
37	>	readoct(                                /* read in octree file or stream */
38	>	char  *inpspec,
39	>	int  load,
40	>	CUBE  *scene,
41	>	char  *ofn[]
42	>	)
43		{
40	–	extern int  fputs();
44		char  sbuf[512];
45		int  nf;
46	<	OBJECT  fnobjects;
47	<	register int  i;
46	>	int  i;
47	>	long  m;
48
49	<	if (fname == NULL) {
49	>	if (inpspec == NULL) {
50		infn = "standard input";
51		infp = stdin;
52	+	} else if (inpspec[0] == '!') {
53	+	infn = inpspec;
54	+	if ((infp = popen(inpspec+1, "r")) == NULL) {
55	+	sprintf(errmsg, "cannot execute \"%s\"", inpspec);
56	+	error(SYSTEM, errmsg);
57	+	}
58		} else {
59	<	infn = fname;
60	<	if ((infp = fopen(fname, "r")) == NULL) {
59	>	infn = inpspec;
60	>	if ((infp = fopen(inpspec, "r")) == NULL) {
61		sprintf(errmsg, "cannot open octree file \"%s\"",
62	<	fname);
62	>	inpspec);
63		error(SYSTEM, errmsg);
64		}
65		}
66	+	SET_FILE_BINARY(infp);
67		/* get header */
68	<	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
68	>	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
69		octerror(USER, "not an octree");
70		/* check format */
71	<	if (getint(2) != OCTMAGIC)
71	>	if ((objsize = ogetint(2)-OCTMAGIC) <= 0 ||
72	>	objsize > MAXOBJSIZ || objsize > sizeof(long))
73		octerror(USER, "incompatible octree format");
74		/* get boundaries */
75		if (load & IO_BOUNDS) {
76		for (i = 0; i < 3; i++)
77	<	scene->cuorg[i] = atof(getstr(sbuf));
78	<	scene->cusize = atof(getstr(sbuf));
77	>	scene->cuorg[i] = atof(ogetstr(sbuf));
78	>	scene->cusize = atof(ogetstr(sbuf));
79		} else {
80		for (i = 0; i < 4; i++)
81	<	getstr(sbuf);
81	>	ogetstr(sbuf);
82		}
83		objorig = nobjects;             /* set object offset */
84		nf = 0;                         /* get object files */
85	<	while (*getstr(sbuf)) {
85	>	while (*ogetstr(sbuf)) {
86		if (load & IO_SCENE)
87		readobj(sbuf);
88		if (load & IO_FILES)
#	Line 81 | Line 92 | char  *ofn[];
92		if (load & IO_FILES)
93		ofn[nf] = NULL;
94		/* get number of objects */
95	<	fnobjects = getint(sizeof(OBJECT));
95	>	fnobjects = m = ogetint(objsize);
96	>	if (fnobjects != m)
97	>	octerror(USER, "too many objects");
98
99	<	if (load & IO_TREE) {
87	<	/* get the octree */
99	>	if (load & IO_TREE)             /* get the octree */
100		scene->cutree = gettree();
101	<	/* get the scene */
102	<	if (nf == 0 && load & IO_SCENE) {
103	<	for (i = 0; *getstr(sbuf); i++)
104	<	if ((otypmap[i] = otype(sbuf)) < 0) {
105	<	sprintf(errmsg, "unknown type \"%s\"",
106	<	sbuf);
107	<	octerror(WARNING, errmsg);
108	<	}
109	<	while (getobj() != OVOID)
110	<	;
111	<	} else if (load & IO_SCENE) {           /* consistency checks */
112	<	/* check object count */
113	<	if (nobjects != objorig+fnobjects)
114	<	octerror(USER, "bad object count; octree stale?");
115	<	/* check for non-surfaces */
116	<	if (nonsurfinset(objorig, fnobjects))
105	<	octerror(USER, "non-surface in set; octree stale?");
106	<	}
101	>	else if (load & IO_SCENE && nf == 0)
102	>	skiptree();
103	>
104	>	if (load & IO_SCENE) {          /* get the scene */
105	>	if (nf == 0) {
106	>	/* load binary scene data */
107	>	readscene(infp, objsize);
108	>
109	>	} else {                    /* consistency checks */
110	>	/* check object count */
111	>	if (nobjects != objorig+fnobjects)
112	>	octerror(USER, "bad object count; octree stale?");
113	>	/* check for non-surfaces */
114	>	if (nonsurfintree(scene->cutree))
115	>	octerror(USER, "modifier in tree; octree stale?");
116	>	}
117		}
118	<	fclose(infp);
118	>	/* close the input */
119	>	if (infn[0] == '!')
120	>	pclose(infp);
121	>	else if (infp != stdin)
122	>	fclose(infp);
123		return(nf);
124		}
125
126
127		static char *
128	<	getstr(s)                       /* get null-terminated string */
115	<	char  *s;
128	>	ogetstr(char *s)                /* get null-terminated string */
129		{
130	<	register char  *cp;
118	<	register int  c;
130	>	extern char  *getstr();
131
132	<	cp = s;
133	<	while ((c = getc(infp)) != EOF)
134	<	if ((*cp++ = c) == '\0')
123	<	return(s);
124	<
125	<	octerror(USER, "truncated octree");
132	>	if (getstr(s, infp) == NULL)
133	>	octerror(USER, "truncated octree");
134	>	return(s);
135		}
136
137
138		static OCTREE
139		getfullnode()                   /* get a set, return fullnode */
140		{
141	<	OBJECT  set[MAXSET+1];
141	>	OBJECT  set[MAXSET+1];
142		register int  i;
143	+	register long  m;
144
145	<	set[0] = getint(sizeof(OBJECT));
136	<	if (set[0] > MAXSET)
145	>	if ((set[0] = ogetint(objsize)) > MAXSET)
146		octerror(USER, "bad set in getfullnode");
147	<	for (i = 1; i <= set[0]; i++)
148	<	set[i] = getint(sizeof(OBJECT)) + objorig;
147	>	for (i = 1; i <= set[0]; i++) {
148	>	m = ogetint(objsize) + objorig;
149	>	if ((set[i] = m) != m)
150	>	octerror(USER, "too many objects");
151	>	}
152		return(fullnode(set));
153		}
154
155
156		static long
157	<	getint(siz)                     /* get a siz-byte integer */
146	<	register int  siz;
157	>	ogetint(int siz)                /* get a siz-byte integer */
158		{
159	<	register int  c;
159	>	extern long  getint();
160		register long  r;
161
162	<	if ((c = getc(infp)) == EOF)
163	<	goto end_file;
164	<	r = 0x80&c ? -1<<8|c : c;               /* sign extend */
154	<	while (--siz > 0) {
155	<	if ((c = getc(infp)) == EOF)
156	<	goto end_file;
157	<	r <<= 8;
158	<	r |= c;
159	<	}
162	>	r = getint(siz, infp);
163	>	if (feof(infp))
164	>	octerror(USER, "truncated octree");
165		return(r);
161	–	end_file:
162	–	octerror(USER, "truncated octree");
166		}
167
168
169		static double
170	<	getflt()                        /* get a floating point number */
170	>	ogetflt()                       /* get a floating point number */
171		{
172	<	extern double  ldexp();
173	<	double  d;
172	>	extern double  getflt();
173	>	double  r;
174
175	<	d = (double)getint(4)/0x7fffffff;
176	<	return(ldexp(d, (int)getint(1)));
175	>	r = getflt(infp);
176	>	if (feof(infp))
177	>	octerror(USER, "truncated octree");
178	>	return(r);
179		}
180
181
182		static OCTREE
183		gettree()                       /* get a pre-ordered octree */
184		{
185	<	register OCTREE  ot;
185	>	register OCTREE  ot;
186		register int  i;
187
188		switch (getc(infp)) {
#	Line 196 | Line 201 | gettree()                      /* get a pre-ordered octree */
201		default:
202		octerror(USER, "damaged octree");
203		}
204	+	return EMPTY; /* pro forma return */
205		}
206
207
208	<	static
209	<	getobj()                                /* get next object */
208	>	static int
209	>	nonsurfintree(OCTREE ot)                /* check tree for modifiers */
210		{
211	<	char  sbuf[MAXSTR];
206	<	int  obj;
211	>	OBJECT  set[MAXSET+1];
212		register int  i;
208	–	register OBJREC  *objp;
213
214	<	i = getint(1);
215	<	if (i == -1)
216	<	return(OVOID);          /* terminator */
217	<	if ((obj = newobject()) == OVOID)
218	<	error(SYSTEM, "out of object space");
219	<	objp = objptr(obj);
220	<	if ((objp->otype = otypmap[i]) < 0)
221	<	octerror(USER, "reference to unknown type");
222	<	if ((objp->omod = getint(sizeof(OBJECT))) != OVOID)
223	<	objp->omod += objorig;
224	<	objp->oname = savqstr(getstr(sbuf));
225	<	if (objp->oargs.nsargs = getint(2)) {
226	<	objp->oargs.sarg = (char **)bmalloc
223	<	(objp->oargs.nsargs*sizeof(char *));
224	<	if (objp->oargs.sarg == NULL)
225	<	goto memerr;
226	<	for (i = 0; i < objp->oargs.nsargs; i++)
227	<	objp->oargs.sarg[i] = savestr(getstr(sbuf));
228	<	} else
229	<	objp->oargs.sarg = NULL;
230	<	#ifdef  IARGS
231	<	if (objp->oargs.niargs = getint(2)) {
232	<	objp->oargs.iarg = (long *)bmalloc
233	<	(objp->oargs.niargs*sizeof(long));
234	<	if (objp->oargs.iarg == NULL)
235	<	goto memerr;
236	<	for (i = 0; i < objp->oargs.niargs; i++)
237	<	objp->oargs.iarg[i] = getint(4);
238	<	} else
239	<	objp->oargs.iarg = NULL;
240	<	#endif
241	<	if (objp->oargs.nfargs = getint(2)) {
242	<	objp->oargs.farg = (double *)bmalloc
243	<	(objp->oargs.nfargs*sizeof(double));
244	<	if (objp->oargs.farg == NULL)
245	<	goto memerr;
246	<	for (i = 0; i < objp->oargs.nfargs; i++)
247	<	objp->oargs.farg[i] = getflt();
248	<	} else
249	<	objp->oargs.farg = NULL;
250	<	/* initialize */
251	<	objp->os = NULL;
252	<	objp->lastrno = -1;
253	<	/* insert */
254	<	insertobject(obj);
255	<	return(obj);
256	<	memerr:
257	<	error(SYSTEM, "out of memory in getobj");
214	>	if (isempty(ot))
215	>	return(0);
216	>	if (istree(ot)) {
217	>	for (i = 0; i < 8; i++)
218	>	if (nonsurfintree(octkid(ot, i)))
219	>	return(1);
220	>	return(0);
221	>	}
222	>	objset(set, ot);
223	>	for (i = set[0]; i > 0; i-- )
224	>	if (ismodifier(objptr(set[i])->otype))
225	>	return(1);
226	>	return(0);
227		}
228
229
230	<	static
231	<	octerror(etyp, msg)                     /* octree error */
232	<	int  etyp;
233	<	char  *msg;
230	>	static void
231	>	skiptree(void)                          /* skip octree on input */
232	>	{
233	>	register int  i;
234	>
235	>	switch (getc(infp)) {
236	>	case OT_EMPTY:
237	>	return;
238	>	case OT_FULL:
239	>	for (i = ogetint(objsize)*objsize; i-- > 0; )
240	>	if (getc(infp) == EOF)
241	>	octerror(USER, "truncated octree");
242	>	return;
243	>	case OT_TREE:
244	>	for (i = 0; i < 8; i++)
245	>	skiptree();
246	>	return;
247	>	case EOF:
248	>	octerror(USER, "truncated octree");
249	>	default:
250	>	octerror(USER, "damaged octree");
251	>	}
252	>	}
253	>
254	>
255	>	static void
256	>	octerror(int etyp, char *msg)           /* octree error */
257		{
258		char  msgbuf[128];
259

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)