src/common/instance.c

#ifndef lint
static const char RCSid[] = "$Id: instance.c,v 2.13 2024/11/05 00:03:10 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) {               /* new instance? */
                sc = (SCENE *)calloc(1, sizeof(SCENE));
                if (sc == NULL)
                        error(SYSTEM, "out of memory in getscene");
                sc->name = savestr(sname);
                sc->scube.cutree = EMPTY;
                sc->next = slist;
                slist = sc;
        }
        sc->nref++;                     /* bump reference count */
        if (!(flags &= ~sc->ldflags))   /* nothing to load? */
                return(sc);
        if ((pathname = getpath(sname, getrlibpath(), R_OK)) == NULL) {
                sprintf(errmsg, "cannot find octree file \"%s\"", sname);
                error(SYSTEM, errmsg);
        }
        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;
        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.14
Committed:	Thu Dec 12 20:04:46 2024 UTC (5 months, 2 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.13:	+6 -11 lines
Log Message:	perf: Eliminated unnecessary call to getpath() for loaded octree
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.14	static const char RCSid[] = "$Id: instance.c,v 2.13 2024/11/05 00:03:10 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	2.14	if (sc == NULL) { /* new instance? */
38			sc = (SCENE *)calloc(1, sizeof(SCENE));
39	greg	1.1	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.2	sc->scube.cutree = EMPTY;
43	greg	1.1	sc->next = slist;
44			slist = sc;
45			}
46	greg	2.14	sc->nref++; /* bump reference count */
47			if (!(flags &= ~sc->ldflags)) /* nothing to load? */
48			return(sc);
49	greg	2.8	if ((pathname = getpath(sname, getrlibpath(), R_OK)) == NULL) {
50	greg	1.1	sprintf(errmsg, "cannot find octree file \"%s\"", sname);
51	greg	2.12	error(SYSTEM, errmsg);
52	greg	1.1	}
53	greg	2.3	if (flags & IO_SCENE)
54	greg	2.2	sc->firstobj = nobjects;
55	greg	2.9	if (flags)
56			readoct(pathname, flags, &sc->scube, NULL);
57	greg	2.3	if (flags & IO_SCENE)
58	greg	2.2	sc->nobjs = nobjects - sc->firstobj;
59	greg	1.1	sc->ldflags \|= flags;
60			return(sc);
61			}
62
63
64			INSTANCE *
65	greg	2.13	getinstance( /* get instance structure */
66			OBJREC *o,
67			int flags
68			)
69	greg	1.1	{
70	greg	2.13	INSTANCE *ins;
71	greg	1.1
72	greg	2.3	flags &= ~IO_ILLEGAL; /* not allowed */
73	greg	2.5	if ((ins = (INSTANCE *)o->os) == NULL) {
74			if ((ins = (INSTANCE *)malloc(sizeof(INSTANCE))) == NULL)
75	greg	2.7	error(SYSTEM, "out of memory in getinstance");
76	greg	1.1	if (o->oargs.nsargs < 1)
77			objerror(o, USER, "bad # of arguments");
78	greg	2.5	if (fullxf(&ins->x, o->oargs.nsargs-1,
79	greg	1.1	o->oargs.sarg+1) != o->oargs.nsargs-1)
80			objerror(o, USER, "bad transform");
81	greg	2.5	if (ins->x.f.sca < 0.0) {
82			ins->x.f.sca = -ins->x.f.sca;
83			ins->x.b.sca = -ins->x.b.sca;
84			}
85			ins->obj = NULL;
86			o->os = (char *)ins;
87	greg	1.1	}
88	greg	2.13	if (ins->obj == NULL) {
89	greg	2.5	ins->obj = getscene(o->oargs.sarg[0], flags);
90	greg	2.13	} else if ((flags &= ~ins->obj->ldflags)) {
91	greg	2.9	if (flags & IO_SCENE)
92			ins->obj->firstobj = nobjects;
93			if (flags)
94			readoct(getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
95			flags, &ins->obj->scube, NULL);
96			if (flags & IO_SCENE)
97			ins->obj->nobjs = nobjects - ins->obj->firstobj;
98			ins->obj->ldflags \|= flags;
99			}
100	greg	2.5	return(ins);
101			}
102
103
104			void
105	greg	2.13	freescene( /* release a scene reference */
106			SCENE *sc
107			)
108	greg	2.5	{
109			SCENE shead;
110	greg	2.13	SCENE *scp;
111	greg	2.5
112			if (sc == NULL)
113			return;
114			if (sc->nref <= 0)
115			error(CONSISTENCY, "unreferenced scene in freescene");
116	greg	2.13	if (--sc->nref) /* still in use? */
117	greg	2.5	return;
118			shead.next = slist; /* else remove from our list */
119			for (scp = &shead; scp->next != NULL; scp = scp->next)
120			if (scp->next == sc) {
121			scp->next = sc->next;
122			sc->next = NULL;
123			break;
124			}
125			if (sc->next != NULL) /* can't be in list anymore */
126			error(CONSISTENCY, "unlisted scene in freescene");
127			slist = shead.next;
128			freestr(sc->name); /* free memory */
129			octfree(sc->scube.cutree);
130			freeobjects(sc->firstobj, sc->nobjs);
131	greg	2.13	free(sc);
132	greg	1.1	}
133	greg	1.7
134
135	greg	2.5	void
136	greg	2.13	freeinstance( /* free memory associated with instance */
137			OBJREC *o
138			)
139	greg	1.7	{
140	greg	1.8	if (o->os == NULL)
141			return;
142	greg	2.5	freescene(((INSTANCE )o->os).obj);
143	greg	2.13	free(o->os);
144	greg	1.8	o->os = NULL;
145	greg	1.7	}