src/common/instance.c

#ifndef lint
static const char RCSid[] = "$Id: instance.c,v 2.12 2016/03/22 03:56:17 greg Exp $";
#endif
/*
 *  instance.c - routines for octree objects.
 */

#include "copyright.h"

#include  "rtmath.h"
#include  "rterror.h"
#include  "rtio.h"
#include  "paths.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(                               /* get new octree reference */
        char  *sname,
        int  flags
)
{
        char  *pathname;
        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(SYSTEM, 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(                            /* get instance structure */
        OBJREC  *o,
        int  flags
)
{
        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(              /* release a scene reference */
        SCENE *sc
)
{
        SCENE  shead;
        SCENE  *scp;

        if (sc == NULL)
                return;
        if (sc->nref <= 0)
                error(CONSISTENCY, "unreferenced scene in freescene");
        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(sc);
}


void
freeinstance(           /* free memory associated with instance */
        OBJREC  *o
)
{
        if (o->os == NULL)
                return;
        freescene((*(INSTANCE *)o->os).obj);
        free(o->os);
        o->os = NULL;
}
Revision:	2.13
Committed:	Tue Nov 5 00:03:10 2024 UTC (6 months, 3 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.12:	+23 -20 lines
Log Message:	style: ANSIfication
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.13	static const char RCSid[] = "$Id: instance.c,v 2.12 2016/03/22 03:56:17 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	2.11	#include "paths.h"
14	greg	1.1
15	greg	2.5	#include "octree.h"
16	greg	1.1	#include "object.h"
17			#include "instance.h"
18
19	greg	2.3	#define IO_ILLEGAL (IO_FILES\|IO_INFO)
20
21	greg	1.1	static SCENE slist = NULL; / list of loaded octrees */
22
23
24			SCENE *
25	greg	2.13	getscene( /* get new octree reference */
26			char *sname,
27			int flags
28			)
29	greg	1.1	{
30			char *pathname;
31	greg	2.13	SCENE *sc;
32	greg	1.1
33	greg	2.3	flags &= ~IO_ILLEGAL; /* not allowed */
34	greg	1.1	for (sc = slist; sc != NULL; sc = sc->next)
35	greg	2.9	if (!strcmp(sname, sc->name))
36			break;
37	greg	1.1	if (sc == NULL) {
38			sc = (SCENE *)malloc(sizeof(SCENE));
39			if (sc == NULL)
40	greg	2.7	error(SYSTEM, "out of memory in getscene");
41	greg	1.1	sc->name = savestr(sname);
42	greg	2.9	sc->nref = 0;
43	greg	1.1	sc->ldflags = 0;
44	greg	2.2	sc->scube.cutree = EMPTY;
45			sc->scube.cuorg[0] = sc->scube.cuorg[1] =
46			sc->scube.cuorg[2] = 0.;
47			sc->scube.cusize = 0.;
48			sc->firstobj = sc->nobjs = 0;
49	greg	1.1	sc->next = slist;
50			slist = sc;
51			}
52	greg	2.8	if ((pathname = getpath(sname, getrlibpath(), R_OK)) == NULL) {
53	greg	1.1	sprintf(errmsg, "cannot find octree file \"%s\"", sname);
54	greg	2.12	error(SYSTEM, errmsg);
55	greg	1.1	}
56	greg	2.3	flags &= ~sc->ldflags; /* skip what's already loaded */
57			if (flags & IO_SCENE)
58	greg	2.2	sc->firstobj = nobjects;
59	greg	2.9	if (flags)
60			readoct(pathname, flags, &sc->scube, NULL);
61	greg	2.3	if (flags & IO_SCENE)
62	greg	2.2	sc->nobjs = nobjects - sc->firstobj;
63	greg	1.1	sc->ldflags \|= flags;
64	greg	2.9	sc->nref++; /* increase reference count */
65	greg	1.1	return(sc);
66			}
67
68
69			INSTANCE *
70	greg	2.13	getinstance( /* get instance structure */
71			OBJREC *o,
72			int flags
73			)
74	greg	1.1	{
75	greg	2.13	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.13	if (ins->obj == NULL) {
94	greg	2.5	ins->obj = getscene(o->oargs.sarg[0], flags);
95	greg	2.13	} else if ((flags &= ~ins->obj->ldflags)) {
96	greg	2.9	if (flags & IO_SCENE)
97			ins->obj->firstobj = nobjects;
98			if (flags)
99			readoct(getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
100			flags, &ins->obj->scube, NULL);
101			if (flags & IO_SCENE)
102			ins->obj->nobjs = nobjects - ins->obj->firstobj;
103			ins->obj->ldflags \|= flags;
104			}
105	greg	2.5	return(ins);
106			}
107
108
109			void
110	greg	2.13	freescene( /* release a scene reference */
111			SCENE *sc
112			)
113	greg	2.5	{
114			SCENE shead;
115	greg	2.13	SCENE *scp;
116	greg	2.5
117			if (sc == NULL)
118			return;
119			if (sc->nref <= 0)
120			error(CONSISTENCY, "unreferenced scene in freescene");
121	greg	2.13	if (--sc->nref) /* still in use? */
122	greg	2.5	return;
123			shead.next = slist; /* else remove from our list */
124			for (scp = &shead; scp->next != NULL; scp = scp->next)
125			if (scp->next == sc) {
126			scp->next = sc->next;
127			sc->next = NULL;
128			break;
129			}
130			if (sc->next != NULL) /* can't be in list anymore */
131			error(CONSISTENCY, "unlisted scene in freescene");
132			slist = shead.next;
133			freestr(sc->name); /* free memory */
134			octfree(sc->scube.cutree);
135			freeobjects(sc->firstobj, sc->nobjs);
136	greg	2.13	free(sc);
137	greg	1.1	}
138	greg	1.7
139
140	greg	2.5	void
141	greg	2.13	freeinstance( /* free memory associated with instance */
142			OBJREC *o
143			)
144	greg	1.7	{
145	greg	1.8	if (o->os == NULL)
146			return;
147	greg	2.5	freescene(((INSTANCE )o->os).obj);
148	greg	2.13	free(o->os);
149	greg	1.8	o->os = NULL;
150	greg	1.7	}