interaction


real time interaction

Principle
Lauching options
Multiple commands interaction ...

       ascii
       coe        cut
       debug        displ
       end        error
       func
       image               interpol
       limit
       menu        mouse
       name        noswap
       period        play        pull
       radius
       screen        see        stock        STOP        swap
       time
       win        write

Using the mouse
Using the menu
Special characters
See also

Principle

Interaction mode

       Anyflo is a graphic language evolved preferably using procedural mode (writing functions).
       A real-time interface (calling MainLoop OpenGL) is available, however, by the command interaction. Once this command is launched interpreter no longer has hand (clic right->interpreteur can invoke shell commands for a line).
The escape character returns to interpreter.
Note: foc is initialized to 0.8.

Call backs

       The interaction occurs through the The interaction occurs through the interaction func option, which defines functions (written in C language or anyflo) executables at different levels (call back).

Interaction with the mouse

       Functionality allowing to interact with the mouse:
displ: to display all kinds of objects.
displ exec: to run command lines or functions.
scale: to read values (1, 2 or 3 dimensional).
menu: to define menus (OpenGL or anyflo style).

Lauching options

Interactively modifying the view
Interactively modifying volumes
Swap
format
Writing images
name
call back
time
period

Interactively modifying the view

interaction("rotxz_eye"):
       the left mouse button allows modifying the rotx and roty of eye.
interaction("rotxy_eye"):
       the left mouse buttonallows modifying the rotx and rotz of eye.
interaction("tran_eye"):
       the left mouse button allows displacing the eye.
interaction("ini_view"):
       resets the view to its default values.
illum(r,v,b:
       frame color (white default).
limit(x1,y1,x2,y2):
       restricts input to frame (x1, y1, x2, y2) that is displayed.
coe(c):
       multiplies the angles and displacements by c (1 default).

Interactively modifying volumes

interaction("tran"):
       the left mouse button allows to move the volumes designated.
Same for interaction("rota"), interaction("rotx"), interaction("roty") , interaction("rotz").

Swap

interaction("noswap"):
       swap is inhibited (the image is frozen).
interaction("swap"):
       swap is restored.

interaction format
       Mesage ANYFLO Michel BRET appears at the bottom of the screen by default. Option interaction format("ANYFLO Michel BRET"): allows this message to not be displayed.
Writing images
interaction write("nnn.ext"):
       successive images will be saved under the names nnn0001.ext, nnn0002.ext ...nnn0001.ext, nnn0002.ext, ...

interaction name
interaction name("ttt"):
       displays ttt during 400 images
       interaction name("ttt",t): displays ttt during t*400 images (t >= 1).

Calls back
       interaction func(n,"Fn"): active callback Fn() order n.

period
       interaction period(p) redefines the display frequency.

Note: these options can be invoked after entering the interaction mode.

Cascading menus
       interaction menu("f1 f2 ...")
              Allows you to define cascading menus associated with right mouse button:
(right button) -> menu -> f1, ...

Multiple commands interaction...

interaction

Launches the interaction mode. Called in this mode with
options.


ascii
coe        cut
debug        displ
end        error
func
limit
menu        mouse
name        noswap
play        pull
radius
screen        see        stock        STOP        swap
time
win        write

interaction displ

interaction displ vol; returns the numbered displayable volumes.
interaction displ vol(id); only volumes id will be displayable.

interaction ascii

edit interaction ascii
ascii abs
ascii format
ascii func
ascii poi
ascii_write

interaction ascii

       Interaction mode returns the ASCII code of a key in nonblocking read, except:
ESCAPE emerging from interaction, > reseting the buffer (useful if some key of interaction ascii("c") func("f") is lost).
! introducing a string to be interpreted by ENTER.
If the first character is < (redefinable by interaction ascii format), reading waits ENTER.
The display options are valid.
Note:
interaction ascii=0: reset the buffer.
interaction ascii="c": set the buffer to c.

interaction ascii abs

       Returns the pressed key.

interaction ascii format


       Returns the character c (< default) for reading the keyboard with the command:
nn=interaction ascii ...;
interaction ascii format("c")
       Redefines the character c.
Note:
we can replace "c" by its ascii code.
Eg interaction ascii format("A") is equivallent to interaction ascii format(65).

interaction ascii("c") func("f")

       Associates the function f to the character c. The function f will be executed each time the button c is pressed.

interaction ascii("c") func

       Returns the name of the function associated with the c key on the keyboard.

interaction ascii func("f")

       Returns the key c associated with the function f.
Note:
This property is typically declared once in a function interaction func(0,"f0").
interaction ascii("ccc") func("f")
       Associates the function f to the string ccc. The function f will be executed whenever the string <ccc will be entered followed by a carriage return.
Notes:
1) <ccc x runs f(x);
2) <ccc x y runs f(x,y);
3) !ccc executes the command line ccc
Example: !fff(): runs function fff()
4) interaction ascii format("k"); replaces < by k.

interaction ascii("ttt")poi(x,y)

Example:
x=interaction ascii("ttt")poi(-200,-200)rectangle(0,0,0) frame(0,1,0)col(1,1,0);
Displays text ttt in a black rectangle in (-200,200) box green, x is the value (in ASCII) of text entered after < that appears in yellow.

interaction ascii("g") write name obj

       Returns the name of the objects obj associated with theg key.

interaction ascii write name("nnn")obj

       Returns the key associated with objects obj named "nnn".

interaction ascii("g") write name("nnn")obj

       Asocie key g to write obj name(nnn).
With options of write image for images.
Note: are destroyed (input and output of interaction mode) should therefore be declared in a function F0.
Special options:
name("nnn"): objects will be stored under the names nnn1.eee, nnn2.eee ... (A1.eee A2.eee ... default).
number(num,ni,inc): ni objects will be stored under the names nnnnum.eee nnnnum+inc.eee ... nnnnum+(ni-1)*inc.eee (by default ni=25, num=1, inc=1).
number("4D",num,ni,inc): names will be numbered on 4 digits.
Examples:
interaction ascii("g")write name("A.bmp")image "4D",ni,10); the images (full screen) will be stored under the successive names: A0010.bmp A0011.bmp A0012.bmp ...
interaction write name("A.jpg")image win(.5,-.5, .5,.5)normal number("4D",10,2)format("RGB"); the images (lower right quadrant) will be stored under the successive names: AOO10.bmp AOO12.bmp AOO14.bmp ... by reversing the red and blue components.

interaction coe

interaction coe

       Restores the multiplier of transformations its default value 1.

interaction coe(c)

       Changes this coefficient.
Note: transformations interaction("...") are multiplied by c.

interaction cut

       Returns -1 mode (continuous default) or 1 (step by step).
Options:
cut(1): step by step mode
cut(-1): continuous mode
cut(0): mode step ahead of an image
Note: Is typically called in a function from a menu.

interaction debug

       F5 called in a function () type interaction func(5,"f5") , this command displays a scale to choose the number of values with scale options (option poi (x, y) is normalized between 0 and 1, the origin is the bottom left corner of the screen). For each of these values two scales appear: The first allows you to select a value between -B and B, the B terminal is selected on the second scale.
interaction debug(n)
       Returns the scale value n (0 to n-1). .
interaction debug(n)=v
       Assigns the value vto scale n (can be used in a function written in C v = Val_Debug [3 * n]).
interaction debug poi=x,y
       Moves scales (x and y between 0 and 1).
interaction debug NP
       Returns the number of validated scales.
interaction debug NP(n)
       Allows you to choose the number of validated scales (between 0 and 24).
interaction debug rectangle
       Displays the full scales (default).
interaction debug frame
       Displays scales wire.
Note: Parameters of this function are available in C language.

interaction displ

       Returns the numbers of the volumes displayed.

interaction displ(num1,num2,...)

       Sets the numbers of the volumes displayed in this order (allows managing the transparencies).

interaction displ(0)

       Sets the numbers of every volumes.

interaction screen

       Returns the screen clearing period. interaction screen(ni)
              Clears the screen and the zbuffer each ni.
If interaction stock or interaction write is active, the image will be saved one image before clearing the screen (allows to accumulate an animation of higher order.
Options:
func: returns the name of the function associated with traj of traj.
func("FIA"):
changes this name.
Note: this function will be executed after each clearing of the screen.

interaction win

       Initiates the interaction with a window full screen.

interaction end

interaction end mouse

Exits (by program) of interaction mouse mode.

interaction error

When stopping interaction adds start ans stop time in file DATE.log.
Options:
error(-1): writes instead of adding.

interaction func (callbacks)

interaction func(0,"f0")

       Interaction switches by running the function f0 () once. Useful to declare automatic properties.

interaction func(n,"fn") (n>0)

       The functions f () are performed at each frame in the following order:

f1(): before the trajectories computations.
       reseting all flags:
              poi anc
              normal fac
              normal vertex
              normal fac generate
              normal vertex generate

f2(): before dynamic and collisions.
       performes the collision anc
       performes dynamic limits
       performes the meta
       performes the dynamic
       resets all force, force add, force rota, force rota add
       performes the collision

f3(): before clear screen.

f4(): before display (to display background images).
       performes the local
       performes the limit
       displays images
       displays volumes

f5(): after display (processing menus, scales, messages and texts)

f6(): when returning of interaction mode (by escape or end interaction (useful for chaining secevral applications). and before swapping.

Notes:
       These functions are performed each image except f0 () which is executed only once at the beginning of interaction. In such functions can execute any anyflo command.

interaction write

write_image
write edit
write end
options
write vol

interaction write image

Returns (im,ni) with:
       im=number of the image currently stocked.
       ni=number of the last images.
Notes:
interaction write image=NIL when animation is completed (allows checking the end).

interaction write image name("nnn.eee")number(num1,ni)

Saves ni images in files nnnnum1.eee, nnnnum1+1.eee, ..., nnnnum1+ni-1.eee.
Options:
number("4D"im,ni): file names indexed with 4 digits.
dim(nx,ny): image size (dim screen default).
win(x1,y1,x2,y2): save window (full default).

interaction write edit

       interaction write edit(1): enables verbose mode for all commands interaction write
       interaction write edit(0): inhibits this verbose mode.

interaction write end

Stops the process of writing.

Options:

abs: does not transform the dimensions in powers of 2 (for option dim(nx1,ny1,nx2,ny2)).

dim(nx1,ny1): the image is resized to (nx2,ny2) (screen dimensions by default) (where (nx2,ny2) are powers of 2 closest nx1,ny1).
If the option abs is present nx2=nx1 and ny2=ny1.

format("fff"): format of the images.

name("Anum1.eee Bnum2.eee",n1,n1,num): for every n1 image the files "Anum1.eee and "Bnum2.eee are read and interpolated in images number num ... (1000000000 default) and used by the first order animation process, then num1 and num2 are incremented.
Note: the field n1,n1 is required.

normal: normalized coordinates (between 0.0 and 1.0).

number(im,ni) set:
       im=number of the first image to be saved (default 1).
       ni=images saved number.
       number("4D"im,ni): with 4 digits.

win(x1,y1,x2,y2): stores the window (x1,y1,x2,y2) (screen size by default).

Notes:
interaction write end: stops the process of writing.
The images stored can be viewed with command play image.

interaction write vol

Same as write image, but for volumes.

interaction image

Allows manage fluent interpolation of textures:

directory
generate
NP
read
var
image vol
image vol number

interaction image read directory("dir1,dir2,...")number(i1,num)

Reads nbi images of folder diri in images numbers i1i, i1i+1, ..., i2i, with i11 = num.
Options:
animate(ni): number of interpolated images (25 default).
dim(dx,dy): size of read images. num1,num1+1, ..., builds the 5D array:
       nbi, * ,*, ii1, ii2
with:
       nbi = number of images of the forder diri.
       ii1, ii2 = first and last read image numbers (i1,i1+1, ...).
Options:
animate(ni): number of interpolated images (default 25).
dim(dx,dy): size of read images.

interaction image(im,im2)read number(i1,num)

As before with images [im1,im2]=im1;im1+1,...,im2 in memory, instead of image files, building images num,num+1,..., and building a single sequence type; and array of one type sequence i1,i1+1,...,i1+num-1.

interaction image generate animate(ni)

Computes interpolated sequences, with ni = number of interpolated images:
first along the images of every forder:
       im1i, im1i+1, im1i+1, ..., im2i, with im11=num.
Builds the 5D array:
       nbi, im1i, im1i, i1i
then between the last image of every folder and the first image of every foldre in the array:
       im1i, im1i+1, im1i+1, ..., im2i.
This array is returnad by
interaction image var.
Its size is returnad by interaction image NP.

interaction image directory

returns the number of directories.

interaction image var

returns the buffer.

interaction image var=

changes the buffer, must be of the form:
       ni,im1,im2,i1,i2
       ni,im1,im2,i1,i2
       ...

interaction image vol

runs the automatic process of textures interpolation for every volumes.
Options:
image(num1,num2): next sequence between num1 and num2 (default).
image(num1,num2)alea: random sequence between num1 and num2.
image(num1,num2)law(num): next sequence is num between num1 and num2.
vol(id); for the volume id.

interaction image vol number(seq)

initiates the automatic proces of textures interpolation between the current texture and the first texture of sequence seq for all the volumes.
Options:
animate(ni): on ni images (25 default).
vol(id); for the volume id.

interaction image NP

returns the number of 5D vectors.

interaction interpol

interaction interpol(ni)image(id1,id2)image(id3)

Starts interpol(k,1-k)image(id1,id2)image(id3) from k=1.0 to k=0.0 on ni images.
Options:
interaction(id): allows define several such objects with various properties.
Note:
validate interaction(id)interpol image returns 0 if the process is finished.

interaction limit

       Gives the framework of its entry defaults value 1 (screen size).

interaction limit(x1,y1,x2,y2)

       Change this frame.

interaction menu

interaction menu
simple
cascading
dynamic

interaction menu(" ")

       May be useful after ini graphic to find the menus.

Simple menu

interaction menu("f1 f2 ...")
       When you right-click, interaction menu appears. If you right click on the box menu f1 f2 ... appears. If you click on the function fi, fi () is executed.

Cascading menus

Cascading menus can be defined (as in OpenGL) the deepest to the main menu.
A submenu sm is declared as:
       menu(">sm f1 f2 ...")
It can be referenced, below, as:
       menu(">...sm ...")
When you click on this menu boxes f1 f2 ... allow trigger functions f1 () f2 () .... f1() f2() ....
Example:
1) code:
interaction
menu(">sm3 f1 f2")
menu(">sm4 f3 f4")
menu(">sm5 f5 f6")
menu(">sm6 f7 f8")
menu(">sm1 sm3 sm4")
menu(">sm2 sm5 sm6")
menu("sm1 sm2 f6");

2) explanations:
/* Level 2 */
menu(">sm3 f1 f2")
       Declares sub menu sm3 calling functions f1 and f2.
menu(">sm4 f3 f4")
       Declares sub menu sm4 calling functions f3 and f4.
menu(">sm5 f5 f6")
       Declares sub menu sm5 calling functions f5 and f6.
menu(">sm6 f7 f8")
       Declares sub menu sm6 calling functions f7 and f8.
/* Level 1 */
menu(">sm1 sm3 sm4")
       Declares sub menu sm1 calling sub menus sm3 and sm4.
menu(">sm2 sm5 sm6")
       Declares sub menu sm2 calling sub menus sm5 and sm6.
/* Niveau 0 */
menu("sm1 sm2 f0")
       Declares main menu menu calling sub menus sm1 and sm2, and calling function f0.

Dynamic menus

interaction menu("...")menu("...")...
Called, interaction off, enters the module defining the interaction menus.
Called in the intercation module, allows dynamically redefine menus.
See menu_cascade.func.

interaction name

interaction name("ttt",t)

       Entering interaction mode, displays the message "ttt" during t * 50 images (t = 1 by default).

interaction noswap

Inhibits swap (image frozen).

interaction period

interaction period(np) name("A")

       Initializes memory named "A" to np zero values.
interaction period name("A") poi(x)
       stacks x and returns the period of the signal x.
Remarque:
       In real-time mode (interaction) memory "A" is a stack of circular current value x.

interaction play

interaction play device

       Returns the value of the sensor, and NIL if the animation is completed or not yet started, must have made interaction play device name..

interaction play device name

interaction play device name("name")wait(t)
       Reads the information of file name.cap generated by interaction stock device name("name") and assigns them to the sensor. Reads and executes commands stored in file name.eff. If wait (t) is present, the animation starts only after t images (allows synchronize music).
Note: name("name",dimp) allows you to specify the size of the records (which can prevent coding errors file).

interaction play device write

interaction play device name("name")write("ima")
       Do as interaction play device name and writes images in nomxxxx.bmp (where xxxx = number of the image).
To change the type of extension:: ext("eee") avec eee=jpg bmp ima raw
To change format: format("f") avec f=nD, n=nombre de caractères (4 par défaut).
To perform a convolution of theimage in a window size (dx,dy): dim(dx,dy)
This command can be replaced by:
       interaction play device name("name");
       interaction write image name("ima") ext("bmp")format("4D")dim(x,y);
See interaction write image.

interaction play vol

interaction play("name")vol
       Reads the information of file fff.sto generated by interaction stock name vol and affects them to the volumes involved.

If edit is present commands and their values are displayed. Save volumes
       See: interaction write vol.

interaction radius

interaction radius

returns the picking radius.

interaction radius(r)

changes this radius.

interaction mouse

interaction mouse


       message CONTINUE (green) and X (red) is displayed in the upper left of the screen, click on:
       CONTINUE: advances one frame.
       X: out of this interrupt mode.
interaction end mouse allows exit this mode by program.
Options:
col(r,g,b): text colour (r,g,b) (white default).
font("fff").
poi(x,y): displays in (x,y) (upper left corner by default).
frame(r,g,b): displays frame colour (r,g,b) (white default).
rectangle(r,g,b): displays rectangle colour (r,g,b) (white default).
validate: returns 1 if this mode is enabled, otherwise returns 0.

interaction stock

stock edit
stock end
stock image
options
stock_device
stock_vol

interaction stock edit

interaction stock edit(1): enables verbose mode for all commands interaction stock
interaction stock edit(0): inhibits this verbose mode.

interaction stock obj end

Stops the process interaction stock obj.

interaction stock image

Returns (im,ni,dni)
Notes:
returns NIL when animation completed (allows testing the end).
yes stock is requiered.

interaction stock image number(im,ni,dni)

every dni (1 default) time the image is stored in image im++

Options:

abs: does not transform the dimensions in powers of 2 (for option dim(nx1,ny1,nx2,ny2)
).

dim(nx1,ny1): the image is resized to (nx2,ny2) (screen dimensions by default) (where (nx2,ny2) are powers of 2 closest nx1,ny1).
If the option abs is present nx2=nx1 and ny2=ny1.

name("Anum1.eee Bnum2.eee",n1,n1,num): every n1 images the files "Anum1.eee and "Bnum2.eee are read and interpolated in images number num ... (1000000000 default) and used by the first order animation process, then num1 and num2 are incremented.
Note: the field n1,n1 is required.


number("4D"im,ni): with 4 digits.

win(x1,y1,x2,y2): stores the window (x1,y1,x2,y2) (screen size by default).

Notes:
interaction end: stops the process of stocking.

It is recommended to choose (nx1,ny1) small enought to avoide memory overflow (for example 128).
The images stored can be viewed with command play
Or, out of interaction, by:
for(i=1,n){displ image(i)poi(0,0)normal;wait(1/25);}

interaction stock image number(im,ni,dni)name("nnn.eee")

every dni (1 default) time the image is stored in image file nnnim++.eee

Options:

abs: does not transform the dimensions in powers of 2 (for option dim(nx1,ny1,nx2,ny2)
).

dim(nx1,ny1): the image is resized to (nx2,ny2) (screen dimensions by default) (where (nx2,ny2) are powers of 2 closest nx1,ny1).
If the option abs is present nx2=nx1 and ny2=ny1.
number("4D",im,ni,dni): with 4 digits.

name("Anum1.eee Bnum2.eee",n1,n1,num): every n1 images the files "Anum1.eee and "Bnum2.eee are read and interpolated in images number num ... (1000000000 default) and used by the first order animation process, then num1 and num2 are incremented.
Note: the field n1,n1 is required.


number("4D"im,ni): with 4 digits.

win(x1,y1,x2,y2): stores the window (x1,y1,x2,y2) (screen size by default).

Notes:
interaction end: stops the process of stocking.

It is recommended to choose (nx1,ny1) small enought to avoide memory overflow (for example 128).
The images stored can be viewed with command play
Or, out of interaction, by:
for(i=1,n){displ image(i)poi(0,0)normal;wait(1/25);}

interaction stock device

stock_device_dim        stock_device_dim        stock_device_name        stock_device_NP
interaction stock device(val)
       After interaction stock device name allows to save the value of sensor.
interaction stock device dim
       Returns the size of records.
interaction stock device name
interaction stock(ni) device name("name")
       Saves (in ascii) to each image, sensor values in file fff.cap, as well as interactive interventions (or CCC! Ccc) in file fff.eff
       command interaction stock device(val), called for every frame, actually stores the values val sensor in memory. Files are written to the end of the animation, which is reached after ni calls, or is interrupted by interaction stock end.
       To replay: play device name("fff").
interaction stock device name("nn")module(m)
       Starts the animation when the sensor module exceeds m (0.1 by default), which can automatically calibrate any sensor, the animation when starting this one has a significant value.
interaction stock device name("nn")wait(t)
       Starts the animation after t images (100 by default). interaction stock device NP
       Returns the number of animation frames.

interaction stock vol name

interaction stock(ni) vol name("name") Stockes every image:
       num: number of the volume
       rx, ry, rz: rotations around axes
       cx, cy, cz: dilatations along axes
       a, xa, ya, za: rotation around axes (xa,ya,za)
interaction stock name("fff")vol(n1,n2,...)
Stores informations in file fff.sto (in binary) to end of animation, which is reached after ni images.

to replay see play.
name file is:
       fff.cap for device(val), sensor value.
       fff.sto for device("vol"), informations about volumes.

interaction STOP

       Exits interaction mode equivalent to no interaction).

interaction swap

Activates swap (default).

interaction time

interaction time(t)

       restricts the duration of animation to t images t = 0 by default: eternal).
Options:
interaction time(t,e): si e=0 inhibiting the Esc key (avoids accidental return to keyboard mode).
interaction time(t,e,1): animate only after the message is displayed.
interaction time("s",t): exits interaction mode after t seconds.
interaction time("m",t): exits interaction mode after t minutes.
interaction time("h",t): exits interaction mode after t hours.

interaction pull

       Activates the mode pull, every vertex of a volume pointed out with the mouse will take this position.
Options:
limit(x1,y1,x2,y2): only vertices inside the frame (x1,y1,x2,y2), this frame is displayed with color (r,v,b).
illum(r,v,b): frame color (white default).
Note: the picking radius may be changed by interaction radius.

interaction play

Plays the sequence memorized by interaction stock image(n1,n2).
Options:
end: stop the play.
normal(x,y): display the images at the left lower corner x,y (normalized between 0.0 and 1.0, 0.0,0.0 default).
number(num1,num2): images num1 to num2 (n1,n2 default).
period(p): frequency p images per second (25 default).
poi(x,y): images displayed at (x,y) (0,0 default) in screen coordinates.

interaction see

       Switches tointeraction mode with yes see activated, allows to interact with the keyboard, the text is displayed on the image (recommended mode in full screen).
Note: It is not recommended to run a demo in this mode (possible conflicts between the interaction of the demo and see the interaction see).

Using the mouse

Bouton de right

Menus
Bouton du milieu
       Moves x: changes the focal
Left button
       Designations:
Choice of parameters of a transformation::
       Click on a vertex to designate an object, after choosing a transformation (transition, rotx, roty, rotz, pull)
Right button
       Acces to menu.

Using the menu

menu =>

       If the interaction was initiated with the interaction menu option interaction menu("f1 f2 ...") first box is menu, click above to access the drop-down menus f1 f2 ....
       Otherwise this box does not appear.

quitter

       Back to keyboard mode.

interpreteur

       Executes a command line entered to keyboard, in order to keep the hand just finish this line of control by input.

reset

       Resets all flags.

tran(eye)

       Click left: moves eye according to (x,y)

rotxy(eye)

       Click left: rotates eye according to (x,y)

rotxz(eye)

       Click left: rotates eye according to (x,z)

right

       Right view.

front

       Front view.

left

       Left view.

behind

       Behind view.

above

       Above view.

below

       Below view.

tran

       Left-click on a vertex of a volume: the displacement is measured by the displacement (x, y) of the mouse.

rotx

       Left-click on a vertex of a volume: the x angle of rotation is measured by the displacement (x, y) of the mouse.

roty

       Left-click on a vertex of a volume: the y angle of rotation is measured by the displacement y of the mouse.

rotz

       Left-click on a vertex of a volume: the z angle of rotation is measured by the displacement x of the mouse.

pull

       Click and drag a vertex by displacing the mouse, the input range is given by radius.
This transformation switches to no pers mode, reset returns yes pers mode.

memory =>

       Stores the rotation transformations
       rotx: x rotation
       roty: y rotation
       rotz: z rotation
       x,y,z,an: Quaternion

Special characters

Esc exits interaction mode (except if interaction has been launched with interaction option interaction time(0,0)).
[ asleep interaction.
] wakes interaction.
!com: executes the command com.
       Example: !cube(1);ball(2): builds a cube and a ball.
<ccc: pass ccc to interaction ascii.

See also:

edit interaction
end interaction
ini interaction
no interaction