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 out-
       put 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 double-precision floating point numbers.  The operators =, /, +, - (both
       unary and binary), <, >, <=, >=, ==, !=, ?: and !, all with their meanings 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
       expression.  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 evaluated for their side effects.  It is distinguished from a com-
       mand 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 exclamation
       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)