src/rt/raycalls.c

#ifndef lint
static const char       RCSid[] = "$Id: raycalls.c,v 2.32 2025/04/23 02:35:26 greg Exp $";
#endif
/*
 *  raycalls.c - interface for running Radiance rendering as a library
 *
 *  External symbols declared in ray.h
 */

#include "copyright.h"

/*
 *  These routines are designed to aid the programmer who wishes
 *  to call Radiance as a library.  Unfortunately, the system was
 *  not originally intended to be run this way, and there are some
 *  awkward limitations to contend with.  The most irritating
 *  perhaps is that the global variables and functions do not have
 *  a prefix, and the symbols are a bit generic.  This results in a
 *  serious invasion of the calling application's name-space, and
 *  you may need to rename either some Radiance routines or some
 *  of your routines to avoid conflicts.  Another limitation is
 *  that the global variables are not gathered together into any
 *  sort of context, so it is impossible to simultaneously run
 *  this library on multiple scenes or in multiple threads.
 *  You get one scene and one thread, and if you want more, you
 *  will have to go with the process model defined in raypcalls.c.
 *  Finally, unrecoverable errors result in a call to the application-
 *  defined function quit().  The usual thing to do is to call exit().
 *  You might want to do something else instead, like
 *  call setjmp()/longjmp() to bring you back to the calling
 *  function for recovery.  You may also wish to define your own
 *  wputs(s) and eputs(s) functions to output warning and error
 *  messages, respectively.
 *
 *  With those caveats, we have attempted to make the interface
 *  as simple as we can.  Global variables and their defaults
 *  are defined below, and including "ray.h" declares these
 *  along with all the routines you are likely to need.  First,
 *  assign the global variable progname by calling fixargv0(argv[0]),
 *  then change the rendering parameters as you like.  If you have a
 *  set of option arguments you are working from, the getrenderopt()
 *  call should be very useful.  Before tracing any rays, you
 *  must read in the octree with a call to ray_init(oct).
 *  Passing NULL for the file name causes ray_init() to read
 *  the octree from the standard input -- rarely a good idea.
 *  However, one may read an octree from a program (such as
 *  oconv) by preceding a shell command by a '!' character.
 *
 *  To trace a ray, define a RAY object myRay and assign:
 *
 *      myRay.rorg = ( ray origin point )
 *      myRay.rdir = ( normalized ray direction )
 *      myRay.rmax = ( maximum length, or zero for no limit )
 *
 *  If you are rendering from a VIEW structure, this can be
 *  accomplished with a single call for the ray at (x,y):
 *
 *      myRay.rmax = viewray(myRay.rorg, myRay.rdir, &myView, x, y);
 *
 *  Then, trace the primary ray with:
 *
 *      ray_trace(&myRay);
 *
 *  The resulting contents of myRay should provide you with
 *  more than enough information about what the ray hit,
 *  the computed value, etc.  For further clues of how to
 *  compute irradiance, how to get callbacks on the evaluated
 *  ray tree, etc., see the contents of rtrace.c.  See
 *  also the rpmain.c, rtmain.c, and rvmain.c modules
 *  to learn more how rendering options are processed.
 *
 *  When you are done, you may call ray_done(1) to clean
 *  up memory used by Radiance.  It doesn't free everything,
 *  but it makes a valiant effort.  If you call ray_done(0),
 *  it leaves data that is likely to be reused, including
 *  loaded data files and fonts.  The library may be
 *  restarted at any point by calling ray_init() on a new
 *  octree.
 *
 *  The call ray_save(rp) fills a parameter structure
 *  with the current global parameter settings, which may be
 *  restored at any time with a call to ray_restore(rp).
 *  This buffer contains no linked information, and thus
 *  may be passed between processes using write() and
 *  read() calls, so long as byte order is maintained.
 *  Calling ray_restore(NULL) restores the original
 *  default parameters, which is also retrievable with
 *  the call ray_defaults(rp).  (These  should be the
 *  same as the defaults for rtrace.)
 */

#include <string.h>
#include <time.h>

#include  "ray.h"
#include  "source.h"
#include  "bsdf.h"
#include  "ambient.h"
#include  "otypes.h"
#include  "random.h"
#include  "func.h"
#include  "data.h"
#include  "font.h"
#include  "pmapray.h"

char    *octname;                       /* octree name we are given */

CUBE    thescene;                       /* our scene */
OBJECT  nsceneobjs;                     /* number of objects in our scene */

int     dimlist[MAXDIM];                /* sampling dimensions */
int     ndims = 0;                      /* number of sampling dimensions */
int     samplendx = 0;                  /* index for this sample */

void    (*trace)() = NULL;              /* trace call */

void    (*addobjnotify[8])() = {ambnotify, NULL};

int     castonly = 0;                   /* only doing ray-casting? */

int     do_irrad = 0;                   /* compute irradiance? */

int     rand_samp = 1;                  /* pure Monte Carlo sampling? */

double  dstrsrc = 0.0;                  /* square source distribution */
double  shadthresh = .03;               /* shadow threshold */
double  shadcert = .75;                 /* shadow certainty */
int     directrelay = 2;                /* number of source relays */
int     vspretest = 512;                /* virtual source pretest density */
int     directvis = 1;                  /* sources visible? */
double  srcsizerat = .2;                /* maximum ratio source size/dist. */

COLOR   cextinction = BLKCOLOR;         /* global extinction coefficient */
COLOR   salbedo = BLKCOLOR;             /* global scattering albedo */
double  seccg = 0.;                     /* global scattering eccentricity */
double  ssampdist = 0.;                 /* scatter sampling distance */

double  specthresh = .15;               /* specular sampling threshold */
double  specjitter = 1.;                /* specular sampling jitter */

int     backvis = 1;                    /* back face visibility */

int     maxdepth = -10;                 /* maximum recursion depth */
double  minweight = 1e-4;               /* minimum ray weight */

char    *ambfile = NULL;                /* ambient file name */
COLOR   ambval = BLKCOLOR;              /* ambient value */
int     ambvwt = 0;                     /* initial weight for ambient value */
double  ambacc = 0.1;                   /* ambient accuracy */
int     ambres = 256;                   /* ambient resolution */
int     ambdiv = 1024;                  /* ambient divisions */
int     ambssamp = 512;                 /* ambient super-samples */
int     ambounce = 0;                   /* ambient bounces */
char    *amblist[AMBLLEN+1];            /* ambient include/exclude list */
int     ambincl = -1;                   /* include == 1, exclude == 0 */


static void
reset_random(void)              /* re-initialize random number generator */
{
        if (rand_samp) {
                srandom((long)time(0));
                initurand(0);
        } else {
                srandom(0L);
                initurand(2048);
        }
}


void
ray_init(                       /* initialize ray-tracing calculation */
        char    *otnm
)
{
        if (nobjects > 0)               /* free old scene data */
                ray_done(0);
                                        /* initialize object types */
        if (ofun[OBJ_SPHERE].funp == o_default)
                initotypes();
                                        /* initialize calcomp routines */
        initfunc();
                                        /* initialize urand */
        reset_random();
                                        /* initialize spectral sampling */
        if (setspectrsamp(CNDX, WLPART) < 0)
                error(USER, "unsupported spectral sampling");

        octname = savqstr(otnm);        /* read scene octree */
        readoct(octname, ~(IO_FILES|IO_INFO), &thescene, NULL);
        nsceneobjs = nobjects;

        if (!castonly) {                /* any actual ray traversal to do? */

                ray_init_pmap();        /* PMAP: set up & load photon maps */

                marksources();          /* find and mark sources */

                setambient();           /* initialize ambient calculation */
        } else
                distantsources();       /* else mark only distant sources */
}


void
ray_trace(                      /* trace a primary ray */
        RAY     *r
)
{
        rayorigin(r, PRIMARY, NULL, NULL);
        samplendx++;
        rayvalue(r);            /* assumes origin and direction are set */
}


void
ray_done(               /* free ray-tracing data */
        int     freall
)
{
        retainfonts = 1;
        ambdone();
        ambnotify(OVOID);
        freesources();
        freeobjects(0, nobjects);
        donesets();
        octdone();
        thescene.cutree = EMPTY;
        freeqstr(octname); octname = NULL;
        retainfonts = 0;
        if (freall) {
                freefont(NULL);
                freedata(NULL);
                SDfreeCache(NULL);
                initurand(0);
        }
        if (nobjects > 0) {
                sprintf(errmsg, "%ld objects left after call to ray_done()",
                                (long)nobjects);
                error(WARNING, errmsg);
        }
        
        ray_done_pmap();
}


void
ray_save(                       /* save current parameter settings */
        RAYPARAMS       *rp
)
{
        int     i, ndx;

        if (rp == NULL)
                return;
        rp->do_irrad = do_irrad;
        rp->rand_samp = rand_samp;
        rp->dstrsrc = dstrsrc;
        rp->shadthresh = shadthresh;
        rp->shadcert = shadcert;
        rp->directrelay = directrelay;
        rp->vspretest = vspretest;
        rp->directvis = directvis;
        rp->srcsizerat = srcsizerat;
        copycolor(rp->cextinction, cextinction);
        copycolor(rp->salbedo, salbedo);
        rp->seccg = seccg;
        rp->ssampdist = ssampdist;
        rp->specthresh = specthresh;
        rp->specjitter = specjitter;
        rp->backvis = backvis;
        rp->maxdepth = maxdepth;
        rp->minweight = minweight;
        if (ambfile != NULL)
                strncpy(rp->ambfile, ambfile, sizeof(rp->ambfile)-1);
        else
                memset(rp->ambfile, '\0', sizeof(rp->ambfile));
        copycolor(rp->ambval, ambval);
        rp->ambvwt = ambvwt;
        rp->ambacc = ambacc;
        rp->ambres = ambres;
        rp->ambdiv = ambdiv;
        rp->ambssamp = ambssamp;
        rp->ambounce = ambounce;
        rp->ambincl = ambincl;
        memset(rp->amblval, '\0', sizeof(rp->amblval));
        ndx = 0;
        for (i = 0; i < AMBLLEN && amblist[i] != NULL; i++) {
                int     len = strlen(amblist[i]);
                if (ndx+len >= sizeof(rp->amblval))
                        break;
                strcpy(rp->amblval+ndx, amblist[i]);
                rp->amblndx[i] = ndx;
                ndx += len+1;
        }
        while (i <= AMBLLEN)
                rp->amblndx[i++] = -1;
                
        /* PMAP: save photon mapping params */
        ray_save_pmap(rp);
}


void
ray_restore(                    /* restore parameter settings */
        RAYPARAMS       *rp
)
{
        int     i;

        if (rp == NULL) {               /* restore defaults */
                RAYPARAMS       dflt;
                ray_defaults(&dflt);
                ray_restore(&dflt);
                return;
        }
                                        /* restore saved settings */
        do_irrad = rp->do_irrad;
        if (!rand_samp != !rp->rand_samp) {
                rand_samp = rp->rand_samp;
                reset_random();
        }
        dstrsrc = rp->dstrsrc;
        shadthresh = rp->shadthresh;
        shadcert = rp->shadcert;
        directrelay = rp->directrelay;
        vspretest = rp->vspretest;
        directvis = rp->directvis;
        srcsizerat = rp->srcsizerat;
        copycolor(cextinction, rp->cextinction);
        copycolor(salbedo, rp->salbedo);
        seccg = rp->seccg;
        ssampdist = rp->ssampdist;
        specthresh = rp->specthresh;
        specjitter = rp->specjitter;
        backvis = rp->backvis;
        maxdepth = rp->maxdepth;
        minweight = rp->minweight;
        copycolor(ambval, rp->ambval);
        ambvwt = rp->ambvwt;
        ambdiv = rp->ambdiv;
        ambssamp = rp->ambssamp;
        ambounce = rp->ambounce;
                                        /* a bit dangerous if not static */
        for (i = 0; rp->amblndx[i] >= 0; i++)
                amblist[i] = rp->amblval + rp->amblndx[i];
        while (i <= AMBLLEN)
                amblist[i++] = NULL;
        ambincl = rp->ambincl;
                                        /* update ambient calculation */
        ambnotify(OVOID);
        if ((thescene.cutree != EMPTY) & !castonly) {
                int     newamb = (ambfile == NULL) ?  rp->ambfile[0] :
                                        strcmp(ambfile, rp->ambfile) ;

                if (amblist[0] != NULL)
                        for (i = 0; i < nobjects; i++)
                                ambnotify(i);

                ambfile = (rp->ambfile[0]) ? rp->ambfile : (char *)NULL;
                if (newamb) {
                        ambres = rp->ambres;
                        ambacc = rp->ambacc;
                        setambient();
                } else {
                        setambres(rp->ambres);
                        setambacc(rp->ambacc);
                }
        } else {
                ambfile = (rp->ambfile[0]) ? rp->ambfile : (char *)NULL;
                ambres = rp->ambres;
                ambacc = rp->ambacc;
        }
        
        /* PMAP: restore photon mapping params */
        ray_restore_pmap(rp);
}


void
ray_defaults(           /* get default parameter values */
        RAYPARAMS       *rp
)
{
        int     i;

        if (rp == NULL)
                return;

        rp->do_irrad = 0;
        rp->rand_samp = 1;
        rp->dstrsrc = 0.0;
        rp->shadthresh = 0.03;
        rp->shadcert = 0.75;
        rp->directrelay = 2;
        rp->vspretest = 512;
        rp->directvis = 1;
        rp->srcsizerat = .2;
        setcolor(rp->cextinction, 0., 0., 0.);
        setcolor(rp->salbedo, 0., 0., 0.);
        rp->seccg = 0.;
        rp->ssampdist = 0.;
        rp->specthresh = 0.15;
        rp->specjitter = 1.;
        rp->backvis = 1;
        rp->maxdepth = -10;
        rp->minweight = 1e-4;
        memset(rp->ambfile, '\0', sizeof(rp->ambfile));
        setcolor(rp->ambval, 0., 0., 0.);
        rp->ambvwt = 0;
        rp->ambres = 256;
        rp->ambacc = 0.1;
        rp->ambdiv = 1024;
        rp->ambssamp = 512;
        rp->ambounce = 0;
        rp->ambincl = -1;
        memset(rp->amblval, '\0', sizeof(rp->amblval));
        for (i = AMBLLEN+1; i--; )
                rp->amblndx[i] = -1;
        
        /* PMAP: restore photon mapping defaults */
        ray_defaults_pmap(rp);
}
Revision:	2.33
Committed:	Tue Jun 3 21:31:51 2025 UTC (44 hours, 57 minutes ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.32:	+4 -6 lines
Log Message:	refactor: More consistent use of global char * progname and fixargv0()
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.33	static const char RCSid[] = "$Id: raycalls.c,v 2.32 2025/04/23 02:35:26 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* raycalls.c - interface for running Radiance rendering as a library
6			*
7			* External symbols declared in ray.h
8			*/
9
10	greg	2.2	#include "copyright.h"
11	greg	2.1
12			/*
13			* These routines are designed to aid the programmer who wishes
14			* to call Radiance as a library. Unfortunately, the system was
15			* not originally intended to be run this way, and there are some
16			* awkward limitations to contend with. The most irritating
17			* perhaps is that the global variables and functions do not have
18			* a prefix, and the symbols are a bit generic. This results in a
19			* serious invasion of the calling application's name-space, and
20			* you may need to rename either some Radiance routines or some
21			* of your routines to avoid conflicts. Another limitation is
22			* that the global variables are not gathered together into any
23			* sort of context, so it is impossible to simultaneously run
24			* this library on multiple scenes or in multiple threads.
25			* You get one scene and one thread, and if you want more, you
26	greg	2.10	* will have to go with the process model defined in raypcalls.c.
27			* Finally, unrecoverable errors result in a call to the application-
28			* defined function quit(). The usual thing to do is to call exit().
29	greg	2.1	* You might want to do something else instead, like
30			* call setjmp()/longjmp() to bring you back to the calling
31			* function for recovery. You may also wish to define your own
32			* wputs(s) and eputs(s) functions to output warning and error
33			* messages, respectively.
34			*
35			* With those caveats, we have attempted to make the interface
36			* as simple as we can. Global variables and their defaults
37			* are defined below, and including "ray.h" declares these
38			* along with all the routines you are likely to need. First,
39	greg	2.33	* assign the global variable progname by calling fixargv0(argv[0]),
40			* then change the rendering parameters as you like. If you have a
41			* set of option arguments you are working from, the getrenderopt()
42	greg	2.1	* call should be very useful. Before tracing any rays, you
43			* must read in the octree with a call to ray_init(oct).
44			* Passing NULL for the file name causes ray_init() to read
45			* the octree from the standard input -- rarely a good idea.
46			* However, one may read an octree from a program (such as
47			* oconv) by preceding a shell command by a '!' character.
48			*
49			* To trace a ray, define a RAY object myRay and assign:
50			*
51			* myRay.rorg = ( ray origin point )
52			* myRay.rdir = ( normalized ray direction )
53			* myRay.rmax = ( maximum length, or zero for no limit )
54			*
55			* If you are rendering from a VIEW structure, this can be
56			* accomplished with a single call for the ray at (x,y):
57			*
58			* myRay.rmax = viewray(myRay.rorg, myRay.rdir, &myView, x, y);
59			*
60			* Then, trace the primary ray with:
61			*
62			* ray_trace(&myRay);
63			*
64			* The resulting contents of myRay should provide you with
65			* more than enough information about what the ray hit,
66			* the computed value, etc. For further clues of how to
67			* compute irradiance, how to get callbacks on the evaluated
68			* ray tree, etc., see the contents of rtrace.c. See
69			* also the rpmain.c, rtmain.c, and rvmain.c modules
70			* to learn more how rendering options are processed.
71			*
72			* When you are done, you may call ray_done(1) to clean
73			* up memory used by Radiance. It doesn't free everything,
74			* but it makes a valiant effort. If you call ray_done(0),
75			* it leaves data that is likely to be reused, including
76			* loaded data files and fonts. The library may be
77			* restarted at any point by calling ray_init() on a new
78			* octree.
79			*
80	greg	2.3	* The call ray_save(rp) fills a parameter structure
81	greg	2.1	* with the current global parameter settings, which may be
82			* restored at any time with a call to ray_restore(rp).
83			* This buffer contains no linked information, and thus
84			* may be passed between processes using write() and
85			* read() calls, so long as byte order is maintained.
86			* Calling ray_restore(NULL) restores the original
87			* default parameters, which is also retrievable with
88			* the call ray_defaults(rp). (These should be the
89			* same as the defaults for rtrace.)
90			*/
91
92	schorsch	2.4	#include <string.h>
93	greg	2.14	#include <time.h>
94	schorsch	2.4
95	greg	2.1	#include "ray.h"
96			#include "source.h"
97	greg	2.19	#include "bsdf.h"
98	greg	2.1	#include "ambient.h"
99			#include "otypes.h"
100			#include "random.h"
101	greg	2.32	#include "func.h"
102	greg	2.1	#include "data.h"
103			#include "font.h"
104	greg	2.21	#include "pmapray.h"
105	greg	2.1
106			char octname; / octree name we are given */
107
108			CUBE thescene; /* our scene */
109			OBJECT nsceneobjs; /* number of objects in our scene */
110
111			int dimlist[MAXDIM]; /* sampling dimensions */
112			int ndims = 0; /* number of sampling dimensions */
113			int samplendx = 0; /* index for this sample */
114
115			void (trace)() = NULL; / trace call */
116
117	greg	2.6	void (*addobjnotify[8])() = {ambnotify, NULL};
118	greg	2.1
119	greg	2.27	int castonly = 0; /* only doing ray-casting? */
120
121	greg	2.1	int do_irrad = 0; /* compute irradiance? */
122
123	greg	2.24	int rand_samp = 1; /* pure Monte Carlo sampling? */
124	greg	2.13
125	greg	2.1	double dstrsrc = 0.0; /* square source distribution */
126	greg	2.8	double shadthresh = .03; /* shadow threshold */
127			double shadcert = .75; /* shadow certainty */
128	greg	2.1	int directrelay = 2; /* number of source relays */
129			int vspretest = 512; /* virtual source pretest density */
130			int directvis = 1; /* sources visible? */
131			double srcsizerat = .2; /* maximum ratio source size/dist. */
132
133			COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
134			COLOR salbedo = BLKCOLOR; /* global scattering albedo */
135			double seccg = 0.; /* global scattering eccentricity */
136			double ssampdist = 0.; /* scatter sampling distance */
137
138			double specthresh = .15; /* specular sampling threshold */
139			double specjitter = 1.; /* specular sampling jitter */
140
141			int backvis = 1; /* back face visibility */
142
143	greg	2.24	int maxdepth = -10; /* maximum recursion depth */
144	greg	2.26	double minweight = 1e-4; /* minimum ray weight */
145	greg	2.1
146			char ambfile = NULL; / ambient file name */
147			COLOR ambval = BLKCOLOR; /* ambient value */
148			int ambvwt = 0; /* initial weight for ambient value */
149	greg	2.8	double ambacc = 0.1; /* ambient accuracy */
150			int ambres = 256; /* ambient resolution */
151			int ambdiv = 1024; /* ambient divisions */
152			int ambssamp = 512; /* ambient super-samples */
153	greg	2.1	int ambounce = 0; /* ambient bounces */
154			char amblist[AMBLLEN+1]; / ambient include/exclude list */
155			int ambincl = -1; /* include == 1, exclude == 0 */
156
157
158	greg	2.25	static void
159			reset_random(void) /* re-initialize random number generator */
160			{
161			if (rand_samp) {
162			srandom((long)time(0));
163			initurand(0);
164			} else {
165			srandom(0L);
166			initurand(2048);
167			}
168			}
169
170
171	greg	2.17	void
172	schorsch	2.9	ray_init( /* initialize ray-tracing calculation */
173			char *otnm
174			)
175	greg	2.1	{
176			if (nobjects > 0) /* free old scene data */
177			ray_done(0);
178			/* initialize object types */
179			if (ofun[OBJ_SPHERE].funp == o_default)
180			initotypes();
181	greg	2.32	/* initialize calcomp routines */
182			initfunc();
183	greg	2.1	/* initialize urand */
184	greg	2.25	reset_random();
185	greg	2.30	/* initialize spectral sampling */
186			if (setspectrsamp(CNDX, WLPART) < 0)
187			error(USER, "unsupported spectral sampling");
188	greg	2.27
189			octname = savqstr(otnm); /* read scene octree */
190			readoct(octname, ~(IO_FILES\|IO_INFO), &thescene, NULL);
191	greg	2.1	nsceneobjs = nobjects;
192	greg	2.27
193			if (!castonly) { /* any actual ray traversal to do? */
194
195			ray_init_pmap(); /* PMAP: set up & load photon maps */
196
197			marksources(); /* find and mark sources */
198
199			setambient(); /* initialize ambient calculation */
200			} else
201			distantsources(); /* else mark only distant sources */
202	greg	2.1	}
203
204	greg	2.25
205	greg	2.17	void
206	schorsch	2.9	ray_trace( /* trace a primary ray */
207			RAY *r
208			)
209	greg	2.1	{
210	greg	2.11	rayorigin(r, PRIMARY, NULL, NULL);
211	greg	2.16	samplendx++;
212	greg	2.1	rayvalue(r); /* assumes origin and direction are set */
213			}
214
215
216	greg	2.17	void
217	schorsch	2.9	ray_done( /* free ray-tracing data */
218			int freall
219			)
220	greg	2.1	{
221			retainfonts = 1;
222			ambdone();
223			ambnotify(OVOID);
224			freesources();
225			freeobjects(0, nobjects);
226			donesets();
227			octdone();
228			thescene.cutree = EMPTY;
229	greg	2.28	freeqstr(octname); octname = NULL;
230	greg	2.19	retainfonts = 0;
231	greg	2.1	if (freall) {
232			freefont(NULL);
233			freedata(NULL);
234	greg	2.19	SDfreeCache(NULL);
235	greg	2.1	initurand(0);
236			}
237			if (nobjects > 0) {
238	schorsch	2.9	sprintf(errmsg, "%ld objects left after call to ray_done()",
239	greg	2.18	(long)nobjects);
240	greg	2.1	error(WARNING, errmsg);
241			}
242	greg	2.21
243			ray_done_pmap();
244	greg	2.1	}
245
246
247	greg	2.17	void
248	schorsch	2.9	ray_save( /* save current parameter settings */
249			RAYPARAMS *rp
250			)
251	greg	2.1	{
252			int i, ndx;
253
254			if (rp == NULL)
255			return;
256			rp->do_irrad = do_irrad;
257	greg	2.24	rp->rand_samp = rand_samp;
258	greg	2.1	rp->dstrsrc = dstrsrc;
259			rp->shadthresh = shadthresh;
260			rp->shadcert = shadcert;
261			rp->directrelay = directrelay;
262			rp->vspretest = vspretest;
263			rp->directvis = directvis;
264			rp->srcsizerat = srcsizerat;
265			copycolor(rp->cextinction, cextinction);
266			copycolor(rp->salbedo, salbedo);
267			rp->seccg = seccg;
268			rp->ssampdist = ssampdist;
269			rp->specthresh = specthresh;
270			rp->specjitter = specjitter;
271			rp->backvis = backvis;
272			rp->maxdepth = maxdepth;
273			rp->minweight = minweight;
274			if (ambfile != NULL)
275			strncpy(rp->ambfile, ambfile, sizeof(rp->ambfile)-1);
276	greg	2.24	else
277			memset(rp->ambfile, '\0', sizeof(rp->ambfile));
278			copycolor(rp->ambval, ambval);
279	greg	2.1	rp->ambvwt = ambvwt;
280			rp->ambacc = ambacc;
281			rp->ambres = ambres;
282			rp->ambdiv = ambdiv;
283			rp->ambssamp = ambssamp;
284			rp->ambounce = ambounce;
285			rp->ambincl = ambincl;
286	schorsch	2.4	memset(rp->amblval, '\0', sizeof(rp->amblval));
287	greg	2.1	ndx = 0;
288			for (i = 0; i < AMBLLEN && amblist[i] != NULL; i++) {
289			int len = strlen(amblist[i]);
290			if (ndx+len >= sizeof(rp->amblval))
291			break;
292			strcpy(rp->amblval+ndx, amblist[i]);
293	greg	2.23	rp->amblndx[i] = ndx;
294	greg	2.1	ndx += len+1;
295			}
296			while (i <= AMBLLEN)
297			rp->amblndx[i++] = -1;
298	greg	2.21
299			/* PMAP: save photon mapping params */
300			ray_save_pmap(rp);
301	greg	2.1	}
302
303
304	greg	2.17	void
305	schorsch	2.9	ray_restore( /* restore parameter settings */
306			RAYPARAMS *rp
307			)
308	greg	2.1	{
309	greg	2.25	int i;
310	greg	2.1
311			if (rp == NULL) { /* restore defaults */
312			RAYPARAMS dflt;
313			ray_defaults(&dflt);
314			ray_restore(&dflt);
315			return;
316			}
317			/* restore saved settings */
318			do_irrad = rp->do_irrad;
319	greg	2.25	if (!rand_samp != !rp->rand_samp) {
320			rand_samp = rp->rand_samp;
321			reset_random();
322			}
323	greg	2.1	dstrsrc = rp->dstrsrc;
324			shadthresh = rp->shadthresh;
325			shadcert = rp->shadcert;
326			directrelay = rp->directrelay;
327			vspretest = rp->vspretest;
328			directvis = rp->directvis;
329			srcsizerat = rp->srcsizerat;
330			copycolor(cextinction, rp->cextinction);
331			copycolor(salbedo, rp->salbedo);
332			seccg = rp->seccg;
333			ssampdist = rp->ssampdist;
334			specthresh = rp->specthresh;
335			specjitter = rp->specjitter;
336			backvis = rp->backvis;
337			maxdepth = rp->maxdepth;
338			minweight = rp->minweight;
339			copycolor(ambval, rp->ambval);
340			ambvwt = rp->ambvwt;
341			ambdiv = rp->ambdiv;
342			ambssamp = rp->ambssamp;
343			ambounce = rp->ambounce;
344	greg	2.25	/* a bit dangerous if not static */
345	greg	2.1	for (i = 0; rp->amblndx[i] >= 0; i++)
346			amblist[i] = rp->amblval + rp->amblndx[i];
347			while (i <= AMBLLEN)
348			amblist[i++] = NULL;
349			ambincl = rp->ambincl;
350			/* update ambient calculation */
351			ambnotify(OVOID);
352	greg	2.29	if ((thescene.cutree != EMPTY) & !castonly) {
353	greg	2.1	int newamb = (ambfile == NULL) ? rp->ambfile[0] :
354			strcmp(ambfile, rp->ambfile) ;
355
356			if (amblist[0] != NULL)
357			for (i = 0; i < nobjects; i++)
358			ambnotify(i);
359
360			ambfile = (rp->ambfile[0]) ? rp->ambfile : (char *)NULL;
361			if (newamb) {
362			ambres = rp->ambres;
363			ambacc = rp->ambacc;
364			setambient();
365			} else {
366			setambres(rp->ambres);
367			setambacc(rp->ambacc);
368			}
369			} else {
370			ambfile = (rp->ambfile[0]) ? rp->ambfile : (char *)NULL;
371			ambres = rp->ambres;
372			ambacc = rp->ambacc;
373			}
374	greg	2.21
375			/* PMAP: restore photon mapping params */
376			ray_restore_pmap(rp);
377	greg	2.1	}
378
379
380	greg	2.17	void
381	schorsch	2.9	ray_defaults( /* get default parameter values */
382			RAYPARAMS *rp
383			)
384	greg	2.1	{
385			int i;
386
387			if (rp == NULL)
388			return;
389
390			rp->do_irrad = 0;
391	greg	2.24	rp->rand_samp = 1;
392	greg	2.1	rp->dstrsrc = 0.0;
393	greg	2.27	rp->shadthresh = 0.03;
394			rp->shadcert = 0.75;
395	greg	2.1	rp->directrelay = 2;
396			rp->vspretest = 512;
397			rp->directvis = 1;
398			rp->srcsizerat = .2;
399			setcolor(rp->cextinction, 0., 0., 0.);
400			setcolor(rp->salbedo, 0., 0., 0.);
401			rp->seccg = 0.;
402			rp->ssampdist = 0.;
403	greg	2.27	rp->specthresh = 0.15;
404	greg	2.1	rp->specjitter = 1.;
405			rp->backvis = 1;
406	greg	2.24	rp->maxdepth = -10;
407	greg	2.27	rp->minweight = 1e-4;
408	greg	2.24	memset(rp->ambfile, '\0', sizeof(rp->ambfile));
409	greg	2.1	setcolor(rp->ambval, 0., 0., 0.);
410			rp->ambvwt = 0;
411	greg	2.7	rp->ambres = 256;
412	greg	2.27	rp->ambacc = 0.1;
413	greg	2.7	rp->ambdiv = 1024;
414			rp->ambssamp = 512;
415	greg	2.1	rp->ambounce = 0;
416			rp->ambincl = -1;
417	schorsch	2.4	memset(rp->amblval, '\0', sizeof(rp->amblval));
418	greg	2.1	for (i = AMBLLEN+1; i--; )
419			rp->amblndx[i] = -1;
420	greg	2.22
421			/* PMAP: restore photon mapping defaults */
422			ray_defaults_pmap(rp);
423	greg	2.1	}