ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/ranimove.c
(Generate patch)

Comparing ray/src/util/ranimove.c (file contents):
Revision 3.4 by schorsch, Thu Jun 26 00:58:11 2003 UTC vs.
Revision 3.16 by schorsch, Sun Mar 6 01:13:18 2016 UTC

# Line 1 | Line 1
1   #ifndef lint
2 < static const char RCSid[] = "$Id";
2 > static const char RCSid[] = "$Id$";
3   #endif
4   /*
5   *  Radiance object animation program
# Line 11 | Line 11 | static const char RCSid[] = "$Id";
11  
12   #include "copyright.h"
13  
14 – #include "ranimove.h"
14   #include <time.h>
15 < #ifndef _WIN32
15 > #if defined(_WIN32) || defined(_WIN64)
16 >  #include <winsock.h> /* struct timeval. XXX find a replacement? */
17 > #else
18    #include <sys/time.h>
19   #endif
20   #include <ctype.h>
21 + #include <string.h>
22  
23 + #include "platform.h"
24 + #include "paths.h"
25 + #include "ranimove.h"
26 +
27   int             NVARS = NV_INIT; /* total number of variables */
28  
29   VARIABLE        vv[] = VV_INIT; /* variable-value pairs */
# Line 57 | Line 63 | int            haveprio = 0;   /* high-level saliency specified */
63   int             gargc;          /* global argc for printargs */
64   char            **gargv;        /* global argv for printargs */
65  
66 + static void setdefaults(void);
67 + static void setmove(struct ObjMove      *om, char       *ms);
68 + static void setrendparams(char          *optf, char             *qval);
69 + static void getradfile(char     *rfargs);
70 + static void animate(void);
71 + static int countviews(void); /* XXX duplicated function */
72 + static char * getobjname(struct ObjMove *om);
73 + static char * getxf(struct ObjMove      *om, int        n);
74  
75 +
76   int
77 < main(argc, argv)
78 < int     argc;
79 < char    *argv[];
77 > main(
78 >        int     argc,
79 >        char    *argv[]
80 > )
81   {
82          int     explicate = 0;
83          char    *cfname;
# Line 94 | Line 110 | char   *argv[];
110                  case 'f':                       /* frame range */
111                          switch (sscanf(argv[++i], "%d,%d", &fbeg, &fend)) {
112                          case 2:
113 <                                if ((fbeg <= 0 | fend < fbeg))
113 >                                if ((fbeg <= 0) | (fend < fbeg))
114                                          goto userr;
115                                  break;
116                          case 1:
# Line 138 | Line 154 | char   *argv[];
154                                                  /* all done */
155          if (lorendoptf[0])
156                  unlink(lorendoptf);
157 <        if (hirendoptf[0])
157 >        if (hirendoptf[0] && strcmp(hirendoptf, lorendoptf))
158                  unlink(hirendoptf);
159          if (objtmpf[0])
160                  unlink(objtmpf);
# Line 148 | Line 164 | userr:
164   "Usage: %s [-n nprocs][-f beg,end][-t sec][-d jnd][-s][-w][-e] anim_file\n",
165                          progname);
166          quit(1);
167 +        return 1; /* pro forma return */
168   }
169  
170  
171   void
172 < eputs(s)                                /* put string to stderr */
173 < register char  *s;
172 > eputs(                          /* put string to stderr */
173 >        register char  *s
174 > )
175   {
176          static int  midline = 0;
177  
# Line 172 | Line 190 | register char  *s;
190  
191  
192   void
193 < setdefaults()                   /* set default values */
193 > quit(ec)                        /* make sure exit is called */
194 > int     ec;
195   {
196 +        if (ray_pnprocs > 0)    /* close children if any */
197 +                ray_pclose(0);          
198 +        exit(ec);
199 + }
200 +
201 +
202 + static void
203 + setdefaults(void)                       /* set default values */
204 + {
205          int     nviews;
206          int     decades;
207          char    buf[256];
# Line 244 | Line 272 | setdefaults()                  /* set default values */
272          setrendparams(lorendoptf, vval(LOWQ));
273          ray_save(&lorendparams);
274          curparams = &lorendparams;
275 <        twolevels = bcmp(&lorendparams, &hirendparams, sizeof(RAYPARAMS));
275 >        twolevels = memcmp(&lorendparams, &hirendparams, sizeof(RAYPARAMS));
276   }
277  
278  
279 < void
280 < setmove(om, ms)                 /* assign a move object from spec. */
281 < struct ObjMove  *om;
282 < char    *ms;
279 > static void
280 > setmove(                        /* assign a move object from spec. */
281 >        struct ObjMove  *om,
282 >        char    *ms
283 > )
284   {
285          char    parname[128];
286          char    *cp;
# Line 296 | Line 325 | char   *ms;
325                  if (isflt(om->prio_file)) {
326                          om->prio = atof(om->prio_file);
327                          om->prio_file[0] = '\0';
328 <                        haveprio |= (om->prio < 0.95 | om->prio > 1.05);
328 >                        haveprio |= ((om->prio < 0.95) | (om->prio > 1.05));
329                  } else
330                          haveprio = 1;
331          } else
# Line 308 | Line 337 | badspec:
337   }
338  
339  
340 < void
341 < setrendparams(optf, qval)       /* set global rendering parameters */
342 < char            *optf;
343 < char            *qval;
340 > static void
341 > setrendparams(  /* set global rendering parameters */
342 >        char            *optf,
343 >        char            *qval
344 > )
345   {
346          char    *argv[1024];
347          char    **av = argv;
# Line 331 | Line 361 | char           *qval;
361          if (qval != NULL && qval[0] == '-')
362                  ac += wordstring(av+ac, qval);
363  
364 <                                /* start with default parameters */
365 <        ray_defaults(NULL);
364 >                                /* restore default parameters */
365 >        ray_restore(NULL);
366                                  /* set what we have */
367          for (i = 0; i < ac; i++) {
368                  while ((rval = expandarg(&ac, &av, i)) > 0)
# Line 346 | Line 376 | char           *qval;
376                          continue;
377                  }
378                  rval = getrenderopt(ac-i, av+i);
379 <                if (rval >= 0) {
380 <                        i += rval;
381 <                        continue;
379 >                if (rval < 0) {
380 >                        sprintf(errmsg, "bad render option at '%s'", av[i]);
381 >                        error(USER, errmsg);
382                  }
383 <                sprintf(errmsg, "bad render option at '%s'", av[i]);
354 <                error(USER, errmsg);
383 >                i += rval;
384          }
385   }
386  
387  
388 < void
389 < getradfile(rfargs)              /* run rad and get needed variables */
390 < char    *rfargs;
388 > static void
389 > getradfile(             /* run rad and get needed variables */
390 >        char    *rfargs
391 > )
392   {
393          static short    mvar[] = {OCONV,OCTREEF,RESOLUTION,EXPOSURE,-1};
394          char    combuf[256];
395          register int    i;
396          register char   *cp;
397 <        char    *pippt;
397 >        char    *pippt = NULL;
398                                          /* create rad command */
399          strcpy(lorendoptf, "ranim0.opt");
400          sprintf(combuf,
# Line 385 | Line 415 | char   *rfargs;
415                          pippt = NULL;
416                  }
417          if (pippt != NULL)
418 <                strcpy(pippt, "> /dev/null");   /* nothing to match */
418 >                strcpy(pippt, "> " NULL_DEVICE);        /* nothing to match */
419          else {
420                  strcpy(cp, ")[ \t]*=' > ranimove.var");
421                  cp += 11;               /* point to file name */
# Line 407 | Line 437 | char   *rfargs;
437   }
438  
439  
440 < void
441 < animate()                       /* run through animation */
440 > static void
441 > animate(void)                   /* run through animation */
442   {
443          int     rpass;
444  
# Line 439 | Line 469 | animate()                      /* run through animation */
469   }
470  
471  
472 < VIEW *
473 < getview(n)                      /* get view number n */
474 < int     n;
472 > extern VIEW *
473 > getview(                        /* get view number n */
474 >        int     n
475 > )
476   {
477          static FILE     *viewfp = NULL;         /* view file pointer */
478          static int      viewnum = 0;            /* current view number */
# Line 453 | Line 484 | int    n;
484                          fclose(viewfp);
485                          viewfp = NULL;
486                          viewnum = 0;
487 <                        copystruct(&curview, &stdview);
487 >                        curview = stdview;
488                  }
489                  return(NULL);
490          }
# Line 469 | Line 500 | int    n;
500                          perror(vval(VIEWFILE));
501                          quit(1);
502                  }
503 <                copystruct(&curview, &stdview);
503 >                curview = stdview;
504                  viewnum = 0;
505          }
506          if (n < 0) {                            /* get next view */
# Line 489 | Line 520 | int    n;
520   }
521  
522  
523 < int
524 < countviews()                    /* count views in view file */
523 > static int
524 > countviews(void)                        /* count views in view file */
525   {
526          int     n;
527  
# Line 502 | Line 533 | countviews()                   /* count views in view file */
533   }
534  
535  
536 < char *
537 < getexp(n)                       /* get exposure for nth frame */
538 < int     n;
536 > extern char *
537 > getexp(                 /* get exposure for nth frame */
538 >        int     n
539 > )
540   {
541          extern char     *fskip();
542          static char     expval[32];
# Line 556 | Line 588 | formerr:
588          sprintf(errmsg, "%s: exposure format error on line %d",
589                          vval(EXPOSURE), curfrm);
590          error(USER, errmsg);
591 +        return NULL; /* pro forma return */
592   }
593  
594  
595 < double
596 < expspec_val(s)                  /* get exposure value from spec. */
597 < char    *s;
595 > extern double
596 > expspec_val(                    /* get exposure value from spec. */
597 >        char    *s
598 > )
599   {
600          double  expval;
601  
# Line 569 | Line 603 | char   *s;
603                  return(1.0);
604  
605          expval = atof(s);
606 <        if ((s[0] == '+' | s[0] == '-'))
606 >        if ((s[0] == '+') | (s[0] == '-'))
607                  return(pow(2.0, expval));
608          return(expval);
609   }
610  
611  
612 < char *
613 < getoctspec(n)                   /* get octree for the given frame */
614 < int     n;
612 > extern char *
613 > getoctspec(                     /* get octree for the given frame */
614 >        int     n
615 > )
616   {
617          static char     combuf[1024];
618 <        int             cfm = 0;
618 >        static int      cfm = 0;
619          int     uses_inline;
620          FILE    *fp;
621          int     i;
622                                          /* is octree static? */
623          if (!vdef(MOVE))
624                  return(vval(OCTREEF));
625 <                                        /* done already */
625 >                                        /* done already? */
626          if (n == cfm)
627                  return(combuf);
628                                          /* else create object file */
629 <        strcpy(objtmpf, "movinobj.rad");
595 <        fp = fopen(objtmpf, "w");
629 >        fp = fopen(mktemp(strcpy(objtmpf, TEMPLATE)), "w");
630          if (fp == NULL) {
631                  sprintf(errmsg, "cannot write to moving objects file '%s'",
632                                  objtmpf);
# Line 623 | Line 657 | int    n;
657                                  vdef(OCONV) ? vval(OCONV) : "",
658                                  vval(OCTREEF), objtmpf);
659          else
660 <                sprintf(combuf, "!xform -f %s | oconv -f -i '%s' -",
661 <                                objtmpf, vval(OCTREEF));
660 >                sprintf(combuf, "!xform -f %s | oconv %s -f -i '%s' -",
661 >                                objtmpf, vdef(OCONV) ? vval(OCONV) : "",
662 >                                vval(OCTREEF));
663          return(combuf);
664   }
665  
666  
667 < char *
668 < getobjname(om)                  /* get fully qualified object name */
669 < register struct ObjMove *om;
667 > static char *
668 > getobjname(                     /* get fully qualified object name */
669 >        register struct ObjMove *om
670 > )
671   {
672          static char     objName[512];
673          register char   *cp = objName;
# Line 647 | Line 683 | register struct ObjMove        *om;
683   }
684  
685  
686 < char *
687 < getxf(om, n)                    /* get total transform for object */
688 < register struct ObjMove *om;
689 < int     n;
686 > static char *
687 > getxf(                  /* get total transform for object */
688 >        register struct ObjMove *om,
689 >        int     n
690 > )
691   {
692          static char     xfsbuf[4096];
693          char            *xfp;
# Line 758 | Line 795 | int    n;
795                  om->cprio = om->prio;
796          }
797                                          /* XXX bxfm relies on call order */
798 <        if (framestep)
798 >        if (framestep) {
799                  if (invmat4(om->bxfm, om->cxfm))
800                          multmat4(om->bxfm, om->bxfm, oxf.xfm);
801                  else
802                          setident4(om->bxfm);
803 +        }
804                                          /* all done */
805          return(xfp);
806   }
807  
808  
809 < int
810 < getmove(obj)                            /* find matching move object */
811 < OBJECT  obj;
809 > extern int
810 > getmove(                                /* find matching move object */
811 >        OBJECT  obj
812 > )
813   {
814          static int      lasti;
815          static OBJECT   lasto = OVOID;
# Line 788 | Line 827 | OBJECT obj;
827                  objnm = obj_move[i].name;
828                  len = strlen(objnm);
829                  if (!strncmp(onm, objnm, len)) {
830 <                        if ((obj_move[i].parent < 0 & onm[len] == '.'))
830 >                        if ((obj_move[i].parent < 0) & (onm[len] == '.'))
831                                  break;
832                          objnm = getobjname(&obj_move[i]) + len;
833                          len2 = strlen(objnm);
# Line 801 | Line 840 | OBJECT obj;
840   }
841  
842  
843 < double
844 < obj_prio(obj)                   /* return priority for object */
845 < OBJECT  obj;
843 > extern double
844 > obj_prio(                       /* return priority for object */
845 >        OBJECT  obj
846 > )
847   {
848          int     moi;
849          
# Line 813 | Line 853 | OBJECT obj;
853   }
854  
855  
856 < double
857 < getTime()                       /* get current time (CPU or real) */
856 > #if defined(_WIN32) || defined(_WIN64)
857 >                                /* replacement function for Windoze */
858 > static int
859 > gettimeofday(struct timeval *tp, void *dummy)
860 > {
861 >    FILETIME        ft;
862 >    LARGE_INTEGER   li;
863 >    __int64         t;
864 >
865 >        SYSTEMTIME              st;
866 >        FILETIME                ft2;
867 >        LARGE_INTEGER   li2;
868 >        __int64                 t2;
869 >
870 >        st.wYear = 1970;
871 >        st.wHour = 0;
872 >        st.wMinute = 0;
873 >        st.wSecond = 0;
874 >        st.wMilliseconds = 1;
875 >
876 >        SystemTimeToFileTime(&st, &ft2);
877 >        li2.LowPart = ft2.dwLowDateTime;
878 >        li2.HighPart = ft2.dwHighDateTime;
879 >        t2 = li2.QuadPart;
880 >
881 >    GetSystemTimeAsFileTime(&ft);
882 >    li.LowPart  = ft.dwLowDateTime;
883 >    li.HighPart = ft.dwHighDateTime;
884 >    t  = li.QuadPart;      
885 >    t -= t2; // From 1970
886 >    t /= 10; // In microseconds
887 >    tp->tv_sec  = (long)(t / 1000000);
888 >    tp->tv_usec = (long)(t % 1000000);
889 >    return 0;
890 > }
891 >
892 > #endif
893 >
894 > extern double
895 > getTime(void)                   /* get current time (CPU or real) */
896   {
897          struct timeval  time_now;
898                                          /* return CPU time if one process */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines