Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (plan9)
Apropos / Subsearch:
optional field

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 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), <&lt;, >&gt;, <&lt;=, >&gt;=, ==, !=, ?: 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&&amp;&&amp;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

       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  argu-
       ments,  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.