gfx/povray/povray.c

   1 /****************************************************************************
   2 *                povray.c
   3 *
   4 *  This module contains the entry routine for the raytracer and the code to
   5 *  parse the parameters on the command line.
   6 *
   7 *  from Persistence of Vision(tm) Ray Tracer
   8 *  Copyright 1996,1999 Persistence of Vision Team
   9 *---------------------------------------------------------------------------
  10 *  NOTICE: This source code file is provided so that users may experiment
  11 *  with enhancements to POV-Ray and to port the software to platforms other
  12 *  than those supported by the POV-Ray Team.  There are strict rules under
  13 *  which you are permitted to use this file.  The rules are in the file
  14 *  named POVLEGAL.DOC which should be distributed with this file.
  15 *  If POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  16 *  Team Coordinator by email to team-coord@povray.org or visit us on the web at
  17 *  http://www.povray.org. The latest version of POV-Ray may be found at this site.
  18 *
  19 * This program is based on the popular DKB raytracer version 2.12.
  20 * DKBTrace was originally written by David K. Buck.
  21 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  22 *
  23 *****************************************************************************/
  24
  25 #include <ctype.h>
  26 #include <time.h>     /* BP */
  27 #include "frame.h"    /* common to ALL modules in this program */
  28 #include "povproto.h"
  29 #include "bezier.h"
  30 #include "blob.h"
  31 #include "bbox.h"
  32 #include "cones.h"
  33 #include "csg.h"
  34 #include "discs.h"
  35 #include "express.h"
  36 #include "fractal.h"
  37 #include "hfield.h"
  38 #include "lathe.h"
  39 #include "lighting.h"
  40 #include "mem.h"
  41 #include "mesh.h"
  42 #include "polysolv.h"
  43 #include "objects.h"
  44 #include "octree.h"
  45 #include "parse.h"
  46 #include "pigment.h"
  47 #include "point.h"
  48 #include "poly.h"
  49 #include "polygon.h"
  50 #include "povray.h"
  51 #include "optin.h"
  52 #include "optout.h"
  53 #include "quadrics.h"
  54 #include "pgm.h"
  55 #include "png_pov.h"
  56 #include "ppm.h"
  57 #include "prism.h"
  58 #include "radiosit.h"
  59 #include "render.h"
  60 #include "sor.h"
  61 #include "spheres.h"
  62 #include "super.h"
  63 #include "targa.h"
  64 #include "texture.h"
  65 #include "tokenize.h"
  66 #include "torus.h"
  67 #include "triangle.h"
  68 #include "truetype.h"
  69 #include "userio.h"     /*Error,Warning,Init_Text_Streams*/
  70 #include "lbuffer.h"
  71 #include "vbuffer.h"
  72
  73
  74 /*****************************************************************************
  75 * Local preprocessor defines
  76 ******************************************************************************/
  77
  78 /* Flags for the variable store. */
  79
  80 #define STORE   1
  81 #define RESTORE 2
  82
  83
  84
  85 /*****************************************************************************
  86 * Local typedefs
  87 ******************************************************************************/
  88
  89
  90
  91 /*****************************************************************************
  92 * Local variables
  93 ******************************************************************************/
  94
  95 /* The frame. */
  96
  97 FRAME Frame;
  98
  99 /* Options and display stuff. */
 100
 101 char Color_Bits;
 102
 103 int Display_Started;
 104
 105 int Abort_Test_Every;
 106
 107 int Experimental_Flag;
 108
 109 /* Current stage of the program. */
 110
 111 int Stage;
 112
 113 /* Flag if -h option will show help screens. */
 114
 115 int Help_Available;
 116
 117 /* File and parsing stuff. */
 118
 119 Opts opts;
 120 COUNTER stats[MaxStat];
 121 COUNTER totalstats[MaxStat];
 122
 123 int Num_Echo_Lines;      /* May make user setable later - CEY*/
 124 int Echo_Line_Length;    /* May make user setable later - CEY*/
 125
 126 int Number_Of_Files;
 127
 128 FILE *stat_file;
 129 FILE_HANDLE *Output_File_Handle;
 130
 131 char Actual_Output_Name[FILE_NAME_LENGTH];
 132
 133 /* Timing stuff .*/
 134
 135 time_t tstart, tstop;
 136 DBL tparse, trender, tparse_total, trender_total;
 137
 138 /* Variable used by vector macros. */
 139
 140 DBL VTemp;
 141 volatile int Stop_Flag;
 142
 143 /* Flag if close_all() was already called. */
 144 static int closed_flag;
 145
 146 int pre_init_flag=0;
 147
 148 char *Option_String_Ptr;
 149 DBL Clock_Delta;
 150
 151 /*****************************************************************************
 152 * Static functions
 153 ******************************************************************************/
 154
 155 static void init_vars (void);
 156 static void destroy_libraries (void);
 157 static void fix_up_rendering_window (void);
 158 static void fix_up_animation_values (void);
 159 static void fix_up_scene_name (void);
 160 static void set_output_file_handle (void);
 161 static void setup_output_file_name (void);
 162 static void open_output_file (void);
 163 static void FrameRender (void);
 164 static void init_statistics (COUNTER *);
 165 static void sum_statistics (COUNTER *, COUNTER *);
 166 static void variable_store (int Flag);
 167 static int Has_Extension (char *name);
 168 static unsigned closest_power_of_2 (unsigned theNumber);
 169 static void init_shellouts (void);
 170 static void destroy_shellouts (void);
 171
 172
 173 /*****************************************************************************
 174 *
 175 * FUNCTION
 176 *
 177 *   main
 178 *
 179 * INPUT
 180 *
 181 * OUTPUT
 182 *
 183 * RETURNS
 184 *
 185 * AUTHOR
 186 *
 187 *   POV-Ray Team
 188 *
 189 * DESCRIPTION
 190 *
 191 *   -
 192 *
 193 * CHANGES
 194 *
 195 *   -
 196 *
 197 ******************************************************************************/
 198
 199
 200 #ifdef NOCMDLINE    /* a main() by any other name... */
 201 #ifdef ALTMAIN
 202   MAIN_RETURN_TYPE alt_main()
 203 #else
 204   MAIN_RETURN_TYPE main()
 205 #endif
 206 #else
 207 #ifdef ALTMAIN
 208   MAIN_RETURN_TYPE alt_main(int argc, char **argv)
 209 #else
 210   MAIN_RETURN_TYPE main(int argc, char **argv)
 211 #endif
 212 #endif            /* ...would be a lot less hassle!! :-) AAC */
 213 {
 214   register int i;
 215   int Diff_Frame;
 216   DBL Diff_Clock;
 217   SHELLRET Pre_Scene_Result, Frame_Result;
 218
 219   /* Attention all ALTMAIN people! See comments attached to this function*/
 220   pre_init_povray();
 221
 222   /* Startup povray. */
 223   Stage = STAGE_STARTUP;
 224   STARTUP_POVRAY
 225
 226   /* Print banner and credit info. */
 227   Stage = STAGE_BANNER;
 228   PRINT_CREDITS
 229   PRINT_OTHER_CREDITS
 230
 231 #ifndef NOCMDLINE
 232   /* Print help screens. */
 233
 234   if (argc == 1)
 235   {
 236     Print_Help_Screens();
 237   }
 238 #endif
 239
 240   /* Initialize variables. */
 241   init_vars();
 242
 243   Stage = STAGE_ENVIRONMENT;
 244
 245   READ_ENV_VAR
 246
 247   Stage = STAGE_INI_FILE;
 248
 249   /* Read parameters from POVRAY.INI */
 250   PROCESS_POVRAY_INI
 251
 252 #ifndef NOCMDLINE
 253   /* Parse the command line parameters */
 254
 255   Stage = STAGE_COMMAND_LINE;
 256
 257   Help_Available = (argc == 2);
 258
 259   for (i = 1 ; i < argc ; i++ )
 260   {
 261     parse_option_line(argv[i]);
 262   }
 263 #endif
 264
 265   /* Strip path and extension off input name to create scene name */
 266   fix_up_scene_name ();
 267
 268   /* Redirect text streams [SCD 2/95] */
 269   Open_Text_Streams();
 270
 271   /* Write .INI file [SCD 2/95] */
 272   Write_INI_File();
 273
 274   ALT_WRITE_INI_FILE
 275
 276   /* Make sure clock is okay, validate animation parameters */
 277   fix_up_animation_values();
 278
 279   /* Fix-up rendering window values if necessary. */
 280   fix_up_rendering_window();
 281
 282   /* Set output file handle for options screen. */
 283   set_output_file_handle();
 284
 285   /* Print options used. */
 286   Print_Options();
 287
 288   /* BEGIN SECTION */
 289   /* VARIOUS INITIALIZATION THAT ONLY NEEDS TO BE DONE 1/EXECUTION */
 290
 291   /* Set up noise-tables. */
 292   Initialize_Noise();
 293
 294   Diff_Clock = opts.FrameSeq.FinalClock - opts.FrameSeq.InitialClock;
 295
 296   if (opts.Options & CYCLIC_ANIMATION)
 297   {
 298     Diff_Frame = opts.FrameSeq.FinalFrame - opts.FrameSeq.InitialFrame + 1;
 299   }
 300   else
 301   {
 302     Diff_Frame = opts.FrameSeq.FinalFrame - opts.FrameSeq.InitialFrame;
 303   }
 304
 305   Clock_Delta = ((Diff_Frame==0)?0:Diff_Clock/Diff_Frame);
 306
 307   /* END SECTION */
 308
 309   /* Execute the first shell-out command */
 310   Pre_Scene_Result=(POV_SHELLOUT_CAST)POV_SHELLOUT(PRE_SCENE_SHL);
 311
 312   /* Loop over each frame */
 313
 314   if (Pre_Scene_Result != ALL_SKIP_RET)
 315   {
 316      if (Pre_Scene_Result != SKIP_ONCE_RET)
 317      {
 318        for (opts.FrameSeq.FrameNumber = opts.FrameSeq.InitialFrame,
 319             opts.FrameSeq.Clock_Value = opts.FrameSeq.InitialClock;
 320
 321             opts.FrameSeq.FrameNumber <= opts.FrameSeq.FinalFrame;
 322
 323             opts.FrameSeq.FrameNumber++,
 324             opts.FrameSeq.Clock_Value += Clock_Delta)
 325        {
 326          setup_output_file_name();
 327
 328          /* Execute a shell-out command before tracing */
 329
 330          Frame_Result=(POV_SHELLOUT_CAST)POV_SHELLOUT(PRE_FRAME_SHL);
 331
 332          if (Frame_Result == ALL_SKIP_RET)
 333          {
 334            break;
 335          }
 336
 337          if (Frame_Result != SKIP_ONCE_RET)
 338          {
 339            FrameRender();
 340
 341            /* Execute a shell-out command after tracing */
 342
 343            Frame_Result = (POV_SHELLOUT_CAST)POV_SHELLOUT(POST_FRAME_SHL);
 344
 345            if ((Frame_Result==SKIP_ONCE_RET) || (Frame_Result==ALL_SKIP_RET))
 346            {
 347              break;
 348            }
 349          }
 350        }
 351
 352        /* Print total stats ... */
 353
 354        if(opts.FrameSeq.FrameType==FT_MULTIPLE_FRAME)
 355        {
 356          Statistics("\nTotal Statistics");
 357
 358          opts.FrameSeq.FrameNumber--;
 359
 360          PRINT_STATS(totalstats);
 361
 362          opts.FrameSeq.FrameNumber++;
 363        }
 364      }
 365
 366      /* Execute the final shell-out command */
 367
 368      POV_SHELLOUT(POST_SCENE_SHL);
 369   }
 370
 371   /* And finish. */
 372
 373   Terminate_POV(0);
 374
 375   MAIN_RETURN_STATEMENT
 376 } /* main */
 377
 378
 379 /*****************************************************************************
 380 *
 381 * FUNCTION
 382 *
 383 *   FrameRender
 384 *
 385 * INPUT
 386 *
 387 * OUTPUT
 388 *
 389 * RETURNS
 390 *
 391 * AUTHOR
 392 *
 393 *   POV-Ray Team
 394 *
 395 * DESCRIPTION
 396 *
 397 *   Do all that is necessary for rendering a single frame, including parsing
 398 *
 399 * CHANGES
 400 *
 401 *   Feb 1996: Make sure we are displaying when doing a mosaic preview [AED]
 402 *
 403 ******************************************************************************/
 404
 405 static void FrameRender()
 406 {
 407   unsigned long hours, minutes;
 408   DBL seconds, t_total;
 409
 410   /* Store start time for parse. */
 411   START_TIME
 412
 413   /* Parse the scene file. */
 414   Status_Info("\n\nParsing...");
 415
 416   opts.Do_Stats=FALSE;
 417
 418   Init_Random_Generators();
 419
 420   Parse();
 421
 422   Destroy_Random_Generators();
 423
 424   opts.Do_Stats=TRUE;
 425
 426   if (opts.Options & RADIOSITY)
 427   {
 428      Experimental_Flag |= EF_RADIOS;
 429   }
 430
 431   if (Experimental_Flag)
 432   {
 433     Warning(0.0,"Warning: This rendering uses the following experimental features:\n");
 434     if (Experimental_Flag & EF_RADIOS)
 435     {
 436        Warning(0.0," radiosity");
 437     }
 438     Warning(0.0,".\nThe design and implementation of these features is likely to\n");
 439     Warning(0.0,"change in future versions of POV-Ray.  Full backward compatibility\n");
 440     Warning(0.0,"with the current implementation is NOT guaranteed.\n");
 441   }
 442
 443   Experimental_Flag=0;
 444
 445   /* Switch off standard anti-aliasing. */
 446
 447   if ((Frame.Camera->Aperture != 0.0) && (Frame.Camera->Blur_Samples > 0))
 448   {
 449     opts.Options &= ~ANTIALIAS;
 450
 451     Warning(0.0, "Focal blur is used. Standard antialiasing is switched off.\n");
 452   }
 453
 454   /* Create the bounding box hierarchy. */
 455
 456   Stage = STAGE_SLAB_BUILDING;
 457
 458   if (opts.Use_Slabs)
 459   {
 460     Status_Info("\nCreating bounding slabs.");
 461   }
 462
 463   /* Init module specific stuff. */
 464   Initialize_Atmosphere_Code();
 465   Initialize_BBox_Code();
 466   Initialize_Lighting_Code();
 467   Initialize_Mesh_Code();
 468   Initialize_VLBuffer_Code();
 469   Initialize_Radiosity_Code();
 470
 471   /* Always call this to print number of objects. */
 472   Build_Bounding_Slabs(&Root_Object);
 473
 474   /* Create the vista buffer. */
 475   Build_Vista_Buffer();
 476
 477   /* Create the light buffers. */
 478   Build_Light_Buffers();
 479
 480   /* Create blob queue. */
 481   Init_Blob_Queue();
 482
 483   /* Save variable values. */
 484   variable_store(STORE);
 485
 486   /* Open output file and if we are continuing an interrupted trace,
 487    * read in the previous file settings and any data there.  This has to
 488    * be done before any image-size related allocations, since the settings
 489    * in a resumed file take precedence over that specified by the user. [AED]
 490    */
 491   open_output_file();
 492
 493   /* Start the display. */
 494   if (opts.Options & DISPLAY)
 495   {
 496     Status_Info ("\nDisplaying...");
 497
 498     POV_DISPLAY_INIT(Frame.Screen_Width, Frame.Screen_Height);
 499
 500     Display_Started = TRUE;
 501
 502     /* Display vista tree. */
 503     Draw_Vista_Buffer();
 504   }
 505
 506   /* Get things ready for ray tracing (misc init, mem alloc) */
 507   Initialize_Renderer();
 508
 509   /* This had to be taken out of open_output_file() because we don't have
 510    * the final image size until the output file has been opened, so we can't
 511    * initialize the display until we know this, which in turn means we can't
 512    * read the rendered part before the display is initialized. [AED]
 513    */
 514   if ((opts.Options & DISKWRITE) && (opts.Options & CONTINUE_TRACE))
 515   {
 516     Read_Rendered_Part(Actual_Output_Name);
 517
 518     if (opts.Last_Line > Frame.Screen_Height)
 519       opts.Last_Line = Frame.Screen_Height;
 520
 521     if (opts.Last_Column > Frame.Screen_Width)
 522       opts.Last_Column = Frame.Screen_Width;
 523
 524   }
 525
 526   /* Get parsing time. */
 527   STOP_TIME
 528   tparse = TIME_ELAPSED
 529
 530   /* Get total parsing time. */
 531   tparse_total += tparse;
 532
 533   /* Store start time for trace. */
 534   START_TIME
 535
 536   if(opts.FrameSeq.FrameType==FT_MULTIPLE_FRAME)
 537   {
 538     t_total=tparse_total+trender_total;
 539     SPLIT_TIME(t_total,&hours,&minutes,&seconds);
 540     Render_Info("\n %02ld:%02ld:%02.0f so far, ",hours,minutes,seconds);
 541     Render_Info("Rendering frame %d, going to %d.",
 542         opts.FrameSeq.FrameNumber, opts.FrameSeq.FinalFrame);
 543   }
 544   /* Start tracing. */
 545   Stage = STAGE_RENDERING;
 546
 547   POV_PRE_RENDER
 548
 549   Status_Info ("\nRendering...\r");
 550
 551   /* Macro for setting up any special FP options */
 552   CONFIG_MATH
 553
 554   /* Ok, go for it - trace the picture. */
 555
 556   /* If radiosity preview has been done, we are continuing a trace, so it
 557    * is important NOT to do the preview, even if the user requests it, as it
 558    * will cause discontinuities in radiosity shading by (probably) calculating
 559    * a few more radiosity values.
 560    */
 561   if ( !opts.Radiosity_Preview_Done )
 562   {
 563     if ( opts.Options & RADIOSITY )
 564     {
 565       /* Note that radiosity REQUIRES a mosaic preview prior to main scan */
 566
 567       Start_Tracing_Mosaic_Smooth(opts.PreviewGridSize_Start, opts.PreviewGridSize_End);
 568     }
 569     else
 570     {
 571       if (opts.Options & PREVIEW && opts.Options & DISPLAY)
 572       {
 573         Start_Tracing_Mosaic_Preview(opts.PreviewGridSize_Start, opts.PreviewGridSize_End);
 574       }
 575     }
 576   }
 577
 578   switch (opts.Tracing_Method)
 579   {
 580     case 2 :
 581
 582       Start_Adaptive_Tracing();
 583
 584       break;
 585
 586     case 1 :
 587     default:
 588
 589       Start_Non_Adaptive_Tracing();
 590   }
 591
 592   /* We're done. */
 593
 594   /* Record time so well spent before file close so it can be in comments  */
 595   STOP_TIME
 596   trender = TIME_ELAPSED
 597
 598   /* Close out our file */
 599   if (Output_File_Handle)
 600   {
 601      Close_File(Output_File_Handle);
 602   }
 603
 604   Stage = STAGE_SHUTDOWN;
 605
 606   POV_PRE_SHUTDOWN
 607
 608   /* DESTROY lots of stuff */
 609   Deinitialize_Atmosphere_Code();
 610   Deinitialize_BBox_Code();
 611   Deinitialize_Lighting_Code();
 612   Deinitialize_Mesh_Code();
 613   Deinitialize_VLBuffer_Code();
 614   Deinitialize_Radiosity_Code();
 615   Destroy_Blob_Queue();
 616   Destroy_Light_Buffers();
 617   Destroy_Vista_Buffer();
 618   Destroy_Bounding_Slabs();
 619   Destroy_Frame();
 620   Terminate_Renderer();
 621   FreeFontInfo();
 622   Free_Iteration_Stack();
 623
 624   POV_POST_SHUTDOWN
 625
 626   /* Get total render time. */
 627   trender_total += trender;
 628
 629   POV_DISPLAY_FINISHED
 630
 631   if ((opts.Options & DISPLAY) && Display_Started)
 632   {
 633     POV_DISPLAY_CLOSE
 634
 635     Display_Started = FALSE;
 636   }
 637
 638   if (opts.histogram_on)
 639     write_histogram (opts.Histogram_File_Name) ;
 640
 641   Status_Info("\nDone Tracing");
 642
 643   /* Print stats ... */
 644   PRINT_STATS(stats);
 645
 646   if(opts.FrameSeq.FrameType==FT_MULTIPLE_FRAME)
 647   {
 648     /* Add them up */
 649     sum_statistics(totalstats, stats);
 650
 651     /* ... and then clear them for the next frame */
 652     init_statistics(stats);
 653   }
 654
 655   /* Restore variable values. */
 656   variable_store(RESTORE);
 657
 658 }
 659
 660
 661
 662 /*****************************************************************************
 663 *
 664 * FUNCTION
 665 *
 666 *   fix_up_rendering_window
 667 *
 668 * INPUT
 669 *
 670 * OUTPUT
 671 *
 672 * RETURNS
 673 *
 674 * AUTHOR
 675 *
 676 *   POV-Ray Team
 677 *
 678 * DESCRIPTION
 679 *
 680 *   Fix wrong window and mosaic preview values.
 681 *
 682 * CHANGES
 683 *
 684 *   -
 685 *
 686 ******************************************************************************/
 687
 688 static void fix_up_rendering_window()
 689 {
 690   int temp;
 691
 692   if (opts.First_Column_Percent > 0.0)
 693     opts.First_Column = (int) (Frame.Screen_Width * opts.First_Column_Percent);
 694
 695   if (opts.First_Line_Percent > 0.0)
 696     opts.First_Line = (int) (Frame.Screen_Height * opts.First_Line_Percent);
 697
 698   /* The decrements are a fudge factor that used to be in OPTIN.C
 699    * but it messed up Write_INI_File so its moved here.
 700    */
 701
 702   if (opts.First_Column <= 0)
 703     opts.First_Column = 0;
 704   else
 705     opts.First_Column--;
 706
 707   if (opts.First_Line <= 0)
 708     opts.First_Line = 0;
 709   else
 710     opts.First_Line--;
 711
 712   if ((opts.Last_Column == -1) && (opts.Last_Column_Percent <= 1.0))
 713     opts.Last_Column = (int) (Frame.Screen_Width * opts.Last_Column_Percent);
 714
 715   if ((opts.Last_Line == -1) && (opts.Last_Line_Percent <= 1.0))
 716     opts.Last_Line = (int) (Frame.Screen_Height * opts.Last_Line_Percent);
 717
 718   if (opts.Last_Line == -1)
 719     opts.Last_Line = Frame.Screen_Height;
 720
 721   if (opts.Last_Column == -1)
 722     opts.Last_Column = Frame.Screen_Width;
 723
 724   if (opts.Last_Column < 0 || opts.Last_Column > Frame.Screen_Width)
 725     opts.Last_Column = Frame.Screen_Width;
 726
 727   if (opts.Last_Line > Frame.Screen_Height)
 728     opts.Last_Line = Frame.Screen_Height;
 729
 730   /* Fix up Mosaic Preview values */
 731   opts.PreviewGridSize_Start=max(1,opts.PreviewGridSize_Start);
 732   opts.PreviewGridSize_End=max(1,opts.PreviewGridSize_End);
 733
 734   if ((temp=closest_power_of_2((unsigned)opts.PreviewGridSize_Start))!=opts.PreviewGridSize_Start)
 735   {
 736      Warning(0.0,"Preview_Start_Size must be a power of 2. Changing to %d.\n",temp);
 737      opts.PreviewGridSize_Start=temp;
 738   }
 739
 740   if ((temp=closest_power_of_2((unsigned)opts.PreviewGridSize_End))!=opts.PreviewGridSize_End)
 741   {
 742      Warning(0.0,"Preview_End_Size must be a power of 2. Changing to %d.\n",temp);
 743      opts.PreviewGridSize_End=temp;
 744   }
 745
 746   /* End must be less than or equal to start */
 747   if (opts.PreviewGridSize_End > opts.PreviewGridSize_Start)
 748     opts.PreviewGridSize_End = opts.PreviewGridSize_Start;
 749
 750   if (opts.PreviewGridSize_Start > 1)
 751   {
 752      opts.PreviewGridSize_End=max(opts.PreviewGridSize_End,2);
 753      opts.Options |= PREVIEW;
 754   }
 755   else
 756   {
 757      opts.Options &= ~PREVIEW;
 758   }
 759
 760   /* Set histogram size here so it is available for Print_Options, and
 761    * make sure that it has an integer number of pixels/bucket. */
 762   if (opts.histogram_on)
 763   {
 764     if (opts.histogram_x == 0 || opts.histogram_x > Frame.Screen_Width)
 765       opts.histogram_x = Frame.Screen_Width;
 766     else if (opts.histogram_x < Frame.Screen_Width)
 767       opts.histogram_x = Frame.Screen_Width / ((Frame.Screen_Width +
 768                          opts.histogram_x - 1) / opts.histogram_x);
 769
 770     if (opts.histogram_y == 0 || opts.histogram_y > Frame.Screen_Height)
 771       opts.histogram_y = Frame.Screen_Height;
 772     else if (opts.histogram_y < Frame.Screen_Height)
 773       opts.histogram_y = Frame.Screen_Height / ((Frame.Screen_Height +
 774                          opts.histogram_y - 1) /opts.histogram_y);
 775   }
 776 }
 777
 778 /*****************************************************************************
 779 *
 780 * FUNCTION
 781 *
 782 *   fix_up_animation_values
 783 *
 784 * INPUT
 785 *
 786 * OUTPUT
 787 *
 788 * RETURNS
 789 *
 790 * AUTHOR
 791 *
 792 *   POV-Ray Team
 793 *
 794 * DESCRIPTION
 795 *
 796 *   Validate animation parameters, compute subset values
 797 *
 798 * CHANGES
 799 *
 800 *   -
 801 *
 802 ******************************************************************************/
 803 static void fix_up_animation_values()
 804 {
 805   float ClockDiff;
 806   int FrameDiff;
 807   int FrameIncr;
 808   float ClockPerFrameIncr;
 809   int NumFrames;
 810
 811   if (opts.FrameSeq.FinalFrame != -1)
 812   {
 813     opts.FrameSeq.FrameType = FT_MULTIPLE_FRAME;
 814
 815     if (opts.FrameSeq.Clock_Value != 0.0)
 816     {
 817        Warning(0.0,"Attempted to set single clock value in multi frame\nanimation. Clock value overridden.\n");
 818     }
 819   }
 820   else
 821   {
 822     if (opts.FrameSeq.Clock_Value != 0.0)
 823     {
 824        opts.FrameSeq.FrameType = FT_SINGLE_FRAME;
 825     }
 826   }
 827
 828   if (opts.FrameSeq.FrameType == FT_SINGLE_FRAME)
 829   {
 830     /*
 831      * These are dummy values that will work for single_frame,
 832      * even in an animation loop.
 833      */
 834
 835     opts.FrameSeq.InitialFrame = 0;
 836     opts.FrameSeq.FinalFrame   = 0;
 837     opts.FrameSeq.InitialClock = opts.FrameSeq.Clock_Value;
 838     opts.FrameSeq.FinalClock   = 0.0;
 839   }
 840   else
 841   {
 842     /* FrameType==FT_MULTIPLE_FRAME */
 843
 844     if(opts.FrameSeq.InitialFrame == -1)
 845     {
 846       opts.FrameSeq.InitialFrame = 1;
 847     }
 848
 849     if (opts.FrameSeq.FinalFrame < opts.FrameSeq.InitialFrame)
 850     {
 851       Error("Final frame %d is less than Start Frame %d.\n",
 852             opts.FrameSeq.FinalFrame, opts.FrameSeq.InitialFrame);
 853     }
 854
 855     ClockDiff = opts.FrameSeq.FinalClock-opts.FrameSeq.InitialClock;
 856
 857     if (opts.Options & CYCLIC_ANIMATION)
 858     {
 859       FrameDiff = opts.FrameSeq.FinalFrame-opts.FrameSeq.InitialFrame+1;
 860     }
 861     else
 862     {
 863       FrameDiff = opts.FrameSeq.FinalFrame-opts.FrameSeq.InitialFrame;
 864     }
 865
 866     ClockPerFrameIncr = (FrameDiff == 0) ? 0 : (ClockDiff/FrameDiff);
 867
 868     /* Calculate width, which is an integer log10 */
 869
 870     NumFrames = opts.FrameSeq.FinalFrame;
 871
 872     opts.FrameSeq.FrameNumWidth = 1;
 873
 874     while (NumFrames >= 10)
 875     {
 876       opts.FrameSeq.FrameNumWidth++;
 877
 878       NumFrames = NumFrames / 10;
 879     }
 880
 881     if (opts.FrameSeq.FrameNumWidth > POV_NAME_MAX-1)
 882     {
 883       Error("Can't render %d frames requiring %d chars with %d width filename.\n",
 884           opts.FrameSeq.FinalFrame - opts.FrameSeq.InitialFrame + 1,
 885           opts.FrameSeq.FrameNumWidth, POV_NAME_MAX);
 886     }
 887
 888     /* STARTING FRAME SUBSET */
 889
 890     if (opts.FrameSeq.SubsetStartPercent != DBL_VALUE_UNSET)
 891     {
 892       FrameIncr = FrameDiff * opts.FrameSeq.SubsetStartPercent + 0.5; /* w/rounding */
 893
 894       opts.FrameSeq.SubsetStartFrame = opts.FrameSeq.InitialFrame + FrameIncr;
 895     }
 896
 897     if (opts.FrameSeq.SubsetStartFrame != INT_VALUE_UNSET)
 898     {
 899       NumFrames = opts.FrameSeq.SubsetStartFrame - opts.FrameSeq.InitialFrame;
 900
 901       opts.FrameSeq.InitialFrame = opts.FrameSeq.SubsetStartFrame;
 902       opts.FrameSeq.InitialClock = opts.FrameSeq.InitialClock + NumFrames * ClockPerFrameIncr;
 903     }
 904
 905     /* ENDING FRAME SUBSET */
 906
 907     if (opts.FrameSeq.SubsetEndPercent != DBL_VALUE_UNSET)
 908     {
 909       /*
 910        * By this time, we have possibly lost InitialFrame, so we calculate
 911        * it via FinalFrame-FrameDiff
 912        */
 913
 914       FrameIncr = FrameDiff * opts.FrameSeq.SubsetEndPercent + 0.5; /* w/rounding */
 915
 916       opts.FrameSeq.SubsetEndFrame = (opts.FrameSeq.FinalFrame - FrameDiff) + FrameIncr;
 917     }
 918
 919     if (opts.FrameSeq.SubsetEndFrame != INT_VALUE_UNSET)
 920     {
 921       NumFrames = opts.FrameSeq.FinalFrame - opts.FrameSeq.SubsetEndFrame;
 922
 923       opts.FrameSeq.FinalFrame = opts.FrameSeq.SubsetEndFrame;
 924       opts.FrameSeq.FinalClock = opts.FrameSeq.FinalClock - NumFrames * ClockPerFrameIncr;
 925     }
 926
 927     /*
 928      * Now that we have everything calculated, we check FinalFrame
 929      * and InitialFrame one more time, in case the subsets messed them up
 930      */
 931
 932     if (opts.FrameSeq.FinalFrame < opts.FrameSeq.InitialFrame)
 933     {
 934       Error("Final frame %d is less than Start Frame %d\ndue to bad subset specification.\n",
 935             opts.FrameSeq.FinalFrame, opts.FrameSeq.InitialFrame);
 936     }
 937   }
 938
 939   /* Needed for pre-render shellout fixup */
 940
 941   opts.FrameSeq.FrameNumber = opts.FrameSeq.InitialFrame;
 942   opts.FrameSeq.Clock_Value = opts.FrameSeq.InitialClock;
 943 }
 944
 945 /*****************************************************************************
 946 *
 947 * FUNCTION
 948 *
 949 *   fix_up_scene_name
 950 *
 951 * INPUT
 952 *
 953 * OUTPUT
 954 *
 955 * RETURNS
 956 *
 957 * AUTHOR
 958 *
 959 *   POV-Ray Team
 960 *
 961 * DESCRIPTION
 962 *
 963 *   Strip path and extention of input file to create scene name
 964 *
 965 * CHANGES
 966 *
 967 ******************************************************************************/
 968
 969 static void fix_up_scene_name()
 970 {
 971   int i, l;
 972   char temp[FILE_NAME_LENGTH];
 973
 974   if ((l=strlen(opts.Input_File_Name)-1)<1)
 975   {
 976      strcpy(opts.Scene_Name,opts.Input_File_Name);
 977      return;
 978   }
 979
 980   strcpy(temp,opts.Input_File_Name);
 981   for (i=l;i>0;i--)
 982   {
 983      if (temp[i]==FILENAME_SEPARATOR)
 984      {
 985         break;
 986      }
 987      if (temp[i]=='.')
 988      {
 989         temp[i]=0;
 990         break;
 991      }
 992   }
 993
 994   i=strlen(temp)-1;
 995
 996   while ((i>0) && (temp[i]!=FILENAME_SEPARATOR))
 997     i--;
 998   if (temp[i]==FILENAME_SEPARATOR)
 999     i++;
1000   strcpy(opts.Scene_Name,&(temp[i]));
1001 }
1002
1003 /*****************************************************************************
1004 *
1005 * FUNCTION
1006 *
1007 *   set_output_file_handle
1008 *
1009 * INPUT
1010 *
1011 * OUTPUT
1012 *
1013 * RETURNS
1014 *
1015 * AUTHOR
1016 *
1017 *   POV-Ray Team
1018 *
1019 * DESCRIPTION
1020 *
1021 *   Set the output file handle according to the file type used.
1022 *
1023 * CHANGES
1024 *
1025 * Oct 95 - Removed test where the output file handle was only set if
1026 *          output_to_file was TRUE. The output file handle structure
1027 *          contains a pointer to read line, which is used by the continue
1028 *          trace option. If you tried a continue trace with file output
1029 *          manually turned OFF, then a GPF would occur due to a call to a
1030 *          NULL function pointer.
1031 *
1032 ******************************************************************************/
1033
1034 static void set_output_file_handle()
1035 {
1036   char *def_ext = NULL;
1037   char temp[FILE_NAME_LENGTH];
1038
1039     switch (opts.OutputFormat)
1040     {
1041       case '\0':
1042       case 's' :
1043       case 'S' : Output_File_Handle = GET_SYS_FILE_HANDLE(); def_ext=SYS_DEF_EXT; break;
1044
1045       case 't' :
1046       case 'T' :
1047       case 'c' :
1048       case 'C' : Output_File_Handle = Get_Targa_File_Handle(); def_ext=".tga"; break;
1049
1050       case 'p' :
1051       case 'P' : Output_File_Handle = Get_PPM_File_Handle(); def_ext=".ppm"; break;
1052
1053       case 'n' :
1054       case 'N' : Output_File_Handle = Get_Png_File_Handle(); def_ext=".png"; break;
1055
1056       case 'd' :
1057       case 'D' : Error ("Dump format no longer supported.\n"); break;
1058       case 'r' :
1059       case 'R' : Error ("Raw format no longer supported.\n"); break;
1060
1061       default  : Error ("Unrecognized output file format %c.\n",
1062                         opts.OutputFormat);
1063     }
1064
1065     Output_File_Handle->file_type = IMAGE_FTYPE;
1066
1067     strcpy(temp,opts.Output_File_Name);
1068
1069     POV_SPLIT_PATH(temp,opts.Output_Path,opts.Output_File_Name);
1070
1071     if (opts.Output_File_Name[0] == '\0')
1072     {
1073       sprintf(opts.Output_File_Name, "%s%s",opts.Scene_Name,def_ext);
1074     }
1075     else if (!(opts.Options & TO_STDOUT))
1076     {
1077        if (!Has_Extension(opts.Output_File_Name))
1078        {
1079          strcat(opts.Output_File_Name, def_ext);
1080        }
1081     }
1082
1083     strcpy(opts.Output_Numbered_Name,opts.Output_File_Name);
1084 }
1085
1086 /*****************************************************************************
1087 *
1088 * FUNCTION
1089 *
1090 *   setup_output_file_name
1091 *
1092 * INPUT
1093 *
1094 * OUTPUT
1095 *
1096 * RETURNS
1097 *
1098 * AUTHOR
1099 *
1100 *   POV-Ray Team
1101 *
1102 * DESCRIPTION
1103 *
1104 *   Determine the file name for this frame.  For an animation, the frame
1105 *   number is inserted into the file name.
1106 *
1107 * CHANGES
1108 *
1109 *   Jan-97  [esp]  Added conditional after getcwd, because Metrowerks getcwd
1110 *                  function appends a path separator on output.
1111 *
1112 ******************************************************************************/
1113 static void setup_output_file_name()
1114 {
1115   char number_string[10];
1116   char separator_string[2] = {FILENAME_SEPARATOR, 0} ;
1117   char *plast_period;
1118   int available_characters;
1119   int ilast_period;
1120   int fname_chars;
1121
1122   /* This will create the real name for the file */
1123   if(opts.FrameSeq.FrameType!=FT_MULTIPLE_FRAME ||
1124      opts.Options & TO_STDOUT)
1125   {
1126     strcpy(opts.Output_Numbered_Name,opts.Output_File_Name);
1127   }
1128   else
1129   {
1130     /*
1131      * This is the maximum number of characters that can be used of the
1132      * original filename.  This will ensure that enough space is available
1133      * for the frame number in the filename
1134      */
1135
1136     available_characters = POV_NAME_MAX-opts.FrameSeq.FrameNumWidth;
1137
1138     plast_period = strrchr(opts.Output_File_Name, '.');
1139
1140     if (plast_period == NULL)
1141     {
1142       Error("Illegal file name %s -- no extension.\n", opts.Output_File_Name);
1143     }
1144
1145     ilast_period = plast_period - opts.Output_File_Name;
1146
1147     fname_chars = ilast_period;
1148
1149     if (fname_chars > available_characters)
1150     {
1151       /* Only give the warning once */
1152
1153       if (opts.FrameSeq.FrameNumber == opts.FrameSeq.InitialFrame)
1154       {
1155         Warning(0.0, "Need to cut the output filename by %d characters.\n",
1156                 ilast_period - available_characters);
1157       }
1158
1159       fname_chars = available_characters;
1160     }
1161
1162     /* Perform actual generation of filename */
1163
1164     strncpy(opts.Output_Numbered_Name, opts.Output_File_Name, (unsigned)fname_chars);
1165
1166     /* strncpy doesn't terminate if strlen(opts.Output_File_Name)<fname_chars */
1167
1168     opts.Output_Numbered_Name[fname_chars]='\0';
1169
1170     sprintf(number_string, "%0*d", opts.FrameSeq.FrameNumWidth, opts.FrameSeq.FrameNumber);
1171
1172     strcat(opts.Output_Numbered_Name, number_string);
1173
1174     strcat(opts.Output_Numbered_Name, &opts.Output_File_Name[ilast_period]);
1175   }
1176
1177   if (strlen (opts.Output_Path) == 0)
1178   {
1179     getcwd (opts.Output_Path, sizeof (opts.Output_Path) - 1) ;
1180     /* on some systems (MacOS) getcwd adds the path separator on the end */
1181     /* so only add it if it isn't already there...  [esp]                */
1182     if (opts.Output_Path[strlen(opts.Output_Path)-1] != FILENAME_SEPARATOR)
1183         strcat (opts.Output_Path, separator_string) ;
1184   }
1185   strncpy (Actual_Output_Name,opts.Output_Path, sizeof (Actual_Output_Name));
1186   strncat (Actual_Output_Name,opts.Output_Numbered_Name, sizeof (Actual_Output_Name));
1187 /*
1188 Debug_Info("P='%s',O='%s',A='%s',N='%s'\n",opts.Output_Path,
1189   opts.Output_Numbered_Name, Actual_Output_Name,opts.Output_Numbered_Name);
1190 */
1191 }
1192
1193
1194 /*****************************************************************************
1195 *
1196 * FUNCTION
1197 *
1198 *   open_output_file
1199 *
1200 * INPUT
1201 *
1202 * OUTPUT
1203 *
1204 * RETURNS
1205 *
1206 * AUTHOR
1207 *
1208 *   POV-Ray Team
1209 *
1210 * DESCRIPTION
1211 *
1212 *   Open file and read in previous image if continued trace is on.
1213 *
1214 *   GOTCHA : This saves a POINTER to the file name, so the file
1215 *            name must exist over the entire life/use of the file
1216 *
1217 * CHANGES
1218 *
1219 *   -
1220 *
1221 ******************************************************************************/
1222
1223 static void open_output_file()
1224 {
1225   int Buffer_Size;
1226
1227   if (opts.Options & DISKWRITE)
1228   {
1229     Stage = STAGE_FILE_INIT;
1230
1231     if (opts.Options & BUFFERED_OUTPUT)
1232     {
1233        Buffer_Size=opts.File_Buffer_Size;
1234     }
1235     else
1236     {
1237        Buffer_Size=0;
1238     }
1239
1240     if (opts.Options & CONTINUE_TRACE)
1241     {
1242       Stage = STAGE_CONTINUING;
1243
1244       if (Open_File(Output_File_Handle, Actual_Output_Name,
1245             &Frame.Screen_Width, &Frame.Screen_Height, Buffer_Size,
1246             READ_MODE) != 1)
1247       {
1248         Close_File(Output_File_Handle);
1249
1250         Warning (0.0,"Error opening continue trace output file.\n");
1251
1252         Warning (0.0,"Opening new output file %s.\n",Actual_Output_Name);
1253
1254         /* Turn off continue trace */
1255
1256         opts.Options &= ~CONTINUE_TRACE;
1257
1258         if (Open_File(Output_File_Handle, Actual_Output_Name,
1259               &Frame.Screen_Width, &Frame.Screen_Height, Buffer_Size,
1260               WRITE_MODE) != 1)
1261         {
1262           Error ("Error opening output file.");
1263         }
1264       }
1265     }
1266     else
1267     {
1268       if (Open_File(Output_File_Handle, Actual_Output_Name,
1269             &Frame.Screen_Width, &Frame.Screen_Height, Buffer_Size,
1270             WRITE_MODE) != 1)
1271       {
1272         Error ("Error opening output file.");
1273       }
1274     }
1275   }
1276 }
1277
1278
1279 /*****************************************************************************
1280 *
1281 * FUNCTION
1282 *
1283 *   init_vars
1284 *
1285 * INPUT
1286 *
1287 * OUTPUT
1288 *
1289 * RETURNS
1290 *
1291 * AUTHOR
1292 *
1293 *   POV-Ray Team
1294 *
1295 * DESCRIPTION
1296 *
1297 *   Initialize all global variables.
1298 *
1299 * CHANGES
1300 *
1301 *   -
1302 *
1303 ******************************************************************************/
1304
1305 static void init_vars()
1306 {
1307   Stage=STAGE_INIT;
1308   opts.Abort_Test_Counter = Abort_Test_Every ;
1309   Abort_Test_Every = 1;
1310   opts.AntialiasDepth = 3;
1311   opts.Antialias_Threshold = 0.3;
1312   opts.BBox_Threshold = 25;
1313   Color_Bits = 8;
1314   opts.DisplayFormat = '0';
1315   Display_Started = FALSE;
1316   opts.File_Buffer_Size = 0;
1317   opts.First_Column = 0;
1318   opts.First_Column_Percent = 0.0;
1319   opts.First_Line = 0;
1320   opts.First_Line_Percent = 0.0;
1321   Frame.Screen_Height = 100;
1322   Frame.Screen_Width  = 100;
1323   Root_Object = NULL;
1324   free_istack = NULL;
1325   opts.JitterScale = 1.0;
1326   opts.Language_Version = 3.1;
1327   opts.Last_Column = -1;
1328   opts.Last_Column_Percent = 1.0;
1329   opts.Last_Line = -1;
1330   opts.Last_Line_Percent = 1.0;
1331   opts.PreviewGridSize_Start = 1;
1332   opts.PreviewGridSize_End   = 1;
1333   opts.Library_Paths[0] = NULL;
1334   opts.Library_Path_Index = 0;
1335   Max_Intersections = 64; /*128*/
1336   Number_Of_Files = 0;
1337   Number_of_istacks = 0;
1338
1339   opts.Options = USE_VISTA_BUFFER + USE_LIGHT_BUFFER + JITTER +
1340                  DISKWRITE + REMOVE_BOUNDS;
1341   opts.OutputFormat = DEFAULT_OUTPUT_FORMAT;
1342   opts.OutputQuality = 8;
1343   Output_File_Handle = NULL;
1344   opts.Output_Numbered_Name[0]='\0';
1345   opts.Output_File_Name[0]='\0';
1346   opts.Output_Path[0]='\0';
1347   opts.PaletteOption = '3';
1348   opts.Quality = 9;
1349   opts.Quality_Flags = QUALITY_9;
1350   opts.DisplayGamma = DEFAULT_DISPLAY_GAMMA;
1351
1352   /*
1353    * If DisplayGamma == 2.2, then GammaFactor == .45, which is what we want.
1354    */
1355   opts.GammaFactor = DEFAULT_ASSUMED_GAMMA/opts.DisplayGamma;
1356
1357   opts.FrameSeq.FrameType = FT_SINGLE_FRAME;
1358   opts.FrameSeq.Clock_Value = 0.0;
1359   opts.FrameSeq.InitialFrame = 1;
1360   opts.FrameSeq.InitialClock = 0.0;
1361   opts.FrameSeq.FinalFrame = INT_VALUE_UNSET;
1362   opts.FrameSeq.FrameNumWidth = 0;
1363   opts.FrameSeq.FinalClock = 1.0;
1364   opts.FrameSeq.SubsetStartFrame = INT_VALUE_UNSET;
1365   opts.FrameSeq.SubsetStartPercent = DBL_VALUE_UNSET;
1366   opts.FrameSeq.SubsetEndFrame = INT_VALUE_UNSET;
1367   opts.FrameSeq.SubsetEndPercent = DBL_VALUE_UNSET;
1368   opts.FrameSeq.Field_Render_Flag = FALSE;
1369   opts.FrameSeq.Odd_Field_Flag = FALSE;
1370
1371   opts.Radiosity_Brightness = 3.3;
1372   opts.Radiosity_Count = 100;
1373   opts.Radiosity_Dist_Max = 0.;   /* default calculated in Radiosity_Initialize */
1374   opts.Radiosity_Error_Bound = .4;
1375   opts.Radiosity_Gray = .5;       /* degree to which gathered light is grayed */
1376   opts.Radiosity_Low_Error_Factor = .8;
1377   opts.Radiosity_Min_Reuse = .015;
1378   opts.Radiosity_Nearest_Count = 6;
1379   opts.Radiosity_Recursion_Limit = 1;
1380   opts.Radiosity_Quality = 6;     /* Q-flag value for light gathering */
1381   opts.Radiosity_File_ReadOnContinue = 1;
1382   opts.Radiosity_File_SaveWhileRendering = 1;
1383   opts.Radiosity_File_AlwaysReadAtStart = 0;
1384   opts.Radiosity_File_KeepOnAbort = 1;
1385   opts.Radiosity_File_KeepAlways = 0;
1386
1387
1388   init_statistics(stats);
1389   init_statistics(totalstats);
1390
1391   strcpy (opts.Input_File_Name, "OBJECT.POV");
1392   opts.Scene_Name[0]='\0';
1393   opts.Ini_Output_File_Name[0]='\0';
1394   opts.Use_Slabs=TRUE;
1395   Num_Echo_Lines = 5;   /* May make user setable later - CEY*/
1396   Echo_Line_Length = 180;   /* May make user setable later - CEY*/
1397
1398   closed_flag = FALSE;
1399   Stop_Flag = FALSE;
1400
1401   trender = trender_total = 0.0;
1402   tparse  = tparse_total  = 0.0;
1403
1404   histogram_grid = NULL ;
1405   opts.histogram_on = FALSE ;
1406   opts.histogram_type = NONE ;
1407   opts.Histogram_File_Name[0] = '\0';
1408   Histogram_File_Handle = NULL ;
1409   /*
1410    * Note that late initialization of the histogram_x and histogram_y
1411    * variables is done in fix_up_rendering_window, if they aren't specified
1412    * on the command line.  This is because they are based on the image
1413    * dimensions, and we can't be certain that we have this info at the
1414    * time we parse the histogram options in optin.c. [AED]
1415    */
1416   opts.histogram_x = opts.histogram_y = 0 ;
1417   max_histogram_value = 0 ;
1418
1419   opts.Tracing_Method = 1;
1420   Experimental_Flag = 0;
1421   Make_Pigment_Entries();
1422 }
1423
1424
1425 /*****************************************************************************
1426 *
1427 * FUNCTION
1428 *
1429 *   init_statistics
1430 *
1431 * INPUT
1432 *
1433 * OUTPUT
1434 *
1435 * RETURNS
1436 *
1437 * AUTHOR
1438 *
1439 *   POV-Ray Team
1440 *
1441 * DESCRIPTION
1442 *
1443 *   Initialize statistics to 0
1444 *
1445 * CHANGES
1446 *
1447 *   -
1448 *
1449 ******************************************************************************/
1450
1451 static void init_statistics(COUNTER *pstats)
1452 {
1453   int i;
1454
1455   for(i=0; i<MaxStat; i++)
1456     Init_Counter(pstats[i]);
1457 }
1458
1459 /*****************************************************************************
1460 *
1461 * FUNCTION
1462 *
1463 *   sum_statistics
1464 *
1465 * INPUT
1466 *
1467 * OUTPUT
1468 *
1469 * RETURNS
1470 *
1471 * AUTHOR
1472 *
1473 *   POV-Ray Team
1474 *
1475 * DESCRIPTION
1476 *
1477 *   Add current statistics to total statistics
1478 *
1479 * CHANGES
1480 *
1481 *   -
1482 *
1483 ******************************************************************************/
1484
1485 static void sum_statistics(COUNTER *ptotalstats, COUNTER *pstats)
1486 {
1487   int i;
1488   COUNTER tmp;
1489
1490   for(i=0; i<MaxStat; i++)
1491   {
1492     Add_Counter(tmp,pstats[i],ptotalstats[i]);
1493     ptotalstats[i]=tmp;
1494   }
1495 }
1496
1497
1498 /*****************************************************************************
1499 *
1500 * FUNCTION
1501 *
1502 *   variable_store
1503 *
1504 * INPUT
1505 *
1506 *   flag - flag telling wether to store or restore variables.
1507 *
1508 * OUTPUT
1509 *
1510 * RETURNS
1511 *
1512 * AUTHOR
1513 *
1514 *   Dieter Bayer
1515 *
1516 * DESCRIPTION
1517 *
1518 *   Store or restore variables whose value has to be the same for all
1519 *   frames of an animation and who are changed during every frame.
1520 *
1521 * CHANGES
1522 *
1523 *   May 1995 : Creation.
1524 *
1525 ******************************************************************************/
1526
1527 static void variable_store(int Flag)
1528 {
1529   static int STORE_First_Line;
1530
1531   switch (Flag)
1532   {
1533     case STORE:
1534
1535       STORE_First_Line = opts.First_Line;
1536
1537       break;
1538
1539     case RESTORE:
1540
1541       opts.First_Line = STORE_First_Line;
1542
1543       break;
1544
1545     default:
1546
1547       Error("Unknown flag in variable_store().\n");
1548   }
1549 }
1550
1551 /*****************************************************************************
1552 *
1553 * FUNCTION
1554 *
1555 *   destroy_libraries
1556 *
1557 * INPUT
1558 *
1559 * OUTPUT
1560 *
1561 * RETURNS
1562 *
1563 * AUTHOR
1564 *
1565 *   POV-Ray Team
1566 *
1567 * DESCRIPTION
1568 *
1569 *   Free library path memory.
1570 *
1571 * CHANGES
1572 *
1573 *   -
1574 *
1575 ******************************************************************************/
1576
1577 static void destroy_libraries()
1578 {
1579   int i;
1580
1581   for (i = 0; i < opts.Library_Path_Index; i++)
1582   {
1583     POV_FREE(opts.Library_Paths[i]);
1584
1585     opts.Library_Paths[i] = NULL;
1586   }
1587 }
1588
1589
1590
1591 /*****************************************************************************
1592 *
1593 * FUNCTION
1594 *
1595 *   close_all
1596 *
1597 * INPUT
1598 *
1599 * OUTPUT
1600 *
1601 * RETURNS
1602 *
1603 * AUTHOR
1604 *
1605 *   POV-Ray Team
1606 *
1607 * DESCRIPTION
1608 *
1609 *   Close all the stuff that has been opened and free all allocated memory.
1610 *
1611 * CHANGES
1612 *
1613 *   -
1614 *
1615 ******************************************************************************/
1616
1617 void close_all()
1618 {
1619   /* Only close things once */
1620
1621   if (closed_flag)
1622   {
1623     return;
1624   }
1625
1626   if (Output_File_Handle != NULL)
1627   {
1628     Close_File(Output_File_Handle);
1629
1630     POV_FREE(Output_File_Handle);
1631
1632     Output_File_Handle = NULL;
1633   }
1634
1635   destroy_shellouts();
1636   destroy_libraries();
1637   Destroy_Text_Streams();
1638   Free_Noise_Tables();
1639   Terminate_Renderer();
1640   Destroy_Bounding_Slabs();
1641   Destroy_Blob_Queue();
1642   Destroy_Vista_Buffer();
1643   Destroy_Light_Buffers();
1644   Destroy_Random_Generators();
1645   Deinitialize_Radiosity_Code();
1646   Free_Iteration_Stack();
1647   destroy_histogram();
1648   Deinitialize_Atmosphere_Code();
1649   Deinitialize_BBox_Code();
1650   Deinitialize_Lighting_Code();
1651   Deinitialize_Mesh_Code();
1652   Deinitialize_VLBuffer_Code();
1653   Destroy_Frame();
1654   Destroy_IStacks();
1655   FreeFontInfo();
1656
1657   if ((opts.Options & DISPLAY) && Display_Started)
1658   {
1659     POV_DISPLAY_CLOSE
1660   }
1661
1662   closed_flag = TRUE;
1663 }
1664
1665
1666
1667 /*****************************************************************************
1668 *
1669 * FUNCTION
1670 *
1671 *   POV_Std_Split_Time
1672 *
1673 * INPUT
1674 *
1675 * OUTPUT
1676 *
1677 * RETURNS
1678 *
1679 * AUTHOR
1680 *
1681 *   POV-Ray Team
1682 *
1683 * DESCRIPTION
1684 *
1685 *   Split time into hours, minutes and seconds.
1686 *
1687 * CHANGES
1688 *
1689 *   -
1690 *
1691 ******************************************************************************/
1692
1693 void POV_Std_Split_Time(DBL time_dif, unsigned long *hrs, unsigned long *mins, DBL *secs)
1694 {
1695   *hrs = (unsigned long)(time_dif / 3600.0);
1696
1697   *mins = (unsigned long)((time_dif - (DBL)(*hrs * 3600)) / 60.0);
1698
1699   *secs = time_dif - (DBL)(*hrs * 3600 + *mins * 60);
1700 }
1701
1702
1703
1704
1705 /*****************************************************************************
1706 *
1707 * FUNCTION
1708 *
1709 *   pov_stricmp
1710 *
1711 * INPUT
1712 *
1713 * OUTPUT
1714 *
1715 * RETURNS
1716 *
1717 * AUTHOR
1718 *
1719 *   POV-Ray Team
1720 *
1721 * DESCRIPTION
1722 *
1723 *   Since the stricmp function isn't available on all systems, we've
1724 *   provided a simplified version of it here.
1725 *
1726 * CHANGES
1727 *
1728 *   -
1729 *
1730 ******************************************************************************/
1731
1732 int pov_stricmp (char *s1, char  *s2)
1733 {
1734   char c1, c2;
1735
1736   while ((*s1 != '\0') && (*s2 != '\0'))
1737   {
1738     c1 = *s1++;
1739     c2 = *s2++;
1740
1741     c1 = (char)toupper(c1);
1742     c2 = (char)toupper(c2);
1743
1744     if (c1 < c2)
1745     {
1746       return(-1);
1747     }
1748
1749     if (c1 > c2)
1750     {
1751       return(1);
1752     }
1753   }
1754
1755   if (*s1 == '\0')
1756   {
1757     if (*s2 == '\0')
1758     {
1759       return(0);
1760     }
1761     else
1762     {
1763       return(-1);
1764     }
1765   }
1766   else
1767   {
1768     return(1);
1769   }
1770 }
1771
1772
1773 /*****************************************************************************
1774 *
1775 * FUNCTION
1776 *
1777 *   Locate_File
1778 *
1779 * INPUT
1780 *
1781 * OUTPUT
1782 *
1783 * RETURNS
1784 *
1785 * AUTHOR
1786 *
1787 *   POV-Ray Team
1788 *
1789 * DESCRIPTION
1790 *
1791 *   Find a file in the search path.
1792 *
1793 * CHANGES
1794 *
1795 *   Apr 1996: Don't add trailing FILENAME_SEPARATOR if we are immediately
1796 *             following DRIVE_SEPARATOR because of Amiga probs.  [AED]
1797 *
1798 ******************************************************************************/
1799
1800 FILE *Locate_File (char *filename, char  *mode, char  *ext1, char  *ext2, char  *buffer, int err_flag)
1801 {
1802   int i,l1,l2;
1803   char pathname[FILE_NAME_LENGTH];
1804   char file0[FILE_NAME_LENGTH];
1805   char file1[FILE_NAME_LENGTH];
1806   char file2[FILE_NAME_LENGTH];
1807   FILE *f;
1808
1809   if (Has_Extension(filename))
1810   {
1811      l1=l2=0;
1812   }
1813   else
1814   {
1815      if ((l1 = strlen(ext1)) > 0)
1816      {
1817         strcpy(file1, filename);
1818         strcat(file1, ext1);
1819      }
1820
1821      if ((l2 = strlen(ext2)) > 0)
1822      {
1823         strcpy(file2, filename);
1824         strcat(file2, ext2);
1825      }
1826   }
1827
1828   /* Check the current directory first. */
1829   if (l1)
1830   {
1831      if ((f = fopen(file1, mode)) != NULL)
1832      {
1833        POV_GET_FULL_PATH(f,file1,buffer);
1834        return(f);
1835      }
1836   }
1837   if (l2)
1838   {
1839      if ((f = fopen(file2, mode)) != NULL)
1840      {
1841        POV_GET_FULL_PATH(f,file2,buffer);
1842        return(f);
1843      }
1844   }
1845   if ((f = fopen(filename, mode)) != NULL)
1846   {
1847      POV_GET_FULL_PATH(f,filename,buffer);
1848      return(f);
1849   }
1850
1851   for (i = 0; i < opts.Library_Path_Index; i++)
1852   {
1853     strcpy(file0, opts.Library_Paths[i]);
1854     file0[strlen(file0)+1] = '\0';
1855     if (file0[strlen(file0) - 1] != DRIVE_SEPARATOR)
1856       file0[strlen(file0)] = FILENAME_SEPARATOR;
1857
1858     if (l1)
1859     {
1860        strcpy(pathname, file0);
1861        strcat(pathname, file1);
1862        if ((f = fopen(pathname, mode)) != NULL)
1863        {
1864           POV_GET_FULL_PATH(f,pathname,buffer);
1865           return(f);
1866        }
1867     }
1868
1869     if (l2)
1870     {
1871        strcpy(pathname, file0);
1872        strcat(pathname, file2);
1873        if ((f = fopen(pathname, mode)) != NULL)
1874        {
1875           POV_GET_FULL_PATH(f,pathname,buffer);
1876           return(f);
1877        }
1878     }
1879     strcpy(pathname, file0);
1880     strcat(pathname, filename);
1881     if ((f = fopen(pathname, mode)) != NULL)
1882     {
1883       POV_GET_FULL_PATH(f,pathname,buffer);
1884       return(f);
1885     }
1886   }
1887
1888   if (err_flag)
1889   {
1890     if (l1)
1891     {
1892       Error_Line("Could not find file '%s%s'\n",filename,ext1);
1893     }
1894     else
1895     {
1896       Error_Line("Could not find file '%s'\n",filename);
1897     }
1898   }
1899
1900   return(NULL);
1901 }
1902
1903 /*****************************************************************************
1904 *
1905 * FUNCTION
1906 *
1907 * INPUT
1908 *
1909 * OUTPUT
1910 *
1911 * RETURNS
1912 *
1913 * AUTHOR
1914 *
1915 * DESCRIPTION
1916 *
1917 * CHANGES
1918 *
1919 ******************************************************************************/
1920
1921 static int Has_Extension (char *name)
1922 {
1923    char *p;
1924
1925    if (name!=NULL)
1926    {
1927      p=strrchr(name, '.');
1928
1929      if (p!=NULL)
1930      {
1931         if ((strlen(name)-(p-name))<=4)
1932         {
1933            return (TRUE);
1934         }
1935      }
1936    }
1937    return (FALSE);
1938 }
1939
1940
1941 /*****************************************************************************
1942 *
1943 * FUNCTION
1944 *
1945 *   pov_shellout
1946 *
1947 * INPUT
1948 *
1949 *   template_command - the template command string to execute
1950 *
1951 * OUTPUT
1952 *
1953 * RETURNS
1954 *
1955 * AUTHOR
1956 *
1957 *   POV-Ray Team
1958 *
1959 * DESCRIPTION
1960 *
1961 *   Execute the command line described by the string being passed in
1962 *
1963 * CHANGES
1964 *
1965 *   -
1966 *
1967 ******************************************************************************/
1968
1969 SHELLRET pov_shellout (SHELLTYPE Type)
1970 {
1971   char real_command[POV_MAX_CMD_LENGTH];
1972   int i, j, l = 0;
1973   int length;
1974   SHELLRET Return_Code;
1975   char *s = NULL;
1976   char *template_command;
1977
1978
1979   if ( opts.Shellouts == NULL ) return(IGNORE_RET);
1980
1981   template_command=opts.Shellouts[Type].Command;
1982
1983   if ((length = strlen(template_command)) == 0)
1984   {
1985     return(IGNORE_RET);
1986   }
1987
1988   switch(Type)
1989   {
1990     case PRE_SCENE_SHL:  s="pre-scene";   break;
1991     case PRE_FRAME_SHL:  s="pre-frame";   break;
1992     case POST_FRAME_SHL: s="post-frame";  break;
1993     case POST_SCENE_SHL: s="post-scene";  break;
1994     case USER_ABORT_SHL: s="user about";  break;
1995     case FATAL_SHL:      s="fatal error"; break;
1996     case MAX_SHL: /* To remove warnings*/ break;
1997   }
1998
1999   Status_Info("\nPerforming %s shell-out command",s);
2000
2001   /* First, find the real command */
2002
2003   for (i = 0, j = 0; i < length; )
2004   {
2005     if (template_command[i] == '%')
2006     {
2007       switch (toupper(template_command[i+1]))
2008       {
2009          case 'O':
2010
2011           strncpy(&real_command[j], opts.Output_Numbered_Name,
2012                (unsigned)(l=strlen(opts.Output_Numbered_Name)));
2013
2014           break;
2015
2016          case 'P':
2017
2018           strncpy(&real_command[j], opts.Output_Path,(unsigned)(l=strlen(opts.Output_Path)));
2019
2020           break;
2021
2022          case 'S':
2023
2024           strncpy(&real_command[j], opts.Scene_Name, (unsigned)(l=strlen(opts.Scene_Name)));
2025
2026           break;
2027
2028          case 'N':
2029
2030           sprintf(&real_command[j],"%d",opts.FrameSeq.FrameNumber);
2031           l = strlen(&real_command[j]);
2032
2033           break;
2034
2035          case 'K':
2036
2037           sprintf(&real_command[j],"%f",opts.FrameSeq.Clock_Value);
2038           l = strlen(&real_command[j]);
2039
2040           break;
2041
2042          case 'H':
2043
2044           sprintf(&real_command[j],"%d",Frame.Screen_Height);
2045           l = strlen(&real_command[j]);
2046
2047           break;
2048
2049          case 'W':
2050
2051           sprintf(&real_command[j],"%d",Frame.Screen_Width);
2052           l = strlen(&real_command[j]);
2053
2054           break;
2055
2056          case '%':
2057
2058           real_command[j]='%';
2059
2060           l=1;
2061
2062           break;
2063        }
2064
2065        j+=l;
2066
2067        i+=2; /* we used 2 characters of template_command */
2068     }
2069     else
2070     {
2071       real_command[j++]=template_command[i++];
2072     }
2073   }
2074
2075   real_command[j]='\0';
2076
2077   Return_Code=(POV_SHELLOUT_CAST)POV_SYSTEM(real_command);
2078
2079   if (opts.Shellouts[Type].Inverse)
2080   {
2081     Return_Code=(POV_SHELLOUT_CAST)(!((int)Return_Code));
2082   }
2083
2084   if (Return_Code)
2085   {
2086     if (Type < USER_ABORT_SHL)
2087     {
2088       switch(opts.Shellouts[Type].Ret)
2089       {
2090         case FATAL_RET:
2091
2092           Error("Fatal error returned from shellout command.");
2093
2094           break;
2095
2096         case USER_RET:
2097
2098           Check_User_Abort(TRUE); /* the TRUE forces user abort */
2099
2100           break;
2101
2102         case QUIT_RET:
2103
2104           Terminate_POV(0);
2105
2106           break;
2107
2108         case IGNORE_RET:
2109         case SKIP_ONCE_RET:
2110         case ALL_SKIP_RET: /* Added to remove warnings */
2111           break;
2112       }
2113     }
2114
2115     return(opts.Shellouts[Type].Ret);
2116   }
2117
2118   return(IGNORE_RET);
2119 }
2120
2121 /*****************************************************************************
2122 *
2123 * FUNCTION
2124 *
2125 * INPUT
2126 *
2127 * OUTPUT
2128 *
2129 * RETURNS
2130 *
2131 * AUTHOR
2132 *
2133 * DESCRIPTION
2134 *
2135 * CHANGES
2136 *
2137 ******************************************************************************/
2138
2139 static void init_shellouts()
2140 {
2141   int i;
2142
2143   opts.Shellouts=(SHELLDATA *)POV_MALLOC(sizeof(SHELLDATA)*MAX_SHL,"shellout data");
2144
2145   for (i=0; i < MAX_SHL; i++)
2146   {
2147     opts.Shellouts[i].Ret=IGNORE_RET;
2148     opts.Shellouts[i].Inverse=FALSE;
2149     opts.Shellouts[i].Command[0]='\0';
2150   }
2151 }
2152
2153 /*****************************************************************************
2154 *
2155 * FUNCTION
2156 *
2157 * INPUT
2158 *
2159 * OUTPUT
2160 *
2161 * RETURNS
2162 *
2163 * AUTHOR
2164 *
2165 * DESCRIPTION
2166 *
2167 * CHANGES
2168 *
2169 ******************************************************************************/
2170
2171 static void destroy_shellouts()
2172 {
2173   if (opts.Shellouts != NULL)
2174   {
2175     POV_FREE(opts.Shellouts);
2176   }
2177
2178   opts.Shellouts=NULL;
2179 }
2180
2181
2182 /*****************************************************************************
2183 *
2184 * FUNCTION
2185 *
2186 *   closest_power_of_2
2187 *
2188 * INPUT
2189 *
2190 *   theNumber - the value to determine closest power of 2 for.
2191 *
2192 * OUTPUT
2193 *
2194 * RETURNS
2195 *
2196 *   The closest power of two is returned, or zero if the
2197 *   argument is less than or equal to zero.
2198 *
2199 * AUTHOR
2200 *
2201 *   Eduard Schwan
2202 *
2203 * DESCRIPTION
2204 *
2205 *   Decription: Find the highest positive power of 2 that is
2206 *   less than or equal to the number passed.
2207 *
2208 *   Input  Output
2209 *   -----  ------
2210 *     0      0
2211 *     1      1
2212 *     2      2
2213 *     3      2
2214 *     8      8
2215 *     9      8
2216 *
2217 * CHANGES
2218 *
2219 *   Aug 1994 : Created by Eduard.
2220 *
2221 ******************************************************************************/
2222
2223 static unsigned closest_power_of_2(unsigned theNumber)
2224 {
2225   int PowerOf2Counter;
2226
2227   /* do not handle zero or negative numbers for now */
2228
2229   if (theNumber <= 0)
2230   {
2231     return(0);
2232   }
2233
2234   /* count the number in question down as we count up a power of 2 */
2235
2236   PowerOf2Counter = 1;
2237
2238   while (theNumber > 1)
2239   {
2240     /* move our power of 2 counter bit up... */
2241
2242     PowerOf2Counter <<= 1;
2243
2244     /* and reduce our test number by a factor of 2 two */
2245
2246     theNumber >>= 1;
2247   }
2248
2249   return(PowerOf2Counter);
2250 }
2251
2252 /*****************************************************************************
2253 *
2254 * FUNCTION
2255 *
2256 *   pre_init_povray
2257 *
2258 * INPUT -- none
2259 *
2260 * OUTPUT
2261 *
2262 * RETURNS
2263 *
2264 * AUTHOR -- CEY
2265 *
2266 * DESCRIPTION
2267 *
2268 *   This routine does essential initialization that is required before any
2269 *   POV_MALLOC-like routines may be called and before any text streams
2270 *   may be used.
2271 *
2272 *   If you are using alt_main and need access to any part of the generic code
2273 *   before alt_main is called, you MUST call this routine first!  Also note
2274 *   that it is safe to call it twice.  If you don't call it, alt_main will.
2275 *   It won't hurt if you both do it.
2276 *
2277 *   NOTE: Terminate_POV de-initializes these features.  Therefore you may
2278 *   need to call it again between sucessive calls to alt_main.  If you call
2279 *   pre_init_povray but for some reason you abort and don't call alt_main,
2280 *   then you should call Terminate_POV to clean up.
2281 *
2282 * CHANGES
2283 *   Nov 1995 : Created by CEY
2284 *
2285 ******************************************************************************/
2286
2287 void pre_init_povray()
2288 {
2289   if (pre_init_flag==1234)
2290   {
2291     return;
2292   }
2293
2294   /* Initialize memory. */
2295   POV_MEM_INIT();
2296
2297   /* Initialize streams. In USERIO.C */
2298   Init_Text_Streams();
2299
2300   init_shellouts();
2301
2302   pre_init_tokenizer ();
2303
2304   pre_init_flag=1234;
2305 }
2306
2307 void POV_Split_Path(char *s,char *p,char *f)
2308 {
2309 char *l;
2310
2311   strcpy(p,s);
2312
2313   if ((l=strrchr(p,FILENAME_SEPARATOR))==NULL)
2314   {
2315      if ((l=strrchr(p,DRIVE_SEPARATOR))==NULL)
2316      {
2317         strcpy(f,s);
2318         p[0]='\0';
2319         return;
2320      }
2321   }
2322
2323   l++;
2324   strcpy(f,l);
2325   *l='\0';
2326
2327 }