ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/util/ranimove.c

Comparing ray/src/util/ranimove.c (file contents):
Revision 3.5 by schorsch, Mon Jun 30 14:59:13 2003 UTC vs.
Revision 3.20 by greg, Mon Feb 6 22:40:21 2023 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 12 | Line 12 | static const char RCSid[] = "$Id";
12		#include "copyright.h"
13
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
#	Line 60 | 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 97 | 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 141 | 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 151 | 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	>	const char  *s
174	>	)
175		{
176		static int  midline = 0;
177
#	Line 175 | Line 190 | register char  *s;
190
191
192		void
193	<	setdefaults()                   /* set default values */
193	>	quit(int ec)                    /* make sure exit is called */
194		{
195	+	if (ray_pnprocs > 0)    /* close children if any */
196	+	ray_pclose(0);
197	+	else if (ray_pnprocs < 0)
198	+	_exit(ec);      /* avoid flush in child */
199	+	exit(ec);
200	+	}
201	+
202	+
203	+	static void
204	+	setdefaults(void)                       /* set default values */
205	+	{
206		int     nviews;
207		int     decades;
208		char    buf[256];
#	Line 251 | Line 277 | setdefaults()                  /* set default values */
277		}
278
279
280	<	void
281	<	setmove(om, ms)                 /* assign a move object from spec. */
282	<	struct ObjMove  *om;
283	<	char    *ms;
280	>	static void
281	>	setmove(                        /* assign a move object from spec. */
282	>	struct ObjMove  *om,
283	>	char    *ms
284	>	)
285		{
286		char    parname[128];
287		char    *cp;
#	Line 299 | Line 326 | char   *ms;
326		if (isflt(om->prio_file)) {
327		om->prio = atof(om->prio_file);
328		om->prio_file[0] = '\0';
329	<	haveprio |= (om->prio < 0.95 | om->prio > 1.05);
329	>	haveprio |= ((om->prio < 0.95) | (om->prio > 1.05));
330		} else
331		haveprio = 1;
332		} else
#	Line 311 | Line 338 | badspec:
338		}
339
340
341	<	void
342	<	setrendparams(optf, qval)       /* set global rendering parameters */
343	<	char            *optf;
344	<	char            *qval;
341	>	static void
342	>	setrendparams(  /* set global rendering parameters */
343	>	char            *optf,
344	>	char            *qval
345	>	)
346		{
347		char    *argv[1024];
348		char    **av = argv;
#	Line 323 | Line 351 | char           *qval;
351		av[ac=0] = NULL;
352		/* load options from file, first */
353		if (optf != NULL && *optf) {
354	<	ac = wordfile(av, optf);
354	>	ac = wordfile(av, 1024, optf);
355		if (ac < 0) {
356		sprintf(errmsg, "cannot load options file \"%s\"",
357		optf);
#	Line 332 | Line 360 | char           *qval;
360		}
361		/* then from options string */
362		if (qval != NULL && qval[0] == '-')
363	<	ac += wordstring(av+ac, qval);
363	>	ac += wordstring(av+ac, 1024-ac, qval);
364
365	<	/* start with default parameters */
366	<	ray_defaults(NULL);
365	>	/* restore default parameters */
366	>	ray_restore(NULL);
367		/* set what we have */
368		for (i = 0; i < ac; i++) {
369		while ((rval = expandarg(&ac, &av, i)) > 0)
#	Line 349 | Line 377 | char           *qval;
377		continue;
378		}
379		rval = getrenderopt(ac-i, av+i);
380	<	if (rval >= 0) {
381	<	i += rval;
382	<	continue;
380	>	if (rval < 0) {
381	>	sprintf(errmsg, "bad render option at '%s'", av[i]);
382	>	error(USER, errmsg);
383		}
384	<	sprintf(errmsg, "bad render option at '%s'", av[i]);
357	<	error(USER, errmsg);
384	>	i += rval;
385		}
386		}
387
388
389	<	void
390	<	getradfile(rfargs)              /* run rad and get needed variables */
391	<	char    *rfargs;
389	>	static void
390	>	getradfile(             /* run rad and get needed variables */
391	>	char    *rfargs
392	>	)
393		{
394		static short    mvar[] = {OCONV,OCTREEF,RESOLUTION,EXPOSURE,-1};
395		char    combuf[256];
396	<	register int    i;
397	<	register char   *cp;
398	<	char    *pippt;
396	>	int     i;
397	>	char    *cp;
398	>	char    *pippt = NULL;
399		/* create rad command */
400		strcpy(lorendoptf, "ranim0.opt");
401		sprintf(combuf,
#	Line 410 | Line 438 | char   *rfargs;
438		}
439
440
441	<	void
442	<	animate()                       /* run through animation */
441	>	static void
442	>	animate(void)                   /* run through animation */
443		{
444		int     rpass;
445
#	Line 443 | Line 471 | animate()                      /* run through animation */
471
472
473		VIEW *
474	<	getview(n)                      /* get view number n */
475	<	int     n;
474	>	getview(                        /* get view number n */
475	>	int     n
476	>	)
477		{
478		static FILE     *viewfp = NULL;         /* view file pointer */
479		static int      viewnum = 0;            /* current view number */
#	Line 456 | Line 485 | int    n;
485		fclose(viewfp);
486		viewfp = NULL;
487		viewnum = 0;
488	<	copystruct(&curview, &stdview);
488	>	curview = stdview;
489		}
490		return(NULL);
491		}
#	Line 472 | Line 501 | int    n;
501		perror(vval(VIEWFILE));
502		quit(1);
503		}
504	<	copystruct(&curview, &stdview);
504	>	curview = stdview;
505		viewnum = 0;
506		}
507		if (n < 0) {                            /* get next view */
508	<	register int    c = getc(viewfp);
508	>	int     c = getc(viewfp);
509		if (c == EOF)
510		return(NULL);                   /* that's it */
511		ungetc(c, viewfp);
#	Line 492 | Line 521 | int    n;
521		}
522
523
524	<	int
525	<	countviews()                    /* count views in view file */
524	>	static int
525	>	countviews(void)                        /* count views in view file */
526		{
527		int     n;
528
#	Line 506 | Line 535 | countviews()                   /* count views in view file */
535
536
537		char *
538	<	getexp(n)                       /* get exposure for nth frame */
539	<	int     n;
538	>	getexp(                 /* get exposure for nth frame */
539	>	int     n
540	>	)
541		{
542		extern char     *fskip();
543		static char     expval[32];
544		static FILE     *expfp = NULL;
545		static int      curfrm = 0;
546	<	register char   *cp;
546	>	char    *cp;
547
548		if (n == 0) {                           /* signal to close file */
549		if (expfp != NULL) {
#	Line 559 | Line 589 | formerr:
589		sprintf(errmsg, "%s: exposure format error on line %d",
590		vval(EXPOSURE), curfrm);
591		error(USER, errmsg);
592	+	return NULL; /* pro forma return */
593		}
594
595
596		double
597	<	expspec_val(s)                  /* get exposure value from spec. */
598	<	char    *s;
597	>	expspec_val(                    /* get exposure value from spec. */
598	>	char    *s
599	>	)
600		{
601		double  expval;
602
#	Line 572 | Line 604 | char   *s;
604		return(1.0);
605
606		expval = atof(s);
607	<	if ((s[0] == '+' | s[0] == '-'))
607	>	if ((s[0] == '+') | (s[0] == '-'))
608		return(pow(2.0, expval));
609		return(expval);
610		}
611
612
613		char *
614	<	getoctspec(n)                   /* get octree for the given frame */
615	<	int     n;
614	>	getoctspec(                     /* get octree for the given frame */
615	>	int     n
616	>	)
617		{
618		static char     combuf[1024];
619	<	int             cfm = 0;
619	>	static int      cfm = 0;
620		int     uses_inline;
621		FILE    *fp;
622		int     i;
623		/* is octree static? */
624		if (!vdef(MOVE))
625		return(vval(OCTREEF));
626	<	/* done already */
626	>	/* done already? */
627		if (n == cfm)
628		return(combuf);
629		/* else create object file */
630	<	strcpy(objtmpf, "movinobj.rad");
598	<	fp = fopen(objtmpf, "w");
630	>	fp = fopen(mktemp(strcpy(objtmpf, TEMPLATE)), "w");
631		if (fp == NULL) {
632		sprintf(errmsg, "cannot write to moving objects file '%s'",
633		objtmpf);
#	Line 626 | Line 658 | int    n;
658		vdef(OCONV) ? vval(OCONV) : "",
659		vval(OCTREEF), objtmpf);
660		else
661	<	sprintf(combuf, "!xform -f %s | oconv -f -i '%s' -",
662	<	objtmpf, vval(OCTREEF));
661	>	sprintf(combuf, "!xform -f %s | oconv %s -f -i '%s' -",
662	>	objtmpf, vdef(OCONV) ? vval(OCONV) : "",
663	>	vval(OCTREEF));
664		return(combuf);
665		}
666
667
668	<	char *
669	<	getobjname(om)                  /* get fully qualified object name */
670	<	register struct ObjMove *om;
668	>	static char *
669	>	getobjname(                     /* get fully qualified object name */
670	>	struct ObjMove  *om
671	>	)
672		{
673		static char     objName[512];
674	<	register char   *cp = objName;
674	>	char    *cp = objName;
675
676		strcpy(cp, om->name);
677		while (om->parent >= 0) {
#	Line 650 | Line 684 | register struct ObjMove        *om;
684		}
685
686
687	<	char *
688	<	getxf(om, n)                    /* get total transform for object */
689	<	register struct ObjMove *om;
690	<	int     n;
687	>	static char *
688	>	getxf(                  /* get total transform for object */
689	>	struct ObjMove  *om,
690	>	int     n
691	>	)
692		{
693		static char     xfsbuf[4096];
694		char            *xfp;
#	Line 664 | Line 699 | int    n;
699		char            *av[64];
700		int             ac;
701		int             i;
702	<	register char   *cp;
702	>	char    *cp;
703		/* get parent transform, first */
704		if (om->parent >= 0)
705		xfp = getxf(&obj_move[om->parent], n);
#	Line 761 | Line 796 | int    n;
796		om->cprio = om->prio;
797		}
798		/* XXX bxfm relies on call order */
799	<	if (framestep)
799	>	if (framestep) {
800		if (invmat4(om->bxfm, om->cxfm))
801		multmat4(om->bxfm, om->bxfm, oxf.xfm);
802		else
803		setident4(om->bxfm);
804	+	}
805		/* all done */
806		return(xfp);
807		}
808
809
810		int
811	<	getmove(obj)                            /* find matching move object */
812	<	OBJECT  obj;
811	>	getmove(                                /* find matching move object */
812	>	OBJECT  obj
813	>	)
814		{
815		static int      lasti;
816		static OBJECT   lasto = OVOID;
817		char    *onm, *objnm;
818		int     len, len2;
819	<	register int    i;
819	>	int     i;
820
821		if (obj == OVOID)
822		return(-1);
#	Line 791 | Line 828 | OBJECT obj;
828		objnm = obj_move[i].name;
829		len = strlen(objnm);
830		if (!strncmp(onm, objnm, len)) {
831	<	if ((obj_move[i].parent < 0 & onm[len] == '.'))
831	>	if ((obj_move[i].parent < 0) & (onm[len] == '.'))
832		break;
833		objnm = getobjname(&obj_move[i]) + len;
834		len2 = strlen(objnm);
#	Line 805 | Line 842 | OBJECT obj;
842
843
844		double
845	<	obj_prio(obj)                   /* return priority for object */
846	<	OBJECT  obj;
845	>	obj_prio(                       /* return priority for object */
846	>	OBJECT  obj
847	>	)
848		{
849		int     moi;
850
#	Line 816 | Line 854 | OBJECT obj;
854		}
855
856
857	+	#if defined(_WIN32) || defined(_WIN64)
858	+	/* replacement function for Windoze */
859	+	static int
860	+	gettimeofday(struct timeval *tp, void *dummy)
861	+	{
862	+	FILETIME        ft;
863	+	LARGE_INTEGER   li;
864	+	__int64         t;
865	+
866	+	SYSTEMTIME              st;
867	+	FILETIME                ft2;
868	+	LARGE_INTEGER   li2;
869	+	__int64                 t2;
870	+
871	+	st.wYear = 1970;
872	+	st.wHour = 0;
873	+	st.wMinute = 0;
874	+	st.wSecond = 0;
875	+	st.wMilliseconds = 1;
876	+
877	+	SystemTimeToFileTime(&st, &ft2);
878	+	li2.LowPart = ft2.dwLowDateTime;
879	+	li2.HighPart = ft2.dwHighDateTime;
880	+	t2 = li2.QuadPart;
881	+
882	+	GetSystemTimeAsFileTime(&ft);
883	+	li.LowPart  = ft.dwLowDateTime;
884	+	li.HighPart = ft.dwHighDateTime;
885	+	t  = li.QuadPart;
886	+	t -= t2; // From 1970
887	+	t /= 10; // In microseconds
888	+	tp->tv_sec  = (long)(t / 1000000);
889	+	tp->tv_usec = (long)(t % 1000000);
890	+	return 0;
891	+	}
892	+
893	+	#endif
894	+
895		double
896	<	getTime()                       /* get current time (CPU or real) */
896	>	getTime(void)                   /* get current time (CPU or real) */
897		{
898		struct timeval  time_now;
899		/* return CPU time if one process */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)