Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
MOTO(9.1)							     MOTO(9.1)

NAME
       moto - create animation scripts

SYNOPSIS
       fb/moto [ -fstart end ] [ -sskip	] [ file [ arg ...  ] ]

DESCRIPTION
       Moto  is	 a  command  generator	tailored for an	animator's needs.  Its
       input is	a concise description of the animation	to  be	produced;  its
       output is a command file	suitable for input to rc or some other command
       interpreter.  Its arguments are an optional file	name containing	a moto
       program	(default  standard  input) and list of numeric parameters that
       are made	available to the program.

       A moto program consists of a list of groups of commands	guarded	 by  a
       range  of  frames.   Groups  may	 contain  parameter ranges enclosed in
       brackets	[].  For each frame, moto  checks  each	 group	and  processes
       those  whose guards include the current frame number:	  1,6: clr 128
	    1,4: clr -w	[0,30] [0,30]  [100,130]  [100,130]	  3,6: clr  -w
       [100,70]	 [100,70]  [130,100] [130,100] 255 This	generates      clr 128
	    clr	-w 0 0 100 100	    clr	128	 clr -w	10 10 110 110	   clr
       128	 clr -w	20 20 120 120	   clr -w 100 100 130 130 255	   clr
       128	clr -w 30 30 130 130	  clr -w 90 90 120  120	 255	   clr
       128	 clr  -w  80 80	110 110	255	 clr 128      clr -w 70	70 100
       100 255

       Two special guards, BEGIN and END, specify actions to be	 taken	before
       and  after  processing frames.  Moto allows complex computations	inside
       parameter brackets:	 1,10:	   clr	[127.5*(1-cos([0,360]))]  This
       generates       clr  0	   clr 29.82933350233	   clr 105.35985734747
	    clr	 191.25	      clr   247.3108091502	  clr	247.3108091502
	    clr	  191.25	clr  105.35985734747	   clr	29.82933350233
	    clr	0

       Expressions may include constants and variables.	 All values  are  dou-
       ble-precision  floating	point numbers.	The operators =, /, +, - (both
       unary and binary), <, >,	<=, >=,	==, !=,	?: and !, all with their mean-
       ings  as	 in  C,	 except	 that  all results are coerced to double.  The
       result of a%b is	a-b*(int)(a/b).	 The result of	a&&b  is  a?b:a.   The
       result  of a||b is a?a:b.  The exponentiation operator is ^, also writ-
       ten **.	The expression [a,b] varies from a to b, linearly as the frame
       number  varies  between	the guards of the group	containing the expres-
       sion.  The expression a[b,c] has	 the  value  a*b+(1-a)*c.   Its	 value
       varies  from b to c as a	varies from 0 to 1.  The expression $i has the
       value of	the i'th parameter following the file name on  moto's  command
       line.

       The precedence of operators is, from lowest to highest:	    =	   ? :
	    ||	    &&	    < <= == != > >=	 +  -	    *  /  %	  [  ]
	    ^  **      - (unary) ! $ Expressions may be	parenthesized to alter
       precedence.

       The following math functions are	available:	fabs floor  ceil  sqrt
       hypot  sin cos tan      asin acos atan exp log log10 sinh cosh tanh All
       math functions are as described in the C	library,  except  that	angles
       are  measured  in  degrees rather than radians for the trig and inverse
       trig functions.	In addition hypot may have  two	 or  three  arguments,
       atan  may  take	two  arguments instead of one, and may also be spelled
       atan2.

       For parameterization, and to allow even more complex computations, moto
       has  variables, assignment and computation groups.  A computation group
       causes no output; rather	its body is a group of expressions to be eval-
       uated for their side effects.  It is distinguished from a command group
       by  having  a   double	colon	separating   the   guard   and	 body:
	    BEGIN::   n=5	1,n::	  x=512*sin([0,90])	 1,n: pcp -w 0
       0 [x] 488 pic.[1,n] %0 This generates	  pcp -w 0 0 0	488  pic.1  %0
	    pcp	 -w  0	0  195.93391737093  488	 pic.2	%0	 pcp  -w  0  0
       362.03867196751 488 pic.3 %0	 pcp -w	0 0 473.02632064578 488	 pic.4
       %0      pcp -w 0	0 512 488 pic.5	%0

       Upon  occasion  it is useful to split moto's output into	several	files,
       under program control.  A group that is separated from its guards by an
       at-sign	@ instead of a colon names a file into which subsequent	output
       is to be	written.  For example,	    1,5@ file.[1,5]	 1,5: This  is
       file.[1,5].   creates  5	 files,	 with names file.1, ..., file.5.  Each
       file's contents will announce its name.

       As is true for all  sufficiently	 large	programs,  moto	 has  a	 shell
       escape.	 The  text of a	group separated	from its guards	by an exclama-
       tion point !  causes a copy of rc(1) to be started.  The	 group's  text
       is  sent	 to rc's standard input, and its standard output inserted into
       moto's output.

SOURCE
       /sys/src/fb/moto.y

								     MOTO(9.1)

NAME | SYNOPSIS | DESCRIPTION | SOURCE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=moto&sektion=9&manpath=Plan+9>

home | help