src/rt/ambio.c

#ifndef lint
static const char       RCSid[] = "$Id: ambio.c,v 2.8 2014/05/07 01:16:03 greg Exp $";
#endif
/*
 * Read and write portable ambient values
 *
 *  Declarations of external symbols in ambient.h
 */

#include "copyright.h"

#include "ray.h"
#include "ambient.h"


#define  badflt(x)      ((x) < -FHUGE || (x) > FHUGE)

#define  badvec(v)      (badflt((v)[0]) | badflt((v)[1]) | badflt((v)[2]))


void
putambmagic(fp)                 /* write out ambient value magic number */
FILE  *fp;
{
        putint(AMBMAGIC, 2, fp);
}


int
hasambmagic(fp)                 /* read in and check validity of magic # */
FILE  *fp;
{
        int  magic;

        magic = getint(2, fp);
        if (feof(fp))
                return(0);
        return(magic == AMBMAGIC);
}


#ifndef OLDAMB

#define  putpos(v,fp)   putflt((v)[0],fp);putflt((v)[1],fp);putflt((v)[2],fp)

#define  getpos(v,fp)   (v)[0]=getflt(fp);(v)[1]=getflt(fp);(v)[2]=getflt(fp)

#define  putv2(v2,fp)   putflt((v2)[0],fp);putflt((v2)[1],fp)

#define  getv2(v2,fp)   (v2)[0]=getflt(fp);(v2)[1]=getflt(fp)

int
writambval(                     /* write ambient value to stream */
        AMBVAL  *av,
        FILE  *fp
)
{
        COLR  col;

        putint(av->lvl, 1, fp);
        putflt(av->weight, fp);
        putpos(av->pos, fp);
        putint(av->ndir, sizeof(av->ndir), fp);
        putint(av->udir, sizeof(av->udir), fp);
        setcolr(col, colval(av->val,RED),
                        colval(av->val,GRN), colval(av->val,BLU));
        fwrite((char *)col, sizeof(col), 1, fp);
        putv2(av->rad, fp);
        putv2(av->gpos, fp);
        putv2(av->gdir, fp);
        putint(av->corral, sizeof(av->corral), fp);
        return(ferror(fp) ? -1 : 0);
}


int
ambvalOK(                       /* check consistency of ambient value */
        AMBVAL  *av
)
{
        double  d;

        if (badvec(av->pos)) return(0);
        if (!av->ndir | !av->udir) return(0);
        if ((av->lvl < 0) | (av->lvl > 100)) return(0);
        if ((av->weight <= 0.) | (av->weight > 1.)) return(0);
        if ((av->rad[0] <= 0.) | (av->rad[0] >= FHUGE)) return(0);
        if ((av->rad[1] <= 0.) | (av->rad[1] >= FHUGE)) return(0);
        if ((colval(av->val,RED) < 0.) |
                        (colval(av->val,RED) > FHUGE) |
                        (colval(av->val,GRN) < 0.) |
                        (colval(av->val,GRN) > FHUGE) |
                        (colval(av->val,BLU) < 0.) |
                        (colval(av->val,BLU) > FHUGE)) return(0);
        if (badflt(av->gpos[0]) || badflt(av->gpos[1])) return(0);
        if (badflt(av->gdir[0]) || badflt(av->gdir[1])) return(0);
        return(1);
}


int
readambval(                     /* read ambient value from stream */
        AMBVAL  *av,
        FILE  *fp
)
{
        COLR  col;

        av->lvl = getint(1, fp);
        if (feof(fp))
                return(0);
        av->weight = getflt(fp);
        getpos(av->pos, fp);
        av->ndir = getint(sizeof(av->ndir), fp);
        av->udir = getint(sizeof(av->udir), fp);
        if (fread((char *)col, sizeof(col), 1, fp) != 1)
                return(0);
        colr_color(av->val, col);
        getv2(av->rad, fp);
        getv2(av->gpos, fp);
        getv2(av->gdir, fp);
        av->corral = (uint32)getint(sizeof(av->corral), fp);
        return(feof(fp) ? 0 : ambvalOK(av));
}


#else /* ! NEWAMB */


#define  putvec(v,fp)   putflt((v)[0],fp);putflt((v)[1],fp);putflt((v)[2],fp)

#define  getvec(v,fp)   (v)[0]=getflt(fp);(v)[1]=getflt(fp);(v)[2]=getflt(fp)


int
writambval(av, fp)              /* write ambient value to stream */
AMBVAL  *av;
FILE  *fp;
{
        COLR  col;

        putint(av->lvl, 1, fp);
        putflt(av->weight, fp);
        putvec(av->pos, fp);
        putvec(av->dir, fp);
        setcolr(col, colval(av->val,RED),
                        colval(av->val,GRN), colval(av->val,BLU));
        fwrite((char *)col, sizeof(col), 1, fp);
        putflt(av->rad, fp);
        putvec(av->gpos, fp);
        putvec(av->gdir, fp);
        return(ferror(fp) ? -1 : 0);
}


int
ambvalOK(av)                    /* check consistency of ambient value */
AMBVAL  *av;
{
        double  d;

        if (badvec(av->pos)) return(0);
        if (badvec(av->dir)) return(0);
        d = DOT(av->dir,av->dir);
        if (d < 0.9999 || d > 1.0001) return(0);
        if (av->lvl < 0 || av->lvl > 100) return(0);
        if (av->weight <= 0. || av->weight > 1.) return(0);
        if (av->rad <= 0. || av->rad >= FHUGE) return(0);
        if (colval(av->val,RED) < 0. ||
                        colval(av->val,RED) > FHUGE ||
                        colval(av->val,GRN) < 0. ||
                        colval(av->val,GRN) > FHUGE ||
                        colval(av->val,BLU) < 0. ||
                        colval(av->val,BLU) > FHUGE) return(0);
        if (badvec(av->gpos)) return(0);
        if (badvec(av->gdir)) return(0);
        return(1);
}


int
readambval(av, fp)              /* read ambient value from stream */
AMBVAL  *av;
FILE  *fp;
{
        COLR  col;

        av->lvl = getint(1, fp);
        if (feof(fp))
                return(0);
        av->weight = getflt(fp);
        getvec(av->pos, fp);
        getvec(av->dir, fp);
        if (fread((char *)col, sizeof(col), 1, fp) != 1)
                return(0);
        colr_color(av->val, col);
        av->rad = getflt(fp);
        getvec(av->gpos, fp);
        getvec(av->gdir, fp);
        return(feof(fp) ? 0 : ambvalOK(av));
}

#endif  /* ! NEWAMB */
Revision:	2.9
Committed:	Thu Jun 19 16:26:55 2014 UTC (9 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad4R2P2, rad5R0, rad4R2, rad4R2P1
Changes since 2.8:	+2 -2 lines
Log Message:	Officially replaced ambient calculation with new Hessian-based error control
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id: ambio.c,v 2.8 2014/05/07 01:16:03 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Read and write portable ambient values
6	greg	2.4	*
7			* Declarations of external symbols in ambient.h
8	greg	2.1	*/
9
10	greg	2.5	#include "copyright.h"
11	greg	2.1
12	greg	2.4	#include "ray.h"
13	greg	2.1	#include "ambient.h"
14
15
16	greg	2.3	#define badflt(x) ((x) < -FHUGE \|\| (x) > FHUGE)
17	greg	2.1
18	greg	2.6	#define badvec(v) (badflt((v)[0]) \| badflt((v)[1]) \| badflt((v)[2]))
19	greg	2.3
20	greg	2.1
21	greg	2.4	void
22	greg	2.2	putambmagic(fp) /* write out ambient value magic number */
23			FILE *fp;
24			{
25	greg	2.6	putint(AMBMAGIC, 2, fp);
26	greg	2.2	}
27
28
29	greg	2.4	int
30	greg	2.2	hasambmagic(fp) /* read in and check validity of magic # */
31			FILE *fp;
32			{
33	greg	2.6	int magic;
34	greg	2.2
35			magic = getint(2, fp);
36			if (feof(fp))
37			return(0);
38			return(magic == AMBMAGIC);
39			}
40
41
42	greg	2.9	#ifndef OLDAMB
43	greg	2.6
44			#define putpos(v,fp) putflt((v)[0],fp);putflt((v)[1],fp);putflt((v)[2],fp)
45
46			#define getpos(v,fp) (v)[0]=getflt(fp);(v)[1]=getflt(fp);(v)[2]=getflt(fp)
47
48			#define putv2(v2,fp) putflt((v2)[0],fp);putflt((v2)[1],fp)
49
50			#define getv2(v2,fp) (v2)[0]=getflt(fp);(v2)[1]=getflt(fp)
51
52			int
53			writambval( /* write ambient value to stream */
54			AMBVAL *av,
55			FILE *fp
56			)
57			{
58			COLR col;
59
60			putint(av->lvl, 1, fp);
61			putflt(av->weight, fp);
62			putpos(av->pos, fp);
63			putint(av->ndir, sizeof(av->ndir), fp);
64			putint(av->udir, sizeof(av->udir), fp);
65			setcolr(col, colval(av->val,RED),
66			colval(av->val,GRN), colval(av->val,BLU));
67			fwrite((char *)col, sizeof(col), 1, fp);
68			putv2(av->rad, fp);
69			putv2(av->gpos, fp);
70			putv2(av->gdir, fp);
71	greg	2.8	putint(av->corral, sizeof(av->corral), fp);
72	greg	2.6	return(ferror(fp) ? -1 : 0);
73			}
74
75
76			int
77			ambvalOK( /* check consistency of ambient value */
78			AMBVAL *av
79			)
80			{
81			double d;
82
83			if (badvec(av->pos)) return(0);
84			if (!av->ndir \| !av->udir) return(0);
85	greg	2.7	if ((av->lvl < 0) \| (av->lvl > 100)) return(0);
86			if ((av->weight <= 0.) \| (av->weight > 1.)) return(0);
87	greg	2.6	if ((av->rad[0] <= 0.) \| (av->rad[0] >= FHUGE)) return(0);
88			if ((av->rad[1] <= 0.) \| (av->rad[1] >= FHUGE)) return(0);
89	greg	2.7	if ((colval(av->val,RED) < 0.) \|
90			(colval(av->val,RED) > FHUGE) \|
91			(colval(av->val,GRN) < 0.) \|
92			(colval(av->val,GRN) > FHUGE) \|
93			(colval(av->val,BLU) < 0.) \|
94			(colval(av->val,BLU) > FHUGE)) return(0);
95	greg	2.6	if (badflt(av->gpos[0]) \|\| badflt(av->gpos[1])) return(0);
96			if (badflt(av->gdir[0]) \|\| badflt(av->gdir[1])) return(0);
97			return(1);
98			}
99
100
101			int
102			readambval( /* read ambient value from stream */
103			AMBVAL *av,
104			FILE *fp
105			)
106			{
107			COLR col;
108
109			av->lvl = getint(1, fp);
110			if (feof(fp))
111			return(0);
112			av->weight = getflt(fp);
113			getpos(av->pos, fp);
114			av->ndir = getint(sizeof(av->ndir), fp);
115			av->udir = getint(sizeof(av->udir), fp);
116			if (fread((char *)col, sizeof(col), 1, fp) != 1)
117			return(0);
118			colr_color(av->val, col);
119			getv2(av->rad, fp);
120			getv2(av->gpos, fp);
121			getv2(av->gdir, fp);
122	greg	2.8	av->corral = (uint32)getint(sizeof(av->corral), fp);
123	greg	2.6	return(feof(fp) ? 0 : ambvalOK(av));
124			}
125
126
127			#else /* ! NEWAMB */
128
129
130			#define putvec(v,fp) putflt((v)[0],fp);putflt((v)[1],fp);putflt((v)[2],fp)
131
132			#define getvec(v,fp) (v)[0]=getflt(fp);(v)[1]=getflt(fp);(v)[2]=getflt(fp)
133
134
135	greg	2.4	int
136	greg	2.1	writambval(av, fp) /* write ambient value to stream */
137	greg	2.6	AMBVAL *av;
138	greg	2.1	FILE *fp;
139			{
140			COLR col;
141
142	greg	2.6	putint(av->lvl, 1, fp);
143	greg	2.1	putflt(av->weight, fp);
144			putvec(av->pos, fp);
145			putvec(av->dir, fp);
146			setcolr(col, colval(av->val,RED),
147			colval(av->val,GRN), colval(av->val,BLU));
148			fwrite((char *)col, sizeof(col), 1, fp);
149			putflt(av->rad, fp);
150			putvec(av->gpos, fp);
151			putvec(av->gdir, fp);
152			return(ferror(fp) ? -1 : 0);
153			}
154
155
156	greg	2.3	int
157			ambvalOK(av) /* check consistency of ambient value */
158	greg	2.6	AMBVAL *av;
159	greg	2.3	{
160			double d;
161
162			if (badvec(av->pos)) return(0);
163			if (badvec(av->dir)) return(0);
164			d = DOT(av->dir,av->dir);
165			if (d < 0.9999 \|\| d > 1.0001) return(0);
166			if (av->lvl < 0 \|\| av->lvl > 100) return(0);
167			if (av->weight <= 0. \|\| av->weight > 1.) return(0);
168			if (av->rad <= 0. \|\| av->rad >= FHUGE) return(0);
169			if (colval(av->val,RED) < 0. \|\|
170			colval(av->val,RED) > FHUGE \|\|
171			colval(av->val,GRN) < 0. \|\|
172			colval(av->val,GRN) > FHUGE \|\|
173			colval(av->val,BLU) < 0. \|\|
174			colval(av->val,BLU) > FHUGE) return(0);
175			if (badvec(av->gpos)) return(0);
176			if (badvec(av->gdir)) return(0);
177			return(1);
178			}
179
180
181	greg	2.4	int
182	greg	2.1	readambval(av, fp) /* read ambient value from stream */
183	greg	2.6	AMBVAL *av;
184	greg	2.1	FILE *fp;
185			{
186			COLR col;
187
188			av->lvl = getint(1, fp);
189			if (feof(fp))
190			return(0);
191			av->weight = getflt(fp);
192			getvec(av->pos, fp);
193			getvec(av->dir, fp);
194			if (fread((char *)col, sizeof(col), 1, fp) != 1)
195			return(0);
196			colr_color(av->val, col);
197			av->rad = getflt(fp);
198			getvec(av->gpos, fp);
199			getvec(av->gdir, fp);
200	greg	2.3	return(feof(fp) ? 0 : ambvalOK(av));
201	greg	2.1	}
202	greg	2.6
203			#endif /* ! NEWAMB */