home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Raytrace & Morphing / SOS-RAYTRACE.ISO / programm / source / rayce27s / spd.dif < prev    next >
Encoding:
Text File  |  1994-01-13  |  17.7 KB  |  588 lines
  1. *** old\showdxf.c    Tue Sep  7 16:48:38 1993
  2. --- showdxf.c    Sat Jan  8 18:27:40 1994
  3. ***************
  4. *** 235,240 ****
  5. --- 235,241 ----
  6.       fprintf(stderr, "    9   PLG format for use with rend386\n");
  7.       fprintf(stderr, "    10  Raw triangle output\n");
  8.       fprintf(stderr, "    11  art 2.3\n");
  9. +     fprintf(stderr, "    12  Rayce 2.7\n");
  10.   
  11.   #endif
  12.   } /* showdxf_usage */
  13. *** old\lib.h    Mon Sep  6 19:13:42 1993
  14. --- lib.h    Fri Jan  7 10:10:08 1994
  15. ***************
  16. *** 26,31 ****
  17. --- 26,36 ----
  18.    *           Eduard [esp] Schwan
  19.    *           Copied comments from lib.c into here for "documenting"
  20.    *           the calls a little better.
  21. +  *
  22. +  * Modified: 6 January 1994
  23. +  *           Shawn McHorse
  24. +  *           Added support for Rayce 2.7
  25. +  *
  26.    */
  27.   #ifndef LIB_H
  28.   #define LIB_H
  29. ***************
  30. *** 39,45 ****
  31.   
  32.   /* ------- The version of this Library, see lib_get_version_str() -------- */
  33.   
  34. ! #define LIB_VERSION    "3.1a"
  35.   
  36.   /* Raytracers supported by this package (default OUTPUT_POVRAY): */
  37.   
  38. --- 44,50 ----
  39.   
  40.   /* ------- The version of this Library, see lib_get_version_str() -------- */
  41.   
  42. ! #define LIB_VERSION    "3.1b"
  43.   
  44.   /* Raytracers supported by this package (default OUTPUT_POVRAY): */
  45.   
  46. ***************
  47. *** 58,64 ****
  48.   #define OUTPUT_PLG        9 /* PLG format for use with "rend386"           */
  49.   #define OUTPUT_RAWTRI    10 /* Raw triangle output                         */
  50.   #define OUTPUT_ART       11 /* Art 2.3                                     */
  51. ! #define OUTPUT_DELAYED   12 /* Needed for RTRACE/PLG output.
  52.                      When this is used, all definitions will be
  53.                      stored rather than immediately dumped.  When
  54.                      all definitions are complete, use the call
  55. --- 63,70 ----
  56.   #define OUTPUT_PLG        9 /* PLG format for use with "rend386"           */
  57.   #define OUTPUT_RAWTRI    10 /* Raw triangle output                         */
  58.   #define OUTPUT_ART       11 /* Art 2.3                                     */
  59. ! #define OUTPUT_RAYCE     12 /* Rayce 2.7                                   */
  60. ! #define OUTPUT_DELAYED   13 /* Needed for RTRACE/PLG output.
  61.                      When this is used, all definitions will be
  62.                      stored rather than immediately dumped.  When
  63.                      all definitions are complete, use the call
  64. ***************
  65. *** 65,71 ****
  66.                      "lib_flush_definitions" to spit them all out. */
  67.   
  68.   /* Default setting of output RT type - change to your favorite & recompile */
  69. ! #define OUTPUT_RT_DEFAULT   OUTPUT_NFF
  70.   
  71.   /* Sets raw triangle output format to include texture */
  72.   #define RAWTRI_WITH_TEXTURES    0    /* set to 1 to include texture */
  73. --- 71,77 ----
  74.                      "lib_flush_definitions" to spit them all out. */
  75.   
  76.   /* Default setting of output RT type - change to your favorite & recompile */
  77. ! #define OUTPUT_RT_DEFAULT   OUTPUT_RAYCE
  78.   
  79.   /* Sets raw triangle output format to include texture */
  80.   #define RAWTRI_WITH_TEXTURES    0    /* set to 1 to include texture */
  81. ***************
  82. *** 216,221 ****
  83. --- 222,228 ----
  84.    *    9   PLG format for use with "rend386"
  85.    *    10  Raw triangle output
  86.    *    11  art 2.3
  87. +  *    12  Rayce 2.7
  88.    * -c - output true curved descriptions
  89.    * -t - output tessellated triangle descriptions
  90.    * -f file - output filename (used for showdxf.c only)
  91. *** old\lib.c    Tue Sep  7 16:42:16 1993
  92. --- lib.c    Sun Jan  9 07:16:12 1994
  93. ***************
  94. *** 74,79 ****
  95. --- 74,84 ----
  96.    *           Eric Haines
  97.    *           Created standardized lib_open/lib_close functions
  98.    *           Renamed lib_initialize/lib_shutdown to lib_storage_*
  99. +  *
  100. +  * Modified: 6 January 1994
  101. +  *           Shawn McHorse
  102. +  *           Added support for Rayce 2.7
  103. +  *
  104.    */
  105.   
  106.   /*-----------------------------------------------------------------*/
  107. ***************
  108. *** 166,171 ****
  109. --- 171,177 ----
  110.       fprintf(stderr, "    9   PLG format for use with rend386\n");
  111.       fprintf(stderr, "    10  Raw triangle output\n");
  112.       fprintf(stderr, "    11  art 2.3\n");
  113. +     fprintf(stderr, "    12  Rayce 2.7\n");
  114.       fprintf(stderr, "-c - output true curved descriptions\n");
  115.       fprintf(stderr, "-t - output tessellated triangle descriptions\n");
  116.   
  117. ***************
  118. *** 191,196 ****
  119. --- 197,203 ----
  120.    *    9   PLG format for use with "rend386"
  121.    *    10  Raw triangle output
  122.    *    11  art 2.3
  123. +  *    12  Rayce 2.7
  124.    * -c - output true curved descriptions
  125.    * -t - output tessellated triangle descriptions
  126.    * -f file - DXF file to convert/display (used for showdxf.c only)
  127. ***************
  128. *** 694,699 ****
  129. --- 701,726 ----
  130.           fprintf(outfile, "\n");
  131.           break;
  132.   
  133. +     case OUTPUT_RAYCE:
  134. +         tab_indent();
  135. +         fprintf(outfile, "camera {\n");
  136. +         tab_inc();
  137. +         tab_indent();
  138. +         fprintf(outfile, "location <%g, %g, %g>\n",
  139. +             from[X], from[Y], from[Z]);
  140. +         tab_indent();
  141. +         fprintf(outfile, "look_at <%g, %g, %g>\n", at[X], at[Y], at[Z]);
  142. +         tab_indent();
  143. +         fprintf(outfile, "sky <%g, %g, %g>\n", up[X], up[Y], up[Z]);
  144. +         tab_indent();
  145. +         fprintf(outfile, "aspect %g\n", aspect_ratio);
  146. +         tab_indent();
  147. +         fprintf(outfile, "fov %g\n", fov_angle);
  148. +         tab_dec();
  149. +         tab_indent();
  150. +         fprintf(outfile, "} /* camera */\n\n");
  151. +         break;
  152. + 
  153.       case OUTPUT_RAWTRI:
  154.           break;
  155.       }
  156. ***************
  157. *** 834,839 ****
  158. --- 861,872 ----
  159.           fprintf(outfile, "\n");
  160.           break;
  161.   
  162. +     case OUTPUT_RAYCE:
  163. +         tab_indent();
  164. +         fprintf(outfile, "light_source { <%g, %g, %g> color rgb <%g, %g, %g> }\n\n",
  165. +             center_pt[X], center_pt[Y], center_pt[Z], lscale, lscale, lscale);
  166. +         break;
  167. + 
  168.       case OUTPUT_RAWTRI:
  169.           break;
  170.       }
  171. ***************
  172. *** 922,930 ****
  173.           fprintf(outfile, "0 0 0\n");
  174.           break;
  175.   
  176. -     case OUTPUT_RAWTRI:
  177. -         break;
  178. - 
  179.       case OUTPUT_ART:
  180.           tab_indent();
  181.           fprintf(outfile, "background %g, %g, %g\n",
  182. --- 955,960 ----
  183. ***************
  184. *** 931,936 ****
  185. --- 961,975 ----
  186.               color[X], color[Y], color[Z]);
  187.           fprintf(outfile, "\n");
  188.           break;
  189. + 
  190. +     case OUTPUT_RAYCE:
  191. +         tab_indent();
  192. +         fprintf(outfile, "options { background color rgb <%g, %g, %g> }\n\n",
  193. +             color[X], color[Y], color[Z]);
  194. +         break;
  195. + 
  196. +        case OUTPUT_RAWTRI:
  197. +         break;
  198.       }
  199.   }
  200.   
  201. ***************
  202. *** 1327,1332 ****
  203. --- 1366,1410 ----
  204.           fprintf(outfile, "transparency %f\n", kt);
  205.           fprintf(outfile, "\n");
  206.           break;
  207. + 
  208. +     case OUTPUT_RAYCE:
  209. +         txname = create_surface_name(name, texture_count);
  210. +         tab_indent();
  211. +         fprintf(outfile, "#declare %s = texture {\n", txname);
  212. +         tab_inc();
  213. +         if (ka != 0) {
  214. +         tab_indent();
  215. +         fprintf(outfile, "ambient color rgb <%g, %g, %g>\n",
  216. +             ka*color[X], ka*color[Y], ka*color[Z]);
  217. +         }
  218. +         if (kd != 0) {
  219. +         tab_indent();
  220. +         fprintf(outfile, "diffuse color rgb <%g, %g, %g>\n",
  221. +             kd*color[X], kd*color[Y], kd*color[Z]);
  222. +         }
  223. +         if (shine != 0) {
  224. +         tab_indent();
  225. +         if (shine > 1.0) shine = 1.0;
  226. +         fprintf(outfile, "specular color rgb <%g, %g, %g>\n",
  227. +             shine*color[X], shine*color[Y], shine*color[Z]);
  228. +         }
  229. +         if (ks != 0) {
  230. +         tab_indent();
  231. +         fprintf(outfile, "reflection color rgb <%g, %g, %g>\n",
  232. +             ks*color[X], ks*color[Y], ks*color[Z]);
  233. +         }
  234. +         if (kt != 0) {
  235. +         tab_indent();
  236. +         fprintf(outfile, "refraction color rgb <%g, %g, %g>\n",
  237. +             kt*color[X], kt*color[Y], kt*color[Z]);
  238. +         tab_indent();
  239. +         fprintf(outfile, "ior %g\n", i_of_r);
  240. +         }
  241. +         tab_dec();
  242. +         tab_indent();
  243. +         fprintf(outfile, "} /* texture %s */\n\n", txname);
  244. +         break;
  245. + 
  246.       }
  247.   
  248.       /* Stash away the current texture name */
  249. ***************
  250. *** 1680,1685 ****
  251. --- 1758,1838 ----
  252.           fprintf(outfile, "\n");
  253.           break;
  254.   
  255. +         case OUTPUT_RAYCE:
  256. +         if (apex_pt[W] < base_pt[W]) {
  257. +             /* Put the bigger end at the top */
  258. +             COPY_COORD4(axis, base_pt);
  259. +             COPY_COORD4(base_pt, apex_pt);
  260. +             COPY_COORD4(apex_pt, axis);
  261. +             }
  262. +         /* Find the axis and axis length */
  263. +         SUB3_COORD3(axis, apex_pt, base_pt);
  264. +         len = lib_normalize_vector(axis);
  265. +         if (len < EPSILON) {
  266. +            /* Degenerate cone/cylinder */
  267. +            fprintf(outfile, "/* degenerate cone/cylinder!  Ignored... */\n");
  268. +            break;
  269. +            }
  270. +         if (ABSOLUTE(apex_pt[W] - base_pt[W]) < EPSILON) {
  271. +            /* Treat this thing as a cylinder */
  272. +            tab_indent();
  273. +            fprintf(outfile, "object { cylinder { <%g, %g, %g>, <%g, %g, %g>, %g } ",
  274. +                 base_pt[X], base_pt[Y], base_pt[Z],
  275. +                 apex_pt[X], apex_pt[Y], apex_pt[Z], base_pt[W]);
  276. +            if (texture_name != NULL)
  277. +              fprintf(outfile, "texture { %s } ", texture_name);
  278. +            fprintf(outfile, "}\n\n");
  279. +         } else {
  280. +            /* Determine alignment */
  281. +            cottheta = len / (apex_pt[W] - base_pt[W]);
  282. +            tab_indent();
  283. +            fprintf(outfile, "object {\n");
  284. +            tab_inc();
  285. +            tab_indent();
  286. +            fprintf(outfile, "quadric{ <1, 1, -1>, <0, 0, 0>, <0, 0, 0>, 0 } /* cone */\n");
  287. +            if (texture_name != NULL) {
  288. +            tab_indent();
  289. +            fprintf(outfile, "texture { %s }\n", texture_name);
  290. +            }
  291. +            tab_indent();
  292. +            fprintf(outfile, "clipped_by {\n");
  293. +            tab_inc();
  294. +            tab_indent();
  295. +            fprintf(outfile, "intersection {\n");
  296. +            tab_inc();
  297. +            tab_indent();
  298. +            fprintf(outfile, "plane { <0, 0, -1>, %g}\n", -base_pt[W]);
  299. +            tab_indent();
  300. +            fprintf(outfile, "plane { <0, 0, 1>, %g}\n", apex_pt[W]);
  301. +            tab_dec();
  302. +            tab_indent();
  303. +            fprintf(outfile, "} /* intersection */\n");
  304. +            tab_dec();
  305. +            tab_indent();
  306. +            fprintf(outfile, "} /* clip */\n");
  307. +            tab_indent();
  308. +            fprintf(outfile, "translate <0, 0, %g>\n", -base_pt[W]);
  309. +               tab_indent();
  310. +            fprintf(outfile, "scale <1, 1, %g>\n", cottheta);
  311. +            len = sqrt(axis[X] * axis[X] + axis[Z] * axis[Z]);
  312. +            xang = -180.0 * asin(axis[Y]) / PI;
  313. +            if (len < EPSILON)
  314. +              yang = 0.0;
  315. +            else
  316. +              yang = 180.0 * acos(axis[Z] / len) / PI;
  317. +            if (axis[X] < 0)
  318. +                yang = -yang;
  319. +            tab_indent();
  320. +            fprintf(outfile, "rotate <%g, %g, 0>\n", xang, yang);
  321. +            tab_indent();
  322. +            fprintf(outfile, "translate <%g, %g, %g>\n",
  323. +                base_pt[X], base_pt[Y], base_pt[Z]);
  324. +            tab_dec();
  325. +            tab_indent();
  326. +            fprintf(outfile, "} /* cone */\n\n");
  327. +          }
  328. +         break;
  329. + 
  330.           case OUTPUT_RAWTRI:
  331.           lib_output_polygon_cylcone(base_pt, apex_pt);
  332.           break;
  333. ***************
  334. *** 1885,1890 ****
  335. --- 2038,2098 ----
  336.           apex[W] = oradius;
  337.           lib_output_cylcone(base, apex, curve_format);
  338.           break;
  339. + 
  340. +         case OUTPUT_RAYCE:
  341. +         /* A disc is a plane intersected with either one or two
  342. +          * spheres
  343. +          */
  344. +         COPY_COORD3(axis, normal);
  345. +         len = lib_normalize_vector(axis);
  346. +         tab_indent();
  347. +         fprintf(outfile, "object {\n");
  348. +         tab_inc();
  349. +         tab_indent();
  350. +         fprintf(outfile, "plane { <0, 0, 1>, 1 }\n");
  351. +         if (texture_name != NULL) {
  352. +         tab_indent();
  353. +         fprintf(outfile, "texture { %s }", texture_name);
  354. +         }
  355. +         tab_indent();
  356. +         fprintf(outfile, "clipped_by {\n");
  357. +         tab_inc();
  358. +         if (iradius > 0.0) {
  359. +             tab_indent();
  360. +             fprintf(outfile, "intersection {\n");
  361. +             tab_inc();
  362. +             tab_indent();
  363. +             fprintf(outfile, "sphere { <0, 0, 0>, %g inverse }\n",
  364. +                 iradius);
  365. +             tab_indent();
  366. +             fprintf(outfile, "sphere { <0, 0, 1>, %g }\n", oradius);
  367. +             tab_dec();
  368. +             tab_indent();
  369. +             fprintf(outfile, "} /* intersection */\n");
  370. +         }
  371. +         else {
  372. +             tab_indent();
  373. +             fprintf(outfile, "object { sphere { <0, 0, 0>, %g } }\n",
  374. +                 oradius);
  375. +         }
  376. +         tab_dec();
  377. +         tab_indent();
  378. +         fprintf(outfile, "} /* clip */\n");
  379. +         len = sqrt(axis[X] * axis[X] + axis[Z] * axis[Z]);
  380. +         xang = -180.0 * asin(axis[Y]) / PI;
  381. +         yang = 180.0 * acos(axis[Z] / len) / PI;
  382. +         if (axis[X] < 0)
  383. +             yang = -yang;
  384. +         tab_indent();
  385. +         fprintf(outfile, "rotate <%g, %g, 0>\n", xang, yang);
  386. +         tab_indent();
  387. +         fprintf(outfile, "translate <%g, %g, %g>\n",
  388. +             center[X], center[Y], center[Z]);
  389. +         tab_dec();
  390. +         tab_indent();
  391. +         fprintf(outfile, "} /* object - disc */\n\n");
  392. +         break;
  393. + 
  394.       }
  395.       } else {
  396.       lib_output_polygon_disc(center, normal, iradius, oradius);
  397. ***************
  398. *** 2258,2263 ****
  399. --- 2466,2480 ----
  400.           fprintf(outfile, "\n");
  401.           break;
  402.   
  403. +         case OUTPUT_RAYCE:
  404. +         tab_indent();
  405. +         fprintf(outfile, "object { sphere { <%g, %g, %g>, %g }",
  406. +             center_pt[X], center_pt[Y], center_pt[Z], center_pt[W]);
  407. +         if (texture_name != NULL)
  408. +             fprintf(outfile, " texture { %s }", texture_name);
  409. +         fprintf(outfile, " }\n\n");
  410. +         break;
  411. + 
  412.           case OUTPUT_RAWTRI:
  413.           lib_output_polygon_sphere(center_pt);
  414.           break;
  415. ***************
  416. *** 2415,2420 ****
  417. --- 2632,2638 ----
  418.           case OUTPUT_QRT:
  419.           case OUTPUT_RTRACE:
  420.           case OUTPUT_VIVID:
  421. +         case OUTPUT_RAYCE:
  422.           case OUTPUT_RAWTRI:
  423.           lib_output_polygon_height(height, width, data,
  424.                         x0, x1, y0, y1, z0, z1);
  425. ***************
  426. *** 2696,2701 ****
  427. --- 2914,2960 ----
  428.           fprintf(outfile, "}\n");
  429.           fprintf(outfile, "\n");
  430.           break;
  431. + 
  432. +         case OUTPUT_RAYCE:
  433. +         /*
  434. +          A torus object lies in the x-y plane.  We need to determine
  435. +          the angles of rotation to get it lined up with "normal".
  436. +          */
  437. +         tab_indent();
  438. +         fprintf(outfile, "object {\n");
  439. +         tab_inc();
  440. +         tab_indent();
  441. +         fprintf(outfile, "torus { %g, %g }\n", iradius, oradius);
  442. +         (void)lib_normalize_vector(normal);
  443. +         len = sqrt(normal[X] * normal[X] + normal[Y] * normal[Y]);
  444. +         xang = 180.0 * asin(normal[Z]) / PI + 90.0;
  445. +         if (len < EPSILON)
  446. +             zang = 0.0;
  447. +         else
  448. +             zang = -180.0 * acos(normal[Y] / len) / PI;
  449. +         if (normal[X] < 0)
  450. +             zang = -zang;
  451. +         if (ABSOLUTE(xang) > EPSILON || ABSOLUTE(zang) > EPSILON) {
  452. +             tab_indent();
  453. +             fprintf(outfile, "rotate <%g, 0, %g>\n", xang, zang);
  454. +         }
  455. +         if (ABSOLUTE(center[X]) > EPSILON ||
  456. +             ABSOLUTE(center[Y]) > EPSILON ||
  457. +             ABSOLUTE(center[Z]) > EPSILON) {
  458. +             tab_indent();
  459. +             fprintf(outfile, "translate <%g, %g, %g>\n",
  460. +                 center[X], center[Y], center[Z]);
  461. +         }
  462. +         if (texture_name != NULL) {
  463. +             tab_indent();
  464. +             fprintf(outfile, "texture { %s }", texture_name);
  465. +         }
  466. +         fprintf(outfile, "\n");
  467. +         tab_dec();
  468. +         tab_indent();
  469. +         fprintf(outfile, "} // torus\n");
  470. +         fprintf(outfile, "\n");
  471. +         break;
  472.       }
  473.       } else {
  474.       lib_output_polygon_torus(center, normal, iradius, oradius);
  475. ***************
  476. *** 2846,2851 ****
  477. --- 3105,3120 ----
  478.               (p1[Z] + p2[Z]) / 2.0,
  479.               p2[X] - p1[X], p2[Y] - p1[Y], p2[Z] - p1[Z]);
  480.           break;
  481. + 
  482. +         case OUTPUT_RAYCE:
  483. +         tab_indent();
  484. +         fprintf(outfile, "object { box { <%g, %g, %g>, <%g, %g, %g> }",
  485. +             p1[X], p1[Y], p1[Z], p2[X], p2[Y], p2[Z]);
  486. +         if (texture_name != NULL)
  487. +             fprintf(outfile, " texture { %s }", texture_name);
  488. +         fprintf(outfile, " }\n\n");
  489. +         break;
  490. + 
  491.           }
  492.       }
  493.   }
  494. ***************
  495. *** 3379,3384 ****
  496. --- 3648,3691 ----
  497.               fprintf(outfile, "\n");
  498.               break;
  499.   
  500. +         case OUTPUT_RAYCE:
  501. +             tab_indent();
  502. +             fprintf(outfile, "object {\n");
  503. +             tab_inc();
  504. +             tab_indent();
  505. +             if (norm == NULL)
  506. +             fprintf(outfile, "triangle {\n");
  507. +             else
  508. +             fprintf(outfile, "smooth_triangle {\n");
  509. +             tab_inc();
  510. +             for (i=0;i<3;++i) {
  511. +             tab_indent();
  512. +             fprintf(outfile, "<%g, %g, %g>",
  513. +                out_verts[t][i][X],
  514. +                out_verts[t][i][Y],
  515. +                out_verts[t][i][Z]);
  516. +             if (norm != NULL)
  517. +                fprintf(outfile, ", <%g, %g, %g>",
  518. +                   out_norms[t][i][X],
  519. +                   out_norms[t][i][Y],
  520. +                   out_norms[t][i][Z]);
  521. +             if (i < 2)
  522. +                fprintf(outfile, ",");
  523. +             fprintf(outfile, "\n");
  524. +             } /*for*/
  525. +             tab_dec();
  526. +             tab_indent();
  527. +             fprintf(outfile, "} /* smooth triangle */\n");
  528. +             if (texture_name != NULL) {
  529. +                tab_indent();
  530. +                fprintf(outfile, "texture { %s }\n", texture_name);
  531. +             }
  532. +             tab_dec();
  533. +             tab_indent();
  534. +             fprintf(outfile, "} /* object */\n\n");
  535. +             break;
  536. + 
  537. + 
  538.           case OUTPUT_RAWTRI:
  539.               for (i=0;i<3;++i) {
  540.               fprintf(outfile, "%-10.5g %-10.5g %-10.5g  ",
  541. ***************
  542. *** 3604,3609 ****
  543. --- 3911,3944 ----
  544.           fprintf(outfile, "\n");
  545.           break;
  546.   
  547. +         case OUTPUT_RAYCE:
  548. +         tab_indent();
  549. +         fprintf(outfile, "object {\n");
  550. +         tab_inc();
  551. +         tab_indent();
  552. +         fprintf(outfile, "polygon {\n");
  553. +         tab_inc();
  554. +         for (num_vert = 0; num_vert < tot_vert; num_vert++) {
  555. +             tab_indent();
  556. +             fprintf(outfile, " <%g, %g, %g>",
  557. +                  vert[num_vert][X],
  558. +                  vert[num_vert][Y],
  559. +                  vert[num_vert][Z]);
  560. +             if (num_vert < tot_vert-1)
  561. +                fprintf(outfile, ",");
  562. +             fprintf(outfile, "\n");
  563. +         }
  564. +         tab_dec();
  565. +         tab_indent();
  566. +         fprintf(outfile, "} /* polygon */\n");
  567. +         if (texture_name != NULL) {
  568. +             tab_indent();
  569. +             fprintf(outfile, "texture { %s }\n", texture_name);
  570. +         }
  571. +         tab_dec();
  572. +         tab_indent();
  573. +         fprintf(outfile, "}\n\n");
  574. +         break;
  575.        } /* switch */
  576.       } /* else !OUTPUT_DELAYED */
  577.   }
  578. ***************
  579. *** 3890,3895 ****
  580. --- 4225,4231 ----
  581.          case OUTPUT_POVRAY_20:
  582.          case OUTPUT_PLG:
  583.          case OUTPUT_RAWTRI:
  584. +        case OUTPUT_RAYCE:
  585.           lib_output_viewpoint(view.from, view.at, view.up, view.angle,
  586.               view.aspect, view.hither, view.resx, view.resy);
  587.   
  588.