src/rt/ambio.c

#ifndef lint
static const char       RCSid[] = "$Id: ambio.c,v 2.5 2003/02/25 02:47:22 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);
}


#ifdef NEWAMB

#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);
        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);
        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.6
Committed:	Fri Apr 11 20:31:37 2014 UTC (10 years ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.5:	+101 -14 lines
Log Message:	Partial implementation of Hessian gradient calculation (-DNEWAMB)
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.6	static const char RCSid[] = "$Id: ambio.c,v 2.5 2003/02/25 02:47:22 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.6	#ifdef NEWAMB
43
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			return(ferror(fp) ? -1 : 0);
72			}
73
74
75			int
76			ambvalOK( /* check consistency of ambient value */
77			AMBVAL *av
78			)
79			{
80			double d;
81
82			if (badvec(av->pos)) return(0);
83			if (!av->ndir \| !av->udir) return(0);
84			if (av->lvl < 0 \|\| av->lvl > 100) return(0);
85			if (av->weight <= 0. \|\| av->weight > 1.) return(0);
86			if ((av->rad[0] <= 0.) \| (av->rad[0] >= FHUGE)) return(0);
87			if ((av->rad[1] <= 0.) \| (av->rad[1] >= FHUGE)) return(0);
88			if (colval(av->val,RED) < 0. \|\|
89			colval(av->val,RED) > FHUGE \|\|
90			colval(av->val,GRN) < 0. \|\|
91			colval(av->val,GRN) > FHUGE \|\|
92			colval(av->val,BLU) < 0. \|\|
93			colval(av->val,BLU) > FHUGE) return(0);
94			if (badflt(av->gpos[0]) \|\| badflt(av->gpos[1])) return(0);
95			if (badflt(av->gdir[0]) \|\| badflt(av->gdir[1])) return(0);
96			return(1);
97			}
98
99
100			int
101			readambval( /* read ambient value from stream */
102			AMBVAL *av,
103			FILE *fp
104			)
105			{
106			COLR col;
107
108			av->lvl = getint(1, fp);
109			if (feof(fp))
110			return(0);
111			av->weight = getflt(fp);
112			getpos(av->pos, fp);
113			av->ndir = getint(sizeof(av->ndir), fp);
114			av->udir = getint(sizeof(av->udir), fp);
115			if (fread((char *)col, sizeof(col), 1, fp) != 1)
116			return(0);
117			colr_color(av->val, col);
118			getv2(av->rad, fp);
119			getv2(av->gpos, fp);
120			getv2(av->gdir, fp);
121			return(feof(fp) ? 0 : ambvalOK(av));
122			}
123
124
125			#else /* ! NEWAMB */
126
127
128			#define putvec(v,fp) putflt((v)[0],fp);putflt((v)[1],fp);putflt((v)[2],fp)
129
130			#define getvec(v,fp) (v)[0]=getflt(fp);(v)[1]=getflt(fp);(v)[2]=getflt(fp)
131
132
133	greg	2.4	int
134	greg	2.1	writambval(av, fp) /* write ambient value to stream */
135	greg	2.6	AMBVAL *av;
136	greg	2.1	FILE *fp;
137			{
138			COLR col;
139
140	greg	2.6	putint(av->lvl, 1, fp);
141	greg	2.1	putflt(av->weight, fp);
142			putvec(av->pos, fp);
143			putvec(av->dir, fp);
144			setcolr(col, colval(av->val,RED),
145			colval(av->val,GRN), colval(av->val,BLU));
146			fwrite((char *)col, sizeof(col), 1, fp);
147			putflt(av->rad, fp);
148			putvec(av->gpos, fp);
149			putvec(av->gdir, fp);
150			return(ferror(fp) ? -1 : 0);
151			}
152
153
154	greg	2.3	int
155			ambvalOK(av) /* check consistency of ambient value */
156	greg	2.6	AMBVAL *av;
157	greg	2.3	{
158			double d;
159
160			if (badvec(av->pos)) return(0);
161			if (badvec(av->dir)) return(0);
162			d = DOT(av->dir,av->dir);
163			if (d < 0.9999 \|\| d > 1.0001) return(0);
164			if (av->lvl < 0 \|\| av->lvl > 100) return(0);
165			if (av->weight <= 0. \|\| av->weight > 1.) return(0);
166			if (av->rad <= 0. \|\| av->rad >= FHUGE) return(0);
167			if (colval(av->val,RED) < 0. \|\|
168			colval(av->val,RED) > FHUGE \|\|
169			colval(av->val,GRN) < 0. \|\|
170			colval(av->val,GRN) > FHUGE \|\|
171			colval(av->val,BLU) < 0. \|\|
172			colval(av->val,BLU) > FHUGE) return(0);
173			if (badvec(av->gpos)) return(0);
174			if (badvec(av->gdir)) return(0);
175			return(1);
176			}
177
178
179	greg	2.4	int
180	greg	2.1	readambval(av, fp) /* read ambient value from stream */
181	greg	2.6	AMBVAL *av;
182	greg	2.1	FILE *fp;
183			{
184			COLR col;
185
186			av->lvl = getint(1, fp);
187			if (feof(fp))
188			return(0);
189			av->weight = getflt(fp);
190			getvec(av->pos, fp);
191			getvec(av->dir, fp);
192			if (fread((char *)col, sizeof(col), 1, fp) != 1)
193			return(0);
194			colr_color(av->val, col);
195			av->rad = getflt(fp);
196			getvec(av->gpos, fp);
197			getvec(av->gdir, fp);
198	greg	2.3	return(feof(fp) ? 0 : ambvalOK(av));
199	greg	2.1	}
200	greg	2.6
201			#endif /* ! NEWAMB */