man(1) Manual page archive

     MOTO(9.1)                                               MOTO(9.1)

          moto - create animation scripts

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

          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 argu-
          ments 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 cur-
          rent 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 com-
          plex 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

     MOTO(9.1)                                               MOTO(9.1)

               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 compu-
          tations, 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 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

     MOTO(9.1)                                               MOTO(9.1)

               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 sev-
          eral files, under program control.  A group that is sepa-
          rated 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.