src/common/instance.c

#ifndef lint
static const char RCSid[] = "$Id$";
#endif
/*
 *  instance.c - routines for octree objects.
 */

#include "copyright.h"

#include  "standard.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)                  /* load octree sname */
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)) {
                        if ((sc->ldflags & flags) == flags) {
                                sc->nref++;
                                return(sc);             /* loaded */
                        }
                        break;                  /* load the rest */
                }
        if (sc == NULL) {
                sc = (SCENE *)malloc(sizeof(SCENE));
                if (sc == NULL)
                        error(SYSTEM, "out of memory in getscene");
                sc->name = savestr(sname);
                sc->nref = 1;
                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, getlibpath(), 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;
        readoct(pathname, flags, &sc->scube, NULL);
        if (flags & IO_SCENE)
                sc->nobjs = nobjects - sc->firstobj;
        sc->ldflags |= flags;
        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->ldflags & flags) != flags)
                ins->obj = getscene(o->oargs.sarg[0], 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.7
Committed:	Tue Mar 4 05:49:21 2003 UTC (21 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.6:	+4 -4 lines
Log Message:	Moved dircode.c and fixed prototype compiles in hd directory
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.7	static const char RCSid[] = "$Id$";
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			#include "standard.h"
11
12	greg	2.5	#include "octree.h"
13
14	greg	1.1	#include "object.h"
15
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			getscene(sname, flags) /* load octree sname */
25			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			if (!strcmp(sname, sc->name)) {
34	greg	2.5	if ((sc->ldflags & flags) == flags) {
35			sc->nref++;
36	greg	1.1	return(sc); /* loaded */
37	greg	2.5	}
38	greg	1.1	break; /* load the rest */
39			}
40			if (sc == NULL) {
41			sc = (SCENE *)malloc(sizeof(SCENE));
42			if (sc == NULL)
43	greg	2.7	error(SYSTEM, "out of memory in getscene");
44	greg	1.1	sc->name = savestr(sname);
45	greg	2.5	sc->nref = 1;
46	greg	1.1	sc->ldflags = 0;
47	greg	2.2	sc->scube.cutree = EMPTY;
48			sc->scube.cuorg[0] = sc->scube.cuorg[1] =
49			sc->scube.cuorg[2] = 0.;
50			sc->scube.cusize = 0.;
51			sc->firstobj = sc->nobjs = 0;
52	greg	1.1	sc->next = slist;
53			slist = sc;
54			}
55	greg	2.4	if ((pathname = getpath(sname, getlibpath(), R_OK)) == NULL) {
56	greg	1.1	sprintf(errmsg, "cannot find octree file \"%s\"", sname);
57			error(USER, errmsg);
58			}
59	greg	2.3	flags &= ~sc->ldflags; /* skip what's already loaded */
60			if (flags & IO_SCENE)
61	greg	2.2	sc->firstobj = nobjects;
62	greg	2.3	readoct(pathname, flags, &sc->scube, NULL);
63			if (flags & IO_SCENE)
64	greg	2.2	sc->nobjs = nobjects - sc->firstobj;
65	greg	1.1	sc->ldflags \|= flags;
66			return(sc);
67			}
68
69
70			INSTANCE *
71			getinstance(o, flags) /* get instance structure */
72			register OBJREC *o;
73			int flags;
74			{
75	greg	2.5	register INSTANCE *ins;
76	greg	1.1
77	greg	2.3	flags &= ~IO_ILLEGAL; /* not allowed */
78	greg	2.5	if ((ins = (INSTANCE *)o->os) == NULL) {
79			if ((ins = (INSTANCE *)malloc(sizeof(INSTANCE))) == NULL)
80	greg	2.7	error(SYSTEM, "out of memory in getinstance");
81	greg	1.1	if (o->oargs.nsargs < 1)
82			objerror(o, USER, "bad # of arguments");
83	greg	2.5	if (fullxf(&ins->x, o->oargs.nsargs-1,
84	greg	1.1	o->oargs.sarg+1) != o->oargs.nsargs-1)
85			objerror(o, USER, "bad transform");
86	greg	2.5	if (ins->x.f.sca < 0.0) {
87			ins->x.f.sca = -ins->x.f.sca;
88			ins->x.b.sca = -ins->x.b.sca;
89			}
90			ins->obj = NULL;
91			o->os = (char *)ins;
92	greg	1.1	}
93	greg	2.5	if (ins->obj == NULL \|\| (ins->obj->ldflags & flags) != flags)
94			ins->obj = getscene(o->oargs.sarg[0], flags);
95			return(ins);
96			}
97
98
99			void
100			freescene(sc) /* release a scene reference */
101			SCENE *sc;
102			{
103			SCENE shead;
104			register SCENE *scp;
105
106			if (sc == NULL)
107			return;
108			if (sc->nref <= 0)
109			error(CONSISTENCY, "unreferenced scene in freescene");
110			sc->nref--;
111			if (sc->nref) /* still in use? */
112			return;
113			shead.next = slist; /* else remove from our list */
114			for (scp = &shead; scp->next != NULL; scp = scp->next)
115			if (scp->next == sc) {
116			scp->next = sc->next;
117			sc->next = NULL;
118			break;
119			}
120			if (sc->next != NULL) /* can't be in list anymore */
121			error(CONSISTENCY, "unlisted scene in freescene");
122			slist = shead.next;
123			freestr(sc->name); /* free memory */
124			octfree(sc->scube.cutree);
125			freeobjects(sc->firstobj, sc->nobjs);
126			free((void *)sc);
127	greg	1.1	}
128	greg	1.7
129
130	greg	2.5	void
131	greg	1.7	freeinstance(o) /* free memory associated with instance */
132			OBJREC *o;
133			{
134	greg	1.8	if (o->os == NULL)
135			return;
136	greg	2.5	freescene(((INSTANCE )o->os).obj);
137	greg	2.7	free((void *)o->os);
138	greg	1.8	o->os = NULL;
139	greg	1.7	}