//----------------------------//
ArtMatic 1 in 3 out components
//----------------------------//

• Vector:
  script call : Constant.any
  Defines a xyz vector
  
• Color constant:
  script call : Constant.rgb
  Defines a RGB Color, returned as a RGB vector.
  
• Normalised vector:
  script call : Constant.normalized
  Defines a normalised xyz vector (magnitude==1)
  
• VY sun light vector:
  script call : Constant.vy_sun
  Returns the Voyager sun light direction in the tile 3 outputs. With the sun light vector we can compute the sun coordinates in the sky dome easily. Note the sky dome is a sphere of Pi*2 radius. The constant "Packed VY sun light vector" has a magnitude parameter that shall be set to Pi*2 (maximum) so this will give the center of the sun projected on the sky dome. Subtract it from the input coordinate and you get a vector in sun coordinates where zero is the sun center.
  You may also use this vector to implement custom shading of DF objects or terrains.
  The Voyager sun light vector is also available in packed form with the 11 Set Constant component.
  
• VY eye position:
  script call : Constant.vy_eye
  Returns the Voyager camera eye coordinates. You may use this vector in Voyager for cool special effects like terrains features or objects/lights that will move along with the camera. Subtrat this vector to an ArtMatic DF object coordinates to ensure the object position is relative to Voyager camera position.
  The eye position is also available in packed form with the 11 Set Constant component.
  

ArtMatic script function :Scale_Vector

parameters :
A : A (-16.0 : 16.0) E9 options
B : B (-16.0 : 16.0) E9 options
C : C (-16.0 : 16.0) E9 options

discussion :
Scale the input value using parameters A, B and C. Output is A*x, B*x, C*x.

ArtMatic script function :Add

parameters :
A : A (-50.0 : 50.0) E9 options
B : B (-50.0 : 50.0) E9 options
C : C (-50.0 : 50.0) E9 options

discussion :
This component is sometimes referred to as Add Vector, the constant vector added being (A,B,C). The three outputs are x+A, x+B and x+C. Add Vector can be useful for adding offsets to the same axis to move several objects in the same axis.

discussion :
Unpack a 3D/RGB stream into its component streams. The stream must have been packed with the 3->1 Pack component or comes from a tile producing a packed stream directly. Most frequently, this is used with compiled trees: either inside of a compiled tree to unpack RGB values passed into the compiled tree through a single input or to unpack RGB values passed out of a compiled tree through a single output.
The corresponding inverse function is the 31 Pack(x,y,z) which packs the xyz input.

discussion :
Main Gradient maps input value to a color of the Main gradient (the current gradient). When parameters A 'Scale' and B 'Offset' are 1 and 0 respectively, 0 maps to the leftmost color of the gradient and 8 maps to the rightmost color.

• Linear:
  script call : Gradient.linear
  Input values maps to gradient colors using a linear ramp. 'Scale' sets the ramp slope.
  
• Linear mirror:
  script call : Gradient.mirror
  Like previous mode but the gradient is mirrored for negative x.
  
• Logarithmic:
  script call : Gradient.log
  Logarithmic uses 1+log(x+1/e) so that 0 maps to zero.
  
• Logarithmic mirror:
  Logarithmic Mirror uses ABS(x) to feed the logarithm. This mode corresponds roughly to the Logarithmic clut mode for scalar 1D output system.
  
• Dual Linear:
  script call : Gradient.dual
  This mode corresponds to the Balanced log clut mode for scalar 1D output system. It reverts the hues of the gradient for negative x;
  
• Dual Logarithmic:
  script call : Gradient.dual_log
  This mode corresponds to the Balanced log clut mode for scalar 1D output system. It reverts the hues of the gradient for negative x;
  
• Cyclic (sin):
  script call : Gradient.cyclic
  Cyclic sin uses a sine wave to loop the input. Thus the gradient progresses back and forth indefinitely. 'Scale X' controls the period and 'Offset' the phase. This mode corresponds roughly to the Cyclic clut mode for scalar 1D output system. In 8.08 the entire gradient is looped whatever the period.
  
• Cyclic (mod):
  script call : Gradient.cyclic_mod
  Cyclic modulo uses a saw tooth wave to loop the input before mapping into the gradient colors. As a result the gradient progresses forwards only while looping so to achieve continuity you'll need that the first color matches the last color. 'Scale X' controls the period and 'Offset' the phase. In 8.08 phases are adjusted so that first instance overlaps the non looping mode.
  

discussion :
This component is similar to 13 Main Gradient but uses parameter C (Index) to choose the gradient that will be taken from the built-in Gradient list.
Starting engine 8.08 Indexed Gradient has the same algotithm options than 13 Main Gradient.

• Linear:
  Input values maps to gradient colors using a linear ramp. 'Scale' sets the ramp slope.
  
• Linear mirror:
  Like previous mode but the gradient is mirrored for negative x.
  
• Logarithmic:
  Logarithmic uses 1+log(x+1/e) so that 0 maps to zero.
  
• Logarithmic mirror:
  Logarithmic Mirror uses ABS(x) to feed the logarithm. This mode corresponds roughly to the Logarithmic clut mode for scalar 1D output system.
  
• Dual Linear:
  This mode corresponds to the Balanced log clut mode for scalar 1D output system. It reverts the hues of the gradient for negative x;
  
• Dual Logarithmic:
  This mode corresponds to the Balanced log clut mode for scalar 1D output system. It reverts the hues of the gradient for negative x;
  
• Cyclic (sin):
  Cyclic sin uses a sine wave to loop the input. Thus the gradient progresses back and forth indefinitely. 'Scale X' controls the period and 'Offset' the phase. This mode corresponds roughly to the Cyclic clut mode for scalar 1D output system. In 8.08 the entire gradient is looped whatever the period.
  
• Cyclic (mod):
  Cyclic modulo uses a saw tooth wave to loop the input before mapping into the gradient colors. As a result the gradient progresses forwards only while looping so to achieve continuity you'll need that the first color matches the last color. 'Scale X' controls the period and 'Offset' the phase. In 8.08 phases are adjusted so that first instance overlaps the non looping mode.
  

ArtMatic script function :Shaded_color

parameters :
A : Red (0.0 : 1.0)
B : Green (0.0 : 1.0)
C : Blue (0.0 : 1.0)
D : Contrast % (0.0 : 16.0) E9 options

discussion :
This component maps input value to a shade of the color defined by parameters Red,Green,Blue. or a shade of its complementary color. The parameter D 'Contrast' scales the input prior the luminance shading of the color. With Ramp the shading uses D*|x| while with Contrast the shading uses clamp(mix(1,x,D),0,1) meaning a value of 0 for D will means no shading takes place.

• Dual color (legacy):
  script call : Shaded_color.legacy
  Negative inputs maps to the complementary color while regions closing to zero are faded to black. The 'Contrast' parameter scales the shading symmetrically around zero.
  
• Single color (contrast):
  script call : Shaded_color.singlecolor
  brightness shading uses clamp(mix(1,x,D),0,1);
  
• Dual color (contrast):
  script call : Shaded_color.dualcolor
  Similar to Dual color but the 'Contrast' parameter scales the shading downward. At zero no shading takes place and the output is the constant color given by parameters (A,B,C).
  
• Dual Auxcolor A (contrast):
  script call : Shaded_color.dualcolor_auxA
  Uses Aux Color A for negative x instead of complementary color.
  
• Dual Auxcolor B (contrast):
  script call : Shaded_color.dualcolor_auxB
  Uses Aux Color B for negative x instead of complementary color.
  
• Dual color ramp:
  script call : Shaded_color.dualshade
  Uses Aux Color B for negative x instead of complementary color and uses black to shade region near zero x. brightness shading uses uses D*|x|
  
• Triple color ramp:
  script call : Shaded_color.tripleshade
  Uses Aux Color B for negative x instead of complementary color and uses Aux Color A instead of black to shade region near zero x. Practically it gives you a 3 color ramp as a procedural gradient. brightness shading uses uses D*|x|
  

ArtMatic script function :Monochrome

parameters :
A : Red (0.0 : 1.0)
B : Green (0.0 : 1.0)
C : Blue (0.0 : 1.0)
D : Contrast % (0.0 : 2.0) E9 options

discussion :
Monochrome ramp, available starting E9, returns a monochromatic gradient function of x with a color ramp ranging from black to "color" to white, "color" being set by parameters.
The contrast controls the slope of the gradient, typically by multiplying input x before mapping to the gradient;

discussion :
13 Multi Perlin noise returns a 3D Vector of Multi Perlin noise with different phases for each components. It can be seen as a triple 11 Multi Perlin noise function. As with the 11 version the "Octaves" parameter controls the amount of higher frequencies additions and the 'Roughness' parameter the fractal dimension of the resulting noise. Values are balanced and can become negatives so when using it as a random color generator you will need to scale and offset the values.

ArtMatic script function :Linear_motion

parameters :
A : Direction x (-1.0 : 1.0) E9 options
B : Direction y (-1.0 : 1.0) E9 options
C : Direction z (-1.0 : 1.0) E9 options
D : Speed (-50.0 : 50.0) E9 options

discussion :
"Linear motion" provides a 3D linear motion akin to the 12 Linear motion tile when input is connected to time (w) or z input in 2D systems. The direction is given by the "Direction" vector parameter that will be normalised internally. Use (0 ,-1,0) to move upward for example. The 'Speed' parameter scales the input time. When negative, motion will proceed backward. The motion is at constant speed if the input is linear. The resulting position has to be added to the target coordinates to actually move it, usually with a packed 3D vector add like Packed RGB Add or better Packed Vector Maths when the target is a 3D object.

ArtMatic script function :Circular_motion

parameters :
A : Radius (0.0 : 100.0) E9 options
B : Angle oX (-180.0 : 180.0) angle in degree
C : Angle oZ (-180.0 : 180.0) angle in degree
D : Speed % (-50.0 : 50.0)

discussion :
When the input is connected to time (w), the result is a circular motion in 3D. With angles oX and oZ at zero the circle is on the XZ plane. You may rotate the circle plane with the 'Angle oX' and 'Angle oZ' parameters (in degree). The 'Radius' sets the radius of the circle.The 'Speed' parameters scales the input time. When negative, motion will proceed backward.
The motion position produced by Circular motion has to be added to the target coordinates usually with a Packed Vector Maths tile when the target is a 3D object.
The tile has the options to interpret the radius in various units.
Examples : Libraries/Components demo/Motion3DMetaballs.artm

ArtMatic script function :Random_motion

parameters :
A : Radius (0.0 : 100.0) E9 options
B : Speed % (-50.0 : 50.0)

discussion :
This component creates continuous random 3D motion when the input is connected to time (w). 'Radius' sets the radius of the motion and 'Speed' parameter scales the input time. When negative, motion will proceed backward. The random motion path is generated using a 1D vector valued (3D) perlin noise function.The motion position produced by Random motion has to be added to the target coordinates usually with a a Packed Vector Maths tile when the target is a 3D object.
The tile has the options to interpret the radius in various units.
Examples : Libraries/Maths/Functions plots/RandomMotion3D.artm

discussion :
Timeloop Interpolator is a utility that makes creation of seamless loops easy.
It outputs 2 overlapping cycling ramps in first 2 outputs with a blending function in third output (z). The blending function shall be used to fade whatever the 2 cycling ramps controls so that looping is continuous. Usually you will use a 31 interpolation tile to blend the 2 functions with z controlling the interpolation like 31 z Blend and the Timeloop tile will be connected to time. If the function to loop is RGBA use Packed z Blend and pass z to the alpha input. The looping take place over the given period so set the animation time to an integer multiple of the period to have 1 or several loop instances.
With Timeloop Interpolator you can create continuous periodic signals with anything as well as seamless motion loops.
Examples : Libraries/Animated Loops/FiberWaves Loop 16.artm Libraries/Animated Loops/Gamma Clouds PanX.artm Libraries/Maths/Periodic fractal signal.artm

discussion :
Compiled Trees are groups of tiles that can be used in place of single tiles as a kind of macro or subroutine.
13 CT can hold any 1 input / 3 ouputs tree that can be seen generally as a 3D vector valued 1D function. In particular 13 CT will often be used to output an RGB color derived from elevation or time, or to define a 3D motion path (3D parametric curve). Select a 13 tile and use Tree menu : New compiled tree to create a new CT from the selection (or type 'n' key).
With E9 you may also create a 13 CT using ArtMatic script language (Tree menu : New CT as text ) and directly type the fonction you want. For example it could be a procedural color gradient function of input like :
vec3 va = color(x,x^2,x^3);
To save a CT on disk to use the function elsewhere use Save compiled tree from the Tree Edit menu.
You may also copy and paste the entire CT by using Copy Tile and Paste Tile from the Edit menu.
You may iterate the tree by "Iterations" number when the tree contains an Iterations tile to modify and accumulates various values. "Scale" provide an optionnal scaling of outputs and is set at 1 by default (no scaling).