src/common/instance.c

#ifndef lint
static const char RCSid[] = "$Id: instance.c,v 2.9 2003/07/10 03:30:11 greg Exp $";
#endif
/*
 *  instance.c - routines for octree objects.
 */

#include "copyright.h"

#include  "rtmath.h"
#include  "rterror.h"
#include  "rtio.h"

#include  "octree.h"
#include  "object.h"
#include  "instance.h"

#define  IO_ILLEGAL     (IO_FILES|IO_INFO)

static SCENE  *slist = NULL;            /* list of loaded octrees */


SCENE *
getscene(sname, flags)                  /* get new octree reference */
char  *sname;
int  flags;
{
        char  *pathname;
        register SCENE  *sc;

        flags &= ~IO_ILLEGAL;           /* not allowed */
        for (sc = slist; sc != NULL; sc = sc->next)
                if (!strcmp(sname, sc->name))
                        break;
        if (sc == NULL) {
                sc = (SCENE *)malloc(sizeof(SCENE));
                if (sc == NULL)
                        error(SYSTEM, "out of memory in getscene");
                sc->name = savestr(sname);
                sc->nref = 0;
                sc->ldflags = 0;
                sc->scube.cutree = EMPTY;
                sc->scube.cuorg[0] = sc->scube.cuorg[1] =
                                sc->scube.cuorg[2] = 0.;
                sc->scube.cusize = 0.;
                sc->firstobj = sc->nobjs = 0;
                sc->next = slist;
                slist = sc;
        }
        if ((pathname = getpath(sname, getrlibpath(), R_OK)) == NULL) {
                sprintf(errmsg, "cannot find octree file \"%s\"", sname);
                error(USER, errmsg);
        }
        flags &= ~sc->ldflags;          /* skip what's already loaded */
        if (flags & IO_SCENE)
                sc->firstobj = nobjects;
        if (flags)
                readoct(pathname, flags, &sc->scube, NULL);
        if (flags & IO_SCENE)
                sc->nobjs = nobjects - sc->firstobj;
        sc->ldflags |= flags;
        sc->nref++;                     /* increase reference count */
        return(sc);
}


INSTANCE *
getinstance(o, flags)                   /* get instance structure */
register OBJREC  *o;
int  flags;
{
        register INSTANCE  *ins;

        flags &= ~IO_ILLEGAL;           /* not allowed */
        if ((ins = (INSTANCE *)o->os) == NULL) {
                if ((ins = (INSTANCE *)malloc(sizeof(INSTANCE))) == NULL)
                        error(SYSTEM, "out of memory in getinstance");
                if (o->oargs.nsargs < 1)
                        objerror(o, USER, "bad # of arguments");
                if (fullxf(&ins->x, o->oargs.nsargs-1,
                                o->oargs.sarg+1) != o->oargs.nsargs-1)
                        objerror(o, USER, "bad transform");
                if (ins->x.f.sca < 0.0) {
                        ins->x.f.sca = -ins->x.f.sca;
                        ins->x.b.sca = -ins->x.b.sca;
                }
                ins->obj = NULL;
                o->os = (char *)ins;
        }
        if (ins->obj == NULL)
                ins->obj = getscene(o->oargs.sarg[0], flags);
        else if ((flags &= ~ins->obj->ldflags)) {
                if (flags & IO_SCENE)
                        ins->obj->firstobj = nobjects;
                if (flags)
                        readoct(getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
                                        flags, &ins->obj->scube, NULL);
                if (flags & IO_SCENE)
                        ins->obj->nobjs = nobjects - ins->obj->firstobj;
                ins->obj->ldflags |= flags;
        }
        return(ins);
}


void
freescene(sc)           /* release a scene reference */
SCENE *sc;
{
        SCENE  shead;
        register SCENE  *scp;

        if (sc == NULL)
                return;
        if (sc->nref <= 0)
                error(CONSISTENCY, "unreferenced scene in freescene");
        sc->nref--;
        if (sc->nref)                   /* still in use? */
                return;
        shead.next = slist;             /* else remove from our list */
        for (scp = &shead; scp->next != NULL; scp = scp->next)
                if (scp->next == sc) {
                        scp->next = sc->next;
                        sc->next = NULL;
                        break;
                }
        if (sc->next != NULL)           /* can't be in list anymore */
                error(CONSISTENCY, "unlisted scene in freescene");
        slist = shead.next;
        freestr(sc->name);              /* free memory */
        octfree(sc->scube.cutree);
        freeobjects(sc->firstobj, sc->nobjs);
        free((void *)sc);
}


void
freeinstance(o)         /* free memory associated with instance */
OBJREC  *o;
{
        if (o->os == NULL)
                return;
        freescene((*(INSTANCE *)o->os).obj);
        free((void *)o->os);
        o->os = NULL;
}
Revision:	2.10
Committed:	Fri Nov 14 17:22:06 2003 UTC (20 years, 5 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
Changes since 2.9:	+4 -4 lines
Log Message:	Reduced compile warnings, and other compatibility fixes.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	2.10	static const char RCSid[] = "$Id: instance.c,v 2.9 2003/07/10 03:30:11 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* instance.c - routines for octree objects.
6	greg	2.5	*/
7
8	greg	2.6	#include "copyright.h"
9	greg	1.1
10	schorsch	2.10	#include "rtmath.h"
11			#include "rterror.h"
12			#include "rtio.h"
13	greg	1.1
14	greg	2.5	#include "octree.h"
15	greg	1.1	#include "object.h"
16			#include "instance.h"
17
18	greg	2.3	#define IO_ILLEGAL (IO_FILES\|IO_INFO)
19
20	greg	1.1	static SCENE slist = NULL; / list of loaded octrees */
21
22
23			SCENE *
24	greg	2.9	getscene(sname, flags) /* get new octree reference */
25	greg	1.1	char *sname;
26			int flags;
27			{
28			char *pathname;
29			register SCENE *sc;
30
31	greg	2.3	flags &= ~IO_ILLEGAL; /* not allowed */
32	greg	1.1	for (sc = slist; sc != NULL; sc = sc->next)
33	greg	2.9	if (!strcmp(sname, sc->name))
34			break;
35	greg	1.1	if (sc == NULL) {
36			sc = (SCENE *)malloc(sizeof(SCENE));
37			if (sc == NULL)
38	greg	2.7	error(SYSTEM, "out of memory in getscene");
39	greg	1.1	sc->name = savestr(sname);
40	greg	2.9	sc->nref = 0;
41	greg	1.1	sc->ldflags = 0;
42	greg	2.2	sc->scube.cutree = EMPTY;
43			sc->scube.cuorg[0] = sc->scube.cuorg[1] =
44			sc->scube.cuorg[2] = 0.;
45			sc->scube.cusize = 0.;
46			sc->firstobj = sc->nobjs = 0;
47	greg	1.1	sc->next = slist;
48			slist = sc;
49			}
50	greg	2.8	if ((pathname = getpath(sname, getrlibpath(), R_OK)) == NULL) {
51	greg	1.1	sprintf(errmsg, "cannot find octree file \"%s\"", sname);
52			error(USER, errmsg);
53			}
54	greg	2.3	flags &= ~sc->ldflags; /* skip what's already loaded */
55			if (flags & IO_SCENE)
56	greg	2.2	sc->firstobj = nobjects;
57	greg	2.9	if (flags)
58			readoct(pathname, flags, &sc->scube, NULL);
59	greg	2.3	if (flags & IO_SCENE)
60	greg	2.2	sc->nobjs = nobjects - sc->firstobj;
61	greg	1.1	sc->ldflags \|= flags;
62	greg	2.9	sc->nref++; /* increase reference count */
63	greg	1.1	return(sc);
64			}
65
66
67			INSTANCE *
68			getinstance(o, flags) /* get instance structure */
69			register OBJREC *o;
70			int flags;
71			{
72	greg	2.5	register INSTANCE *ins;
73	greg	1.1
74	greg	2.3	flags &= ~IO_ILLEGAL; /* not allowed */
75	greg	2.5	if ((ins = (INSTANCE *)o->os) == NULL) {
76			if ((ins = (INSTANCE *)malloc(sizeof(INSTANCE))) == NULL)
77	greg	2.7	error(SYSTEM, "out of memory in getinstance");
78	greg	1.1	if (o->oargs.nsargs < 1)
79			objerror(o, USER, "bad # of arguments");
80	greg	2.5	if (fullxf(&ins->x, o->oargs.nsargs-1,
81	greg	1.1	o->oargs.sarg+1) != o->oargs.nsargs-1)
82			objerror(o, USER, "bad transform");
83	greg	2.5	if (ins->x.f.sca < 0.0) {
84			ins->x.f.sca = -ins->x.f.sca;
85			ins->x.b.sca = -ins->x.b.sca;
86			}
87			ins->obj = NULL;
88			o->os = (char *)ins;
89	greg	1.1	}
90	greg	2.9	if (ins->obj == NULL)
91	greg	2.5	ins->obj = getscene(o->oargs.sarg[0], flags);
92	greg	2.9	else if ((flags &= ~ins->obj->ldflags)) {
93			if (flags & IO_SCENE)
94			ins->obj->firstobj = nobjects;
95			if (flags)
96			readoct(getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
97			flags, &ins->obj->scube, NULL);
98			if (flags & IO_SCENE)
99			ins->obj->nobjs = nobjects - ins->obj->firstobj;
100			ins->obj->ldflags \|= flags;
101			}
102	greg	2.5	return(ins);
103			}
104
105
106			void
107			freescene(sc) /* release a scene reference */
108			SCENE *sc;
109			{
110			SCENE shead;
111			register SCENE *scp;
112
113			if (sc == NULL)
114			return;
115			if (sc->nref <= 0)
116			error(CONSISTENCY, "unreferenced scene in freescene");
117			sc->nref--;
118			if (sc->nref) /* still in use? */
119			return;
120			shead.next = slist; /* else remove from our list */
121			for (scp = &shead; scp->next != NULL; scp = scp->next)
122			if (scp->next == sc) {
123			scp->next = sc->next;
124			sc->next = NULL;
125			break;
126			}
127			if (sc->next != NULL) /* can't be in list anymore */
128			error(CONSISTENCY, "unlisted scene in freescene");
129			slist = shead.next;
130			freestr(sc->name); /* free memory */
131			octfree(sc->scube.cutree);
132			freeobjects(sc->firstobj, sc->nobjs);
133			free((void *)sc);
134	greg	1.1	}
135	greg	1.7
136
137	greg	2.5	void
138	greg	1.7	freeinstance(o) /* free memory associated with instance */
139			OBJREC *o;
140			{
141	greg	1.8	if (o->os == NULL)
142			return;
143	greg	2.5	freescene(((INSTANCE )o->os).obj);
144	greg	2.7	free((void *)o->os);
145	greg	1.8	o->os = NULL;
146	greg	1.7	}