src/common/readoct.c

#ifndef lint
static const char       RCSid[] = "$Id: readoct.c,v 2.17 2003/06/07 12:50:20 schorsch Exp $";
#endif
/*
 *  readoct.c - routines to read octree information.
 */

#include "copyright.h"

#include  <stdio.h>

#include  "standard.h"
#include  "platform.h"
#include  "octree.h"
#include  "object.h"
#include  "otypes.h"
#include  "resolu.h"

static double  ogetflt();
static long  ogetint();
static char  *ogetstr();
static int  nonsurfinset();
static void  octerror(int  etyp, char  *msg);
static void  skiptree(void);
static OCTREE  getfullnode(), gettree();

static char  *infn;                     /* input file specification */
static FILE  *infp;                     /* input file stream */
static int  objsize;                    /* size of stored OBJECT's */
static OBJECT  objorig;                 /* zeroeth object */
static OBJECT  fnobjects;               /* number of objects in this file */


int
readoct(inpspec, load, scene, ofn)      /* read in octree file or stream */
char  *inpspec;
int  load;
CUBE  *scene;
char  *ofn[];
{
        char  sbuf[512];
        int  nf;
        int  i;
        long  m;
        
        if (inpspec == NULL) {
                infn = "standard input";
                infp = stdin;
        } else if (inpspec[0] == '!') {
                infn = inpspec;
                if ((infp = popen(inpspec+1, "r")) == NULL) {
                        sprintf(errmsg, "cannot execute \"%s\"", inpspec);
                        error(SYSTEM, errmsg);
                }
        } else {
                infn = inpspec;
                if ((infp = fopen(inpspec, "r")) == NULL) {
                        sprintf(errmsg, "cannot open octree file \"%s\"",
                                        inpspec);
                        error(SYSTEM, errmsg);
                }
        }
        SET_FILE_BINARY(infp);
                                        /* get header */
        if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
                octerror(USER, "not an octree");
                                        /* check format */
        if ((objsize = ogetint(2)-OCTMAGIC) <= 0 ||
                        objsize > MAXOBJSIZ || objsize > sizeof(long))
                octerror(USER, "incompatible octree format");
                                        /* get boundaries */
        if (load & IO_BOUNDS) {
                for (i = 0; i < 3; i++)
                        scene->cuorg[i] = atof(ogetstr(sbuf));
                scene->cusize = atof(ogetstr(sbuf));
        } else {
                for (i = 0; i < 4; i++)
                        ogetstr(sbuf);
        }
        objorig = nobjects;             /* set object offset */
        nf = 0;                         /* get object files */
        while (*ogetstr(sbuf)) {
                if (load & IO_SCENE)
                        readobj(sbuf);
                if (load & IO_FILES)
                        ofn[nf] = savqstr(sbuf);
                nf++;
        }
        if (load & IO_FILES)
                ofn[nf] = NULL;
                                        /* get number of objects */
        fnobjects = m = ogetint(objsize);
        if (fnobjects != m)
                octerror(USER, "too many objects");

        if (load & IO_TREE)             /* get the octree */
                scene->cutree = gettree();
        else if (load & IO_SCENE && nf == 0)
                skiptree();
                
        if (load & IO_SCENE)            /* get the scene */
            if (nf == 0) {
                                        /* load binary scene data */
                readscene(infp, objsize);

            } else {                    /* consistency checks */
                                /* check object count */
                if (nobjects != objorig+fnobjects)
                        octerror(USER, "bad object count; octree stale?");
                                /* check for non-surfaces */
                if (dosets(nonsurfinset))
                        octerror(USER, "modifier in tree; octree stale?");
            }
                                /* close the input */
        if (infn[0] == '!')
                pclose(infp);
        else
                fclose(infp);
        return(nf);
}


static char *
ogetstr(s)                      /* get null-terminated string */
char  *s;
{
        extern char  *getstr();

        if (getstr(s, infp) == NULL)
                octerror(USER, "truncated octree");
        return(s);
}


static OCTREE
getfullnode()                   /* get a set, return fullnode */
{
        OBJECT  set[MAXSET+1];
        register int  i;
        register long  m;

        if ((set[0] = ogetint(objsize)) > MAXSET)
                octerror(USER, "bad set in getfullnode");
        for (i = 1; i <= set[0]; i++) {
                m = ogetint(objsize) + objorig;
                if ((set[i] = m) != m)
                        octerror(USER, "too many objects");
        }
        return(fullnode(set));
}       


static long
ogetint(siz)                    /* get a siz-byte integer */
int  siz;
{
        extern long  getint();
        register long  r;

        r = getint(siz, infp);
        if (feof(infp))
                octerror(USER, "truncated octree");
        return(r);
}


static double
ogetflt()                       /* get a floating point number */
{
        extern double  getflt();
        double  r;

        r = getflt(infp);
        if (feof(infp))
                octerror(USER, "truncated octree");
        return(r);
}
        

static OCTREE
gettree()                       /* get a pre-ordered octree */
{
        register OCTREE  ot;
        register int  i;
        
        switch (getc(infp)) {
        case OT_EMPTY:
                return(EMPTY);
        case OT_FULL:
                return(getfullnode());
        case OT_TREE:
                if ((ot = octalloc()) == EMPTY)
                        octerror(SYSTEM, "out of tree space in gettree");
                for (i = 0; i < 8; i++)
                        octkid(ot, i) = gettree();
                return(ot);
        case EOF:
                octerror(USER, "truncated octree");
        default:
                octerror(USER, "damaged octree");
        }
        return NULL; /* pro forma return */
}


static int
nonsurfinset(os)                        /* check set for modifier */
register OBJECT  *os;
{
        register OBJECT  s;
        register int  i;

        for (i = *os; i-- > 0; )
                if ((s = *++os) >= objorig && s < objorig+fnobjects &&
                                ismodifier(objptr(s)->otype))
                        return(1);
        return(0);
}


static void
skiptree(void)                          /* skip octree on input */
{
        register int  i;
        
        switch (getc(infp)) {
        case OT_EMPTY:
                return;
        case OT_FULL:
                for (i = ogetint(objsize)*objsize; i-- > 0; )
                        if (getc(infp) == EOF)
                                octerror(USER, "truncated octree");
                return;
        case OT_TREE:
                for (i = 0; i < 8; i++)
                        skiptree();
                return;
        case EOF:
                octerror(USER, "truncated octree");
        default:
                octerror(USER, "damaged octree");
        }
}


static void
octerror(etyp, msg)                     /* octree error */
int  etyp;
char  *msg;
{
        char  msgbuf[128];

        sprintf(msgbuf, "(%s): %s", infn, msg);
        error(etyp, msgbuf);
}
Revision:	2.18
Committed:	Sun Jun 8 12:03:09 2003 UTC (20 years, 10 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
Changes since 2.17:	+2 -5 lines
Log Message:	Reduced compile warnings/errors on Windows.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	2.18	static const char RCSid[] = "$Id: readoct.c,v 2.17 2003/06/07 12:50:20 schorsch Exp $";
3	greg	1.1	#endif
4			/*
5			* readoct.c - routines to read octree information.
6	greg	2.13	*/
7
8	greg	2.14	#include "copyright.h"
9	greg	1.1
10	schorsch	2.17	#include <stdio.h>
11
12	greg	1.1	#include "standard.h"
13	schorsch	2.18	#include "platform.h"
14	greg	1.1	#include "octree.h"
15			#include "object.h"
16			#include "otypes.h"
17	schorsch	2.17	#include "resolu.h"
18	greg	1.1
19	greg	2.4	static double ogetflt();
20			static long ogetint();
21			static char *ogetstr();
22	greg	2.12	static int nonsurfinset();
23	schorsch	2.17	static void octerror(int etyp, char *msg);
24			static void skiptree(void);
25	greg	1.7	static OCTREE getfullnode(), gettree();
26	greg	1.1
27	greg	2.13	static char infn; / input file specification */
28	greg	1.1	static FILE infp; / input file stream */
29	greg	1.14	static int objsize; /* size of stored OBJECT's */
30	greg	1.1	static OBJECT objorig; /* zeroeth object */
31	greg	2.12	static OBJECT fnobjects; /* number of objects in this file */
32	greg	1.1
33
34			int
35	greg	2.13	readoct(inpspec, load, scene, ofn) /* read in octree file or stream */
36			char *inpspec;
37	greg	1.1	int load;
38			CUBE *scene;
39			char *ofn[];
40			{
41	greg	1.11	char sbuf[512];
42	greg	1.1	int nf;
43	greg	2.15	int i;
44	greg	1.15	long m;
45	greg	1.1
46	greg	2.13	if (inpspec == NULL) {
47	greg	1.1	infn = "standard input";
48			infp = stdin;
49	greg	2.13	} else if (inpspec[0] == '!') {
50			infn = inpspec;
51			if ((infp = popen(inpspec+1, "r")) == NULL) {
52			sprintf(errmsg, "cannot execute \"%s\"", inpspec);
53			error(SYSTEM, errmsg);
54			}
55	greg	1.1	} else {
56	greg	2.13	infn = inpspec;
57			if ((infp = fopen(inpspec, "r")) == NULL) {
58	greg	1.1	sprintf(errmsg, "cannot open octree file \"%s\"",
59	greg	2.13	inpspec);
60	greg	1.1	error(SYSTEM, errmsg);
61			}
62			}
63	schorsch	2.16	SET_FILE_BINARY(infp);
64	greg	1.1	/* get header */
65	greg	2.11	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
66	greg	1.12	octerror(USER, "not an octree");
67	greg	1.1	/* check format */
68	greg	2.4	if ((objsize = ogetint(2)-OCTMAGIC) <= 0 \|\|
69	greg	1.14	objsize > MAXOBJSIZ \|\| objsize > sizeof(long))
70	greg	1.12	octerror(USER, "incompatible octree format");
71	greg	1.1	/* get boundaries */
72			if (load & IO_BOUNDS) {
73			for (i = 0; i < 3; i++)
74	greg	2.4	scene->cuorg[i] = atof(ogetstr(sbuf));
75			scene->cusize = atof(ogetstr(sbuf));
76	greg	1.1	} else {
77			for (i = 0; i < 4; i++)
78	greg	2.4	ogetstr(sbuf);
79	greg	1.1	}
80			objorig = nobjects; /* set object offset */
81			nf = 0; /* get object files */
82	greg	2.4	while (*ogetstr(sbuf)) {
83	greg	1.1	if (load & IO_SCENE)
84			readobj(sbuf);
85			if (load & IO_FILES)
86			ofn[nf] = savqstr(sbuf);
87			nf++;
88			}
89			if (load & IO_FILES)
90			ofn[nf] = NULL;
91	greg	1.8	/* get number of objects */
92	greg	2.4	fnobjects = m = ogetint(objsize);
93	greg	1.15	if (fnobjects != m)
94			octerror(USER, "too many objects");
95	greg	1.1
96	greg	2.13	if (load & IO_TREE) /* get the octree */
97	greg	1.1	scene->cutree = gettree();
98	greg	2.5	else if (load & IO_SCENE && nf == 0)
99			skiptree();
100
101			if (load & IO_SCENE) /* get the scene */
102			if (nf == 0) {
103	greg	2.15	/* load binary scene data */
104			readscene(infp, objsize);
105
106	greg	2.5	} else { /* consistency checks */
107			/* check object count */
108			if (nobjects != objorig+fnobjects)
109			octerror(USER, "bad object count; octree stale?");
110			/* check for non-surfaces */
111	greg	2.12	if (dosets(nonsurfinset))
112	greg	2.5	octerror(USER, "modifier in tree; octree stale?");
113			}
114	greg	2.13	/* close the input */
115			if (infn[0] == '!')
116			pclose(infp);
117			else
118			fclose(infp);
119	greg	1.1	return(nf);
120			}
121
122
123			static char *
124	greg	2.4	ogetstr(s) /* get null-terminated string */
125	greg	1.1	char *s;
126			{
127	greg	2.4	extern char *getstr();
128	greg	1.1
129	greg	2.4	if (getstr(s, infp) == NULL)
130			octerror(USER, "truncated octree");
131			return(s);
132	greg	1.1	}
133
134
135			static OCTREE
136			getfullnode() /* get a set, return fullnode */
137			{
138	greg	2.7	OBJECT set[MAXSET+1];
139	greg	1.1	register int i;
140	greg	1.14	register long m;
141	greg	1.1
142	greg	2.4	if ((set[0] = ogetint(objsize)) > MAXSET)
143	greg	1.1	octerror(USER, "bad set in getfullnode");
144	greg	1.14	for (i = 1; i <= set[0]; i++) {
145	greg	2.4	m = ogetint(objsize) + objorig;
146	greg	1.15	if ((set[i] = m) != m)
147	greg	1.14	octerror(USER, "too many objects");
148			}
149	greg	1.1	return(fullnode(set));
150			}
151
152
153			static long
154	greg	2.4	ogetint(siz) /* get a siz-byte integer */
155			int siz;
156	greg	1.1	{
157	greg	2.4	extern long getint();
158	greg	1.3	register long r;
159	greg	1.1
160	greg	2.4	r = getint(siz, infp);
161			if (feof(infp))
162			octerror(USER, "truncated octree");
163	greg	1.1	return(r);
164			}
165
166
167			static double
168	greg	2.4	ogetflt() /* get a floating point number */
169	greg	1.1	{
170	greg	2.4	extern double getflt();
171	greg	2.7	double r;
172	greg	1.1
173	greg	2.4	r = getflt(infp);
174			if (feof(infp))
175			octerror(USER, "truncated octree");
176			return(r);
177	greg	1.1	}
178
179
180			static OCTREE
181			gettree() /* get a pre-ordered octree */
182			{
183	greg	2.7	register OCTREE ot;
184	greg	1.1	register int i;
185
186			switch (getc(infp)) {
187			case OT_EMPTY:
188			return(EMPTY);
189			case OT_FULL:
190			return(getfullnode());
191			case OT_TREE:
192			if ((ot = octalloc()) == EMPTY)
193			octerror(SYSTEM, "out of tree space in gettree");
194			for (i = 0; i < 8; i++)
195			octkid(ot, i) = gettree();
196			return(ot);
197	greg	2.5	case EOF:
198			octerror(USER, "truncated octree");
199			default:
200			octerror(USER, "damaged octree");
201			}
202	schorsch	2.17	return NULL; /* pro forma return */
203	greg	2.12	}
204
205
206			static int
207			nonsurfinset(os) /* check set for modifier */
208			register OBJECT *os;
209			{
210			register OBJECT s;
211			register int i;
212
213			for (i = *os; i-- > 0; )
214			if ((s = *++os) >= objorig && s < objorig+fnobjects &&
215			ismodifier(objptr(s)->otype))
216			return(1);
217			return(0);
218	greg	2.5	}
219
220
221	schorsch	2.17	static void
222			skiptree(void) /* skip octree on input */
223	greg	2.5	{
224			register int i;
225
226			switch (getc(infp)) {
227			case OT_EMPTY:
228			return;
229			case OT_FULL:
230	greg	2.6	for (i = ogetint(objsize)*objsize; i-- > 0; )
231			if (getc(infp) == EOF)
232			octerror(USER, "truncated octree");
233	greg	2.5	return;
234			case OT_TREE:
235			for (i = 0; i < 8; i++)
236			skiptree();
237			return;
238	greg	1.1	case EOF:
239			octerror(USER, "truncated octree");
240			default:
241			octerror(USER, "damaged octree");
242			}
243			}
244
245
246	schorsch	2.17	static void
247	greg	1.1	octerror(etyp, msg) /* octree error */
248			int etyp;
249			char *msg;
250			{
251			char msgbuf[128];
252
253			sprintf(msgbuf, "(%s): %s", infn, msg);
254			error(etyp, msgbuf);
255			}