ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/nff2rad.c
Revision: 1.2
Committed: Tue Dec 11 09:28:27 1990 UTC (33 years, 7 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 1.1: +1 -1 lines
Log Message:
changed transmitting objects to always polished

File Contents

# Content
1 /* Copyright (c) 1990 Regents of the University of California */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ LBL";
5 #endif
6
7 /*
8 * Convert Neutral File Format input to Radiance scene description.
9 *
10 * 12/9/90 Greg Ward
11 */
12
13 /******************************************************************
14
15 Since Eric Haines wrote such excellent documentation of his
16 Neutral File Format, I am just going to reprint it here with
17 my added comments in braces {}.
18
19 Neutral File Format (NFF), by Eric Haines
20
21 Draft document #1, 10/3/88
22
23 The NFF (Neutral File Format) is designed as a minimal scene description
24 language. The language was designed in order to test various rendering
25 algorithms and efficiency schemes. It is meant to describe the geometry and
26 basic surface characteristics of objects, the placement of lights, and the
27 viewing frustum for the eye. Some additional information is provided for
28 esthetic reasons (such as the color of the objects, which is not strictly
29 necessary for testing rendering algorithms).
30
31 Future enhancements include: circle and torus objects, spline surfaces
32 with trimming curves, directional lights, characteristics for positional
33 lights, CSG descriptions, and probably more by the time you read this.
34 Comments, suggestions, and criticisms are all welcome.
35
36 At present the NFF file format is used in conjunction with the SPD (Standard
37 Procedural Database) software, a package designed to create a variety of
38 databases for testing rendering schemes. The SPD package is available
39 from Netlib and via ftp from drizzle.cs.uoregon.edu. For more information
40 about SPD see "A Proposal for Standard Graphics Environments," IEEE Computer
41 Graphics and Applications, vol. 7, no. 11, November 1987, pp. 3-5.
42
43 By providing a minimal interface, NFF is meant to act as a simple format to
44 allow the programmer to quickly write filters to move from NFF to the
45 local file format. Presently the following entities are supported:
46 A simple perspective frustum
47 A positional (vs. directional) light source description
48 A background color description
49 A surface properties description
50 Polygon, polygonal patch, cylinder/cone, and sphere descriptions
51
52 Files are output as lines of text. For each entity, the first line
53 defines its type. The rest of the first line and possibly other lines
54 contain further information about the entity. Entities include:
55
56 "v" - viewing vectors and angles { optionally creates view file }
57 "l" - positional light location { it's there, but bad to use }
58 "b" - background color { ditto }
59 "f" - object material properties { this is flakey }
60 "c" - cone or cylinder primitive
61 "s" - sphere primitive
62 "p" - polygon primitive
63 "pp" - polygonal patch primitive { interpreted same as p for now }
64
65 These are explained in depth below: { see conversion routines }
66
67 ***********************************************************************/
68
69 #include <stdio.h>
70
71 char *viewfile = NULL; /* view parameters file */
72
73 char *progname;
74
75
76 main(argc, argv) /* convert NFF file to Radiance */
77 int argc;
78 char *argv[];
79 {
80 int i;
81
82 progname = argv[0];
83 for (i = 1; i < argc; i++)
84 if (argc-i > 1 && !strcmp(argv[i], "-vf"))
85 viewfile = argv[++i];
86 else
87 break;
88 if (i-argc > 1)
89 goto userr;
90 if (i-argc == 1 && freopen(argv[i], "r", stdin) == NULL) {
91 perror(argv[i]);
92 exit(1);
93 }
94 init();
95 nff2rad();
96 exit(0);
97 userr:
98 fprintf(stderr, "Usage: %s [-vf viewfile] [input]\n", progname);
99 exit(1);
100 }
101
102
103 init() /* spit out initial definitions */
104 {
105 printf("# File created by %s\n", progname);
106 printf("\nvoid light light\n");
107 printf("0\n0\n3 1 1 1\n");
108 printf("\nvoid plastic fill\n");
109 printf("0\n0\n5 .5 .5 .5 0 0\n");
110 }
111
112
113 nff2rad() /* convert NFF on stdin to Radiance on stdout */
114 {
115 register int c;
116
117 while ((c = getchar()) != EOF)
118 switch (c) {
119 case ' ': /* white space */
120 case '\t':
121 case '\n':
122 case '\f':
123 case '\r':
124 continue;
125 case '#': /* comment */
126 comment();
127 break;
128 case 'v': /* view point */
129 view();
130 break;
131 case 'l': /* light source */
132 light();
133 break;
134 case 'b': /* background color */
135 background();
136 break;
137 case 'f': /* fill material */
138 fill();
139 break;
140 case 'c': /* cylinder or cone */
141 cone();
142 break;
143 case 's': /* sphere */
144 sphere();
145 break;
146 case 'p': /* polygon or patch */
147 poly();
148 break;
149 default: /* unknown */
150 fprintf(stderr, "%c: unknown NFF primitive\n", c);
151 exit(1);
152 }
153 }
154
155
156 /*******************************************
157
158 Comment. Description:
159 "#" [ string ]
160
161 Format:
162 # [ string ]
163
164 As soon as a "#" character is detected, the rest of the line is considered
165 a comment.
166
167 ******************/
168
169 comment()
170 {
171 register int c;
172
173 putchar('#');
174 while ((c = getchar()) != EOF) {
175 putchar(c);
176 if (c == '\n')
177 break;
178 }
179 }
180
181
182 /***************************************************
183
184 Viewpoint location. Description:
185 "v"
186 "from" Fx Fy Fz
187 "at" Ax Ay Az
188 "up" Ux Uy Uz
189 "angle" angle
190 "hither" hither
191 "resolution" xres yres
192
193 Format:
194
195 v
196 from %g %g %g
197 at %g %g %g
198 up %g %g %g
199 angle %g
200 hither %g
201 resolution %d %d
202
203 The parameters are:
204
205 From: the eye location in XYZ.
206 At: a position to be at the center of the image, in XYZ world
207 coordinates. A.k.a. "lookat".
208 Up: a vector defining which direction is up, as an XYZ vector.
209 Angle: in degrees, defined as from the center of top pixel row to
210 bottom pixel row and left column to right column.
211 Resolution: in pixels, in x and in y.
212
213 Note that no assumptions are made about normalizing the data (e.g. the
214 from-at distance does not have to be 1). Also, vectors are not
215 required to be perpendicular to each other.
216
217 For all databases some viewing parameters are always the same:
218 Yon is "at infinity."
219 Aspect ratio is 1.0.
220
221 A view entity must be defined before any objects are defined (this
222 requirement is so that NFF files can be used by hidden surface machines).
223
224 ***************/
225
226 view()
227 {
228 static FILE *fp = NULL;
229 float from[3], at[3], up[3], angle;
230
231 if (scanf(" from %f %f %f", &from[0], &from[1], &from[2]) != 3)
232 goto fmterr;
233 if (scanf(" at %f %f %f", &at[0], &at[1], &at[2]) != 3)
234 goto fmterr;
235 if (scanf(" up %f %f %f", &up[0], &up[1], &up[2]) != 3)
236 goto fmterr;
237 if (scanf(" angle %f", &angle) != 1)
238 goto fmterr;
239 scanf(" hither %*f");
240 scanf(" resolution %*d %*d");
241 if (viewfile != NULL) {
242 if (fp == NULL && (fp = fopen(viewfile, "a")) == NULL) {
243 perror(viewfile);
244 exit(1);
245 }
246 fprintf(fp,
247 "VIEW= -vp %g %g %g -vd %g %g %g -vu %g %g %g -vh %g -vv %g\n",
248 from[0], from[1], from[2],
249 at[0]-from[0], at[1]-from[1], at[2]-from[2],
250 up[0], up[1], up[2],
251 angle, angle);
252 }
253 return;
254 fmterr:
255 fprintf(stderr, "%s: view syntax error\n", progname);
256 exit(1);
257 }
258
259
260 /********************************
261
262 Positional light. A light is defined by XYZ position. Description:
263 "l" X Y Z
264
265 Format:
266 l %g %g %g
267
268 All light entities must be defined before any objects are defined (this
269 requirement is so that NFF files can be used by hidden surface machines).
270 Lights have a non-zero intensity of no particular value [this definition
271 may change soon, with the addition of an intensity and/or color].
272
273 **************************/
274
275 light()
276 {
277 static int nlights = 0;
278 register int c;
279 float x, y, z;
280
281 if (scanf("%f %f %f", &x, &y, &z) != 3) {
282 fprintf(stderr, "%s: light source syntax error\n", progname);
283 exit(1);
284 }
285 while ((c = getchar()) != EOF && c != '\n')
286 ;
287 printf("\nlight sphere l%d ", ++nlights);
288 printf("0\n0\n4 %g %g %g 1\n", x, y, z);
289 }
290
291
292 /**************************************************
293
294 Background color. A color is simply RGB with values between 0 and 1:
295 "b" R G B
296
297 Format:
298 b %g %g %g
299
300 If no background color is set, assume RGB = {0,0,0}.
301
302 ********************/
303
304 background()
305 {
306 float r, g, b;
307
308 if (scanf("%f %f %f", &r, &g, &b) != 3) {
309 fprintf(stderr, "%s: background syntax error\n", progname);
310 exit(1);
311 }
312 printf("\nvoid glow backg_color\n");
313 printf("0\n0\n4 %g %g %g 0\n", r, g, b);
314 printf("\nbackg_color source background\n");
315 printf("0\n0\n4 0 0 1 360\n");
316 }
317
318
319 /****************************************************
320
321 Fill color and shading parameters. Description:
322 "f" red green blue Kd Ks Shine T index_of_refraction
323
324 Format:
325 f %g %g %g %g %g %g %g %g
326
327 RGB is in terms of 0.0 to 1.0.
328
329 Kd is the diffuse component, Ks the specular, Shine is the Phong cosine
330 power for highlights, T is transmittance (fraction of light passed per
331 unit). Usually, 0 <= Kd <= 1 and 0 <= Ks <= 1, though it is not required
332 that Kd + Ks == 1. Note that transmitting objects ( T > 0 ) are considered
333 to have two sides for algorithms that need these (normally objects have
334 one side).
335
336 The fill color is used to color the objects following it until a new color
337 is assigned.
338
339 *********************/
340
341 fill()
342 {
343 float r, g, b, d, s, p, t, n;
344
345 if (scanf("%f %f %f %f %f %f %f %f", &r, &g, &b,
346 &d, &s, &p, &t, &n) != 8) {
347 fprintf(stderr, "%s: fill material syntax error\n", progname);
348 exit(1);
349 }
350 d /= 1.-s-t;
351 r *= d;
352 g *= d;
353 b *= d;
354 if (p > 1.)
355 p = 1./p;
356 if (t > .001) { /* has transmission */
357 printf("\nvoid trans fill\n");
358 printf("0\n0\n7 %g %g %g %g 0 %g 1\n", r, g, b, s, t);
359 } else { /* no transmission */
360 printf("\nvoid plastic fill\n");
361 printf("0\n0\n5 %g %g %g %g %g\n", r, g, b, s, p);
362 }
363 }
364
365
366 /*****************************************************
367
368 Cylinder or cone. A cylinder is defined as having a radius and an axis
369 defined by two points, which also define the top and bottom edge of the
370 cylinder. A cone is defined similarly, the difference being that the apex
371 and base radii are different. The apex radius is defined as being smaller
372 than the base radius. Note that the surface exists without endcaps. The
373 cone or cylinder description:
374
375 "c"
376 base.x base.y base.z base_radius
377 apex.x apex.y apex.z apex_radius
378
379 Format:
380 c
381 %g %g %g %g
382 %g %g %g %g
383
384 A negative value for both radii means that only the inside of the object is
385 visible (objects are normally considered one sided, with the outside
386 visible). Note that the base and apex cannot be coincident for a cylinder
387 or cone.
388
389 ************************/
390
391 cone()
392 {
393 static int ncs = 0;
394 int invert;
395 float x0, y0, z0, x1, y1, z1, r0, r1;
396
397 if (scanf("%f %f %f %f %f %f %f %f", &x0, &y0, &z0, &r0,
398 &x1, &y1, &z1, &r1) != 8) {
399 fprintf(stderr, "%s: cylinder or cone syntax error\n",
400 progname);
401 exit(1);
402 }
403 if (invert = r0 < 0.) {
404 r0 = -r0;
405 r1 = -r1;
406 }
407 if (r0-r1 < .001 && r1-r0 < .001) { /* cylinder */
408 printf("\nfill %s c%d ", invert?"tube":"cylinder", ++ncs);
409 printf("0\n0\n7\n");
410 printf("\t%g\t%g\t%g\n", x0, y0, z0);
411 printf("\t%g\t%g\t%g\n", x1, y1, z1);
412 printf("\t%g\n", r0);
413 } else { /* cone */
414 printf("\nfill %s c%d ", invert?"cup":"cone", ++ncs);
415 printf("0\n0\n8\n");
416 printf("\t%g\t%g\t%g\n", x0, y0, z0);
417 printf("\t%g\t%g\t%g\n", x1, y1, z1);
418 printf("\t%g\t%g\n", r0, r1);
419 }
420 }
421
422
423 /*****************************************
424
425 Sphere. A sphere is defined by a radius and center position:
426 "s" center.x center.y center.z radius
427
428 Format:
429 s %g %g %g %g
430
431 If the radius is negative, then only the sphere's inside is visible
432 (objects are normally considered one sided, with the outside visible).
433
434 ******************/
435
436 sphere()
437 {
438 static int nspheres = 0;
439 float x, y, z, r;
440
441 if (scanf("%f %f %f %f", &x, &y, &z, &r) != 4) {
442 fprintf(stderr, "%s: sphere syntax error\n", progname);
443 exit(1);
444 }
445 if (r < 0.) {
446 printf("\nfill bubble s%d ", ++nspheres);
447 printf("0\n0\n4 %g %g %g %g\n", x, y, z, -r);
448 } else {
449 printf("\nfill sphere s%d ", ++nspheres);
450 printf("0\n0\n4 %g %g %g %g\n", x, y, z, r);
451 }
452 }
453
454
455 /*********************************************
456
457 Polygon. A polygon is defined by a set of vertices. With these databases,
458 a polygon is defined to have all points coplanar. A polygon has only
459 one side, with the order of the vertices being counterclockwise as you
460 face the polygon (right-handed coordinate system). The first two edges
461 must form a non-zero convex angle, so that the normal and side visibility
462 can be determined. Description:
463
464 "p" total_vertices
465 vert1.x vert1.y vert1.z
466 [etc. for total_vertices vertices]
467
468 Format:
469 p %d
470 [ %g %g %g ] <-- for total_vertices vertices
471
472 --------
473
474 Polygonal patch. A patch is defined by a set of vertices and their normals.
475 With these databases, a patch is defined to have all points coplanar.
476 A patch has only one side, with the order of the vertices being
477 counterclockwise as you face the patch (right-handed coordinate system).
478 The first two edges must form a non-zero convex angle, so that the normal
479 and side visibility can be determined. Description:
480
481 "pp" total_vertices
482 vert1.x vert1.y vert1.z norm1.x norm1.y norm1.z
483 [etc. for total_vertices vertices]
484
485 Format:
486 pp %d
487 [ %g %g %g %g %g %g ] <-- for total_vertices vertices
488
489 *******************/
490
491 poly()
492 {
493 static int npolys = 0;
494 int ispatch;
495 int nverts;
496 float x, y, z;
497
498 ispatch = getchar();
499 if (ispatch != 'p') {
500 ungetc(ispatch, stdin);
501 ispatch = 0;
502 }
503 if (scanf("%d", &nverts) != 1)
504 goto fmterr;
505 printf("\nfill polygon p%d ", ++npolys);
506 printf("0\n0\n%d\n", 3*nverts);
507 while (nverts-- > 0) {
508 if (scanf("%f %f %f", &x, &y, &z) != 3)
509 goto fmterr;
510 if (ispatch)
511 scanf("%*f %*f %*f");
512 printf("\t%g\t%g\t%g\n", x, y, z);
513 }
514 return;
515 fmterr:
516 fprintf(stderr, "%s: polygon or patch syntax error\n", progname);
517 exit(1);
518 }