//----------------------------//
ArtMatic 4 in 4 out components
//----------------------------//

44 components are generally used to process RGB+Alpha or 3D space + Alpha information (Remember Alpha can hold (channel/elevation/DF field). They can be quite similar to 33 or 34 components. The output is generally of the same type as input. In this chapter, the left three inputs and outputs may be called either x y z or RGB. The fourth input and output may be called either alpha or w. In general we use X and Y capital case to refer to vector values and x y lower case to refer to scalar coordinates.
Some 44 components can be useful for modifying the RGB with the alpha channel value to implement various shaders like Alpha Fade or Alpha gradient. In many cases, the fourth input is passed through to the fourth output without change.
A bunch of 44 components serves as transforming a 3D space while maintaining a space scaling information in w as in the S-Space cases.

An essential in-depth discussion of ArtMatic structures Trees and components is found in ArtMatic Designer References and in Building trees.

discussion :
Scale inputs (x,y,z) using parameter A, and independently scale and offset the fourth input(w/alpha) using B and C. Infinity passes through unchanged.
'Scale xyz' multiplies the (x,y,z) inputs which is often a color. Value above 1 will brighten the color before passing it out.
'Scale w' multiplies to the (w/alpha) while 'Offset w' is added to the (w/alpha). Options (ArtMatic engine 8.06): 'Pass infinity' and 'Discard infinity'. Discarding infinities might be necessary to avoid discontinuities in iterative fractal shaders or to discard the implicit infinity masking. When 'Discard infinity' is set incoming infinities in RGB are shaded with the Depth cue color.

• Rotate 3 axes :
  
• Rotate yz(oX) & Offset z & x
  
• Rotate xz(oY) & Offset x & y
  
• Rotate xy(oZ) & Offset y & z
  

discussion :
Apply a Smooth clamping function to the alpha channel (fourth input) and pass through the other channels unchanged.'Roof level' has to be higher than 'Floor level'. See also the 11 Smooth Clamps component. The output is clipped to a valid color range (i.e. no negative values are passed out). Infinities in RGB are shaded with the Depth cue color in any cases.
Options 'Pass infinity' and 'Discard infinity'. When 'Discard infinity' is set infinity in alpha are mapped to -1. Discarding infinities might be necessary to avoid discontinuities in iterative fractal shaders or to discard the implicit infinity masking.

discussion :
Scale the space uniformly and send out an adjusted scale value in output 4. This component takes a 3D space (xyz) plus a scale value as its inputs (such as the values generated by the 34 S-Space Scale component. The output is the scaled space (from the xyz outputs) and the fourth input (S) multiplied by the 'Scale' parameter value. In other words it outputs the vector (Scale*x,Scale*y,Scale*z,Scale*S).
The scale 'S' value is important for DFRM trees that distorts space to make sure that the system converges correctly ( Divide the Distance field value by the S-Space scale 4th output).
Learn more about DF modeling in Building 3D Objects : DFRM guide.

• Scale & Offset :
  
• Abs & Scale & Offset :
  
• Space inversion :
  Similar to the 22 Complex Inverse component. Inputs (x,y,z) AND S are divided by length(x,y,z)2. Parameter options : Radius 1, Radius Pi, Radius Pi2, Radius 16.Similar to the 22 Complex Inverse component. Inputs (x,y,z) AND S are divided by length(x,y,z) squared.
  Parameter options: Radius 1, Radius Pi, Radius Pi2, Radius 16.
• Spherical fold :
  Reflect the space between two spheres of Radius A and B where A and B are the values of the parameter sliders A and B.
• Sphere reflection :
  
• Mandelbox transform :
  
• Mirror N-Fold xy & Spherical fold :
  Options: N-Fold 3 through 20. A mix of planar rotation symmetries with spherical folding.
• Mirror N-Fold xz & Spherical fold :
  Options: N-Fold 3 through 20. A mix of planar rotation symmetries with spherical folding.
• 3D N-Fold oY oX :
  Two planar rotation symmetries around they given axis.
• Tetra s-inversions :
  
• Cross s-inversions :
  
• Kleinian Box s-inversions :
  Spherical inversion sets.
• BoxFold & s-inversions :
  


• Sierpinsky Tetrahedron :
  45° mirror transform that converges to Sierpinsky Tetrahedron fractals when iterated.
• Sierpinsky Octahedron (x) :
  45° mirror transform that converges to Sierpinsky Octahedron fractals when iterated.
• Dodecahedron Mirror(z+) :
  
• Octahedron Mirror (xyz+) :
  
• Box Mirror Tower (z+) :
  
• Saw Plane (xz) :
  Infinite mirror saw and scaling in 2D on the xz plane.
• Saw Space
  Infinite mirror saw and scaling in 3D. When iterated with rotation and offset, Saw Space creates interesting fractal textures and can be used to modify other objects.
• Boxodron (x+) :
  
• Pyranodron (yz+) :
  
• Pyrabulbodron (yz+) :
  

discussion :
This component reflects the space around a sphere. The scaling is non-linear; so, make sure to use the s-output (the fourth) to divide the DF amplitude at the end of the tree to avoid convergence problems. S-Sphere Invert+offset is typically used in conjunction with the S-Space Scale component.

Example: The component's s-output needs to be used to scale the DF object field. In this example, the compiled tree creates a color DF object (RGBA). The input is a 3D space in the xyz inputs and a scale value in the fourth input. The output is a 3D space plus a scale value :

discussion :
This component creates a perspective distortion of the space and is useful for deforming DF objects. As with S-Sphere inversion, you should use the s-output to scale the DFRM object's amplitude (as shown in the S-Sphere Inversion explanation) in order to make sure the convergence is accurate in ArtMatic Voyager.
The input is a 3D space in the xyz inputs and a scale value in the fourth input. The output is a 3D space plus a scale value.
S-Perspective distort is typically used in conjunction with the S-Space Scale component.

Learn more about DF modeling in Building 3D Objects : DFRM guide.

discussion :
Polar space transform with a scale factor to compensate for dist estimate distortion. This replaces the one that was in 33 spaces. It has the following options to use oY or oZ as the center axis and to use or not a symmetric mapping. S-Polar space is typically used in conjunction with the S-Space Scale component.

• "orient oY ,use x",
• "orient oY ,use |x|", //absolute value of X
• "orient oY ,use -|x|",
• "orient oZ ,use x",
• "orient oZ ,use |x|",
• "orient oZ ,use -|x|",

• None : Negative or zero alpha values will set the RGB to black (previous behavior).
• Use depth cue color for alpha : Negative alpha values will be mapped to theDepth cue color (first auxiliary color). You need to be in RGB Multi mode to have the transparent (negative alpha ) regions be opaque and visible.
• Use aux color A for alpha : Negative alpha values will be mapped to the Aux color A.You need to be in RGB multi mode to have the transparent (negative alpha ) regions be opaque and visible.

• Linear multiply :
  In this mode w (the alpha) is multiplied with the RGB directly.
• Power multiply :
  In this mode w is raised to the parameter 'power' before the RGB multiplication.
• Gate multiply :
  In this mode the alpha is premultiplied by 100 to have a very sharp transition between opaque and transparent regions. When used with "Use depth cue color for alpha" option and the RGB Multi mode you will have transparent regions (alpha<=0) colored with the depth cue color.

discussion :
44 Alpha Fade uses the alpha channel (w) to blend the Depth cue color with the RGB channels. 'Feather' parameter controls the rate of the blending : use low value for a sharper transition. When alpha/w is a distance the Exponential algorithm will yield nicer results.
You may use this component to implement a customized depth cuing or to fade a texture into a constant color. The incoming alpha/w is returned unchanged. When alpha is unneeded you have the 43 w Color Fade which provides the same service.

Options (ArtMatic engine 8.06): 'Pass infinity' and 'Discard infinity'. Discarding infinities might be necessary to avoid discontinuities in iterative fractal shaders or to discard the implicit infinity masking. When 'Discard infinity' is set incoming infinities in RGB are shaded with theDepth cue color.

• Linear (legacy) :
  'Amount' is a multiplier applied to the blending alpha channel. When 'Amount' is positive, the auxiliary color appears where the alpha channel's value is >=0 at a rate depending on 'Feather'. When the value is negative, the auxiliary color appears where the alpha channel is negative.
  
  
• Exponential+ :
  In this mode fading to depth cue is governed by an exponential which provides more realistic results for haze when w input is the z distance, as provided by ArtMatic 3D objects components. 'Level adjusts' offset moves the point in depth (z) where depth cueing starts.
• Exponential- :
  Same as previous but reverses the orientation of fade. Use it when the "far" z value are increasing on negative axis.

discussion :
Alpha gradient shades the w input alpha channel with the main Gradient and blend it with the RGB channels. It is similar with the 43 RGB mix but with an alpha output. The alpha channel is also passed out unchanged through the fourth output. 'Amount' controls the mix of the RGB and Alpha/Gradient channel. 'Scale X' and 'Offset' controls the mapping of w to the Gradient : Gradient( Scale* w + Offset). See also 13 Main Gradient if you need more control over how the mapping is performed.

discussion :
Adjust the HLS (Hue, Luminance/Lightness and Saturation) of the RGB image passed into the component. This component is very convenient for adjusting the HLS of an RGB image without having to convert color spaces and can be used with straight RGB images (no alpha) by leaving the fourth input unconnected. Sophisticated color processing effects can be created by adjusting HLS. The output is clipped to a valid color range (i.e. no negative values are passed out). TheDepth cue color is used where the output value is infinity.
The Alpha channel is left unchanged except infinities are discarded and mapped to a alpha transparent value. If you need infinities to be passed on use the 43 w Color Shift or the 33 Color Shift versions.

discussion :
Adjust the color contrast of the XYZ inputs (which are treated as RGB), and scale and offset the fourth input. Parameter A adjusts the color contrast of the RGB channels. B and C scale and offset the fourth input (w/alpha) and have no influence on the RGB input/output. Contrast & offset always discard infinities in w and maps infinities in RGB to theDepth cue color.

discussion :
44 Color Controls # provides the same services as the 33 Color Controls # and passes the alpha channel unchanged.

• Colorize
  
• Color Floor
  
• Offset & clip
  
• RGB Contrast
  
• Multiply
  
• MonoChrome
  
• Invert
  
• Power Saturation
  
• Clip and blend
  
• Color infinity & discard
  
• Remap with Gradient
  

discussion :
This component is an RGB + Alpha component for creating ArtMatic Voyager terrain-based cityscapes. It provides the color texture for building exteriors and an alpha output that can be used for special effects (like embossing) in ArtMatic Voyager. This component generally provides the color shading for buildings created with the 24 City Maps # (xziy) component and has a special interpretation of the input values.

The inputs are (from left to right):

• x and z. the ground co-ordinates (latitude and longitude)
• i: texture index. Index value that selects the color pattern to use. The color texture for the buildings is determined by the "i" input and not by the ground position. The "i" input will usually be provided by 24 City Maps, but you may pass in a constant (to select a particular texture) or manipulate "i" to select different textures for the same buildings.
• y: elevation.

• City Texture Set A #
  
• City Texture Set B #
  
• City Texture Set C #
  
• City Classic Set #
  

discussion :
DF Fractal Texturer # modulates existing DF volume with DF volumetric color fractal algorithm. Such algorithm avoid additions that distorts the distance estimation and uses a combination of smooth boolean operator to scult details to maintain an exact distance estimate (DF). The original DF volume is passed in input 4 and should be a packed4 CT if the volume already has a color. The resulting RGBA contains a true DF field in a and its rendering should be optimum in all aspects. Colors defaults are specific to each algorithms but usually are aimed for natural rocks shades.
The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• MF balls:
  sculpt the volume with randomly placed balls at various frequencies.
• MF boxes:
  sculpt the volume with randomly placed boxes at various frequencies.
• MF strata:
  uses boxes split horizontally to obtain a stratified rock aspect.
• MF saucers:
  uses saucer shape as accumulating form.
• MF saw rocks:
  uses boxes split with saw waves as accumulating shape.
• MF pipe rocks:
  uses cylindres split with saw waves as accumulating shape.
• MF spongeA:
  Carves the volume using randomly placed balls at various frequencies.
• MF spongeB:
  Carves the volume using randomly placed saw balls at various frequencies.

discussion :
Takes an RGBA input and assuming Alpha is a balanced DF field Line Shader creates and shades contour line at the Alpha values zero crossings while using a background flat color for negative A values. So practically it is a "contour" shader and will transform any DF functions or any balanced surfaces into a 2D graphic drawings.

The 44 Line shader is similar to 11 line and 21 line and can accommodate high resolution outputs. (See 21 Line discussion). Negative A input values are shaded with the background color taken procedurally from the "Background color ramp" parameter. The color of the Lines (default black) are taken procedurally from the "Contours Color Ramp" parameter. When negative it returns a ramp from white to black (0). When positive it cycles the hues from dark to bright.

44 Line Shader provides an easy way to get a 2D graphic view of a 3D object slice. Here for example is a rendering of almost the same system in 3D and in 2D the only difference being the 2D version uses the 44 line shader at the output of the tree:

Examples:


ManyOverlay DF 3D view in Voyager (Voyager Examples/DF modeling/Geometry/Grafic ManyOverlay DF.vy)


ManyOverlay DF LineShaded

discussion :
2D Motion Pict Atlas is a powerful and efficient animation tool. It offers an alternate fully controllable way of displaying the atlas cells using a 1D vector function that will provide each cell position and orientation of the list, in short the motion function usually a 11 Compiled Tree (CT). The component mixes all Atlas cells images at once using the precomputed array of positions using alpha-compositing, with the last list element going topmost. All cells are displayed at least once when "cycles" is 1 and the number of element would be the square of images per row times "cycles". Thus the number of elements is given by Atlas size * cycles. It can become quite large : if the atlas array is 16*16 you can go up to 32 cycles of 16*16 which is 8192 elements.
The positions vectors are precomputed once per frame (instead of for each pixels) : the connected motion function is called by Motion Pict Atlas with an internally computed input defined as :
-cell index / step divide + time
Time is added only when the motion function is connected to Global Input Matrix Time (w). Typically if you need positions to move along the path over time use w input. Otherwise you may want the motion function to be only dependent on the atlas index and animate the motion using parameters keyframing within the motion function. Note that even if the CT is not connected to time it is still possible within the CT to connect a particular component to global time. In that case you can control how much time and absolute index affects the final positions of each cell.
The "step divide" parameter control spacing over time of each steps and the bigger the less differences in position between cells.
Keep the "step divide" at 1 if the motion function needs just the cell index. The "cell size" parameter further scales each Atlas cell. The "Input index" selects which source Atlas image to use in the image inputs layers.

The supported 1D vector function can be :
-A 12 motion tile or CT connected to input 3 and 4:
In that case the only the cells positions are defined and the 1D vector function can be component like Circular motion (or an equivalent CT with 2 outputs)


Ring of flowers using a circular motion (ArtMatic Designer CTX/Libraries/PictAtlas/)

-A 11 packed CT connected to input 4:
The output of packed4 CT will be interpreted as a (x,y,z,w) vector where xy controls the position of the cell and zw the rotation (in radians) and scale (0 will be 1 as scale is set as exp(w)). CT with Packed 3 outputs are supported as well and will control only position(x,y) and cell orientation(z).
In this configuration input 3 is free and can be connected to Time or a Constant to further modulate the cell index.


Randomized spiraling butterflies (ArtMatic Designer CTX/Libraries/PictAtlas/)

In general the CT providing the position should be connected to the Time master input to Global Input Matrix Time (w) as other inputs will be ignored as the function is called internally from the 2D Motion Pict Atlas component once per frame.
See also 2D Motion_Path render discussion.

For more details about Atlas see the : Pict Atlas # discussion.

• Alpha compose (default):
  The various cells are composed on top of each others with their alpha channel and on top of the background color set by the Options preferences.
  The output alpha channel will be the maximum of all alphas.
• Additive:
  The various cells are added and the order has no importance so you can keep elements unsorted. The output alpha channel will be the addition of all alphas.
• Maximum:
  The maximum of RGB is taken and the order has no importance. The alpha channel will be the maximum of all alphas.
• Gradient Shaded:
  This mode uses the normal alpha compositing but multiplies each cell colors with the main gradient mapped over the cell indexes.
  The output alpha channel will be the maximum of all alphas.
  
  
  Pop and fall motion Gradient shaded (ArtMatic Designer CTX/Libraries/PictAtlas/Motion Letter Pop and fall.artm)
  

• Infinity (DC color) : use Depth cue color for background default color
• Black : use a black background
• White : use a white background
• Aux color A : use Aux color A for background
• Aux color B : use Aux color B for background


• Unsorted : Cells are displayed in the default order, the last one drawn frontmost
• Sorted by y :
  Cells are sorted in Y before display so the lowest appears frontmost.
  
  
  People sorted by y ensure a logical display order
  
  
• Sorted by size : Cells are sorted by size so that the biggest appears frontmost

discussion :
DF quantizer allows to reinterpret a DF volume using accumulated elements. The volume to be quantized has to be provided in input 4 either as a direct DF function tile or as a scalar or packed RGBA Compiled Tree for more complex volumes.
For each unit grid an element is generated if the middle is inside the given volume. If the volume has no color the element will have a random color otherwise it will take the volume color at its center position. The "Style" parameter usually controls the jittering for random elements. When "Style" is above 0.75 elements becomes negative and disappear progressively.

Example in ArtMatic Voyager CTX/Voyager Examples/VY15 Examples/Geometry/

• box:
  The element is a cube, centered to unit grid.
• balls:
  The element is a sphere, centered to unit grid.
  
  
  Original volume
  
  
  DF quantizer random balls volume
  
  
• random box:
  The element is randomized cube in size and position
  
  
  DF quantizer random box volume
  
  


• legobox:
  The element is a lego cube. Special effects like Lego can be achieved using legobox.
  
  
  Ring and sphere legobox effect
  
  
• random balls:
  The element is randomized sphere in size and position.
• random saucers:
  The element is randomized "saucer" shape.
  
  
  Ring and sphere random saucers
  

discussion :
Memory Fractal Add accumulates the color by first shading the RGB with the alpha value (zero and negatives turns black) and adding the shaded color with a weight that depends on 'power slope' parameter. At 1 the sum has an equal weight for all iterations. 'power slope' below zero will fade higher iterations while values above zero will fade out the starting iterations. In many fractal systems when iterations scales the frequencies upward the amplitude is scaled inversely. So to maintain this relationship between frequency and amplitude (1/f noises means amplitude is related to inverse frequency) you will typically set the power slope to 0.5 if the frequency is scaled by 2. The 'Sum gain' parameter scales the overall result.
"Memory Fractal Add" discards infinities.

See also the 1D version 11 Memory Fractal Add .

discussion :
Use the alpha channel to adjust the pixel brightness before an iteration is added to the accumulated image. Unlike with Memory Fractal Add the weight is constant and depends on incoming alpha value (4th input ) scaled by 'Alpha Contrast' and offseted by 'Alpha Offset'. In other words the color are shaded with the alpha value before being accumulated.
See also 44 RGB * alpha for alpha brightness shading.
"Memory Weighted Add" discards infinities.

discussion :
Memory w Logic is used to accumulate RGBA streams using logic operations in the context of iterated systems. It has great application for recursive graphics, fractals and multi-layer texturing. Memory w Logic can be used as well for color images with alpha than color-textured DF fields (with the field value being in the alpha channel).
This component can be used with the iteration component when the tile is in feedback mode to accumulate all iterations with a memory component. When creating 3D fractals, it is often useful to mix the various iterations levels together instead of rendering just the the limit set which can be just a very fine dust.

Options (ArtMatic engine 8.06): 'Pass infinity' and 'Discard infinity'. Discarding infinities might be necessary to avoid discontinuities in iterative fractal shaders or to discard the implicit infinity masking. When 'Discard infinity' is set incoming infinities in RGB are shaded with theDepth cue color and alpha is set to transparent.

Notes: Xor, Overlay and Underlay expects the w alpha value to be balanced (negatives and positives).

• Weighted max :
  Assign a weight to the input RGBA prior the MAX logic compare. Parameter D (Blend With Last) offers control of the blending between iterations. It is especially valuable when doing fractal iteration. When the parameter is set to the maximum, only the last iteration will be visible leaving only the limit set when working with a fractal.
  
  
  Weighted max - Nfold snowflake uses Weighted max to accumulate objects instances within iterative fractal transforms.
  
  
• Maximum :
  Parameters : Smoothness , Level
  Implement a straight a straight maximum. Max is the logical operation equivalent of Union. 'Level' adjust the level of incoming alpha For each pixel, compare the alpha (w) input value to the stored image's and keep the pixel whose w value is largest. In order to be compatible with DF, the component is initialized to -infinity. You may use it with recursive DF object as an Union logic operator (see 24 Packed Logic)
  
  
  Maximum - Dsks accumulated with the Maximum logic.
  
  
• Minimum :
  Parameters : Smoothness , Level
  Implement a straight minimum. Min is the logical operation equivalent of intersection. 'Level' adjust the level of incoming alpha For each pixel, compare the alpha (w) input value to the stored image's and keep the pixel whose w value is smallest. In order to be compatible with DF, the component is initialized to +infinity.
  
• Xor :
  Parameters : Smoothness Xor sets the intersection of X & Y to Negative. Negative alphas are set to Aux color A. You may use it with recursive DF object as an Xor logic operator (see 24 Packed Logic)
  
  
  Xor - Disks accumulated with the Xor logic.
  
  
• Overlay :
  Y shape goes above X shape : successive iteration masked elements will blend above previous elements. Negative alphas are set to Aux color A.
  Parameters : Smoothness, Smooth Power:
  As with weighted max 'Smooth Power' scales the smooth value according to iteration level (scaled smooth= smooth/pow(Smooth Power,iteration level). When power is 1 the smooth value is constant. When power is 2 the smooth value gets smaller for higher iterations, while when power is less then 1 smooth gets bigger for higher iterations. Smoothness with Smooth Power can dramatically change the result and can create blur or subtle shadings effects for iterative systems.
  
  
  Overlay - Disks accumulated with the Overlay logic. Notice the contours are preserved at the intersections unlike with the Maximum logic.
  
  
• Underlay :
  Y shape goes below X shape : successive iteration masked elements will blend below previous elements. Negative alphas are set to Aux color A.
  Parameters 'Smoothness and 'Smooth Power' works like described above.
  "Underlay" is a particularly useful for iterative fractal "Orbit trap" shading as illustrated by the example below:
  
  
  Underlay mode shaded Julia Set (Libraries/Fractales/Mandel OrbitTraps Seed.artm).
  

discussion :
Memory w Maths accumulates RGBA streams using various mathematical functions. Infinity are preserved and incoming infinities in RGB are shaded with theDepth cue color and alpha is set to transparent.
See also the scalar implementation 11 Memory Maths #

• Difference :
  Subtract each iteration's pixel RGB values from the accumulated image's and returns the Absolute value of the result. Note that since ArtMatic engine 8.06 the resulting Alpha channel is set to the 'smooth' maximum of incoming Alphas.
• RGB Multiply :
  Parameters: Smoothness, Gain, Blend
  Multiplies RGB on positive inputs and combine the alphas using a smooth max. Blend mixes the result with the incoming RGB. The gain adjust the multiply amplitude.
• Morph :
  Parameters : Smoothness
  Accumulates the RGBA values using exponentials to blend the alpha values and mixes the colors accordingly. The morph equation is log(exp(x*K)+exp(y*K))/K where K is a smoothing factor. K is derived from the 'Smoothness' parameter. Morph produces a similar result as smooth Max but with a much smoother and natural blending. note: Morph works best with balanced alpha.
  
  
  A fractal using Memory Morph to accumulate various iteration levels.
  
  
• Alpha Blend :
  Reimplemented in ArtMatic engine 8.06, this algorithm compose successive RGBA inputs using 'Blend Slope' to controls the fading direction. When in middle (0.5) all instances are equals and Alpha Blend behave like standard alpha compositing. When zero higher iterations are faded and reversely at 1 earlier iteration are faded. 'Color Blend' parameter controls how much input color is faded into a constant color using Aux color A. Leave it at zero for no color fading.
  'RGB Gain' adjust the incoming RGB brightness.
  
  
  Alpha Blend with slope above 0.6
  
  
• Alpha Blend Max :
  Same as above but the resulting alpha will be the maximum of all incoming alpha. This leaves an opaque trace of all iterations.
  Example : Libraries/Components demo/MemoryWMAlphaBM
  
  
  Alpha Blend Max with slope above 0.6 and Color Blend at 1.
  
  
• DF Union Blend :
  This mode is suited for iterative accumulation of DF colored objects, often used in fractals. When parameter C 'Max Alpha Blend' is at 1 the resulting alpha/DF will be the maximum of all incoming alpha/DF. Lower value will shrink the thickness of early DF values, enhancing the latest, usually thinnest, features.
  The 'RGB blend' parameter allows to control how much new RGB data is blended into the final sum. Low value will enhance the first RGB values while values close to 1 will give more importance to the latest iterated RGB values.
  
  
  DF 3D fractal using 'DF Union Blend'
  
  

discussion :
Memory w Alpha accumulates RGBA streams in iterated systems using alpha channel compositing (alpha value sets the blending amount of incoming RGB with background, zero and below being transparent, 1 being opaque). The 'Start color' sets the starting background color from a procedural color ramp and is visible when the output alpha is ignored in final shader like in RGB Multi Shading mode. Infinities are discarded : incoming infinities are set to 'Start color' with transparent alpha. The output alpha is computed as the maximum of incoming alphas.
Keep 'feather' at 1 to have a strict alpha blending (alpha values are not scaled).
'Alpha Level' offsets the alpha values for each iterations.
Memory w Alpha has great application for recursive graphics, fractals and multi-layer texturing. For more control on the order of iterative layers compositing you can use the 44 Memory w logic # component with Overlay or Underlay modes as described above.

discussion :
This is a very powerful component that mixes 3 RGBA (or Color/DFRM) inputs using the fourth input to control the mix. This component is generally used with an index value (like the one created by the 24 xyza components or 34 UVID Sweep Volumes) as the fourth input. You may also generate this index with the special logical function 32 Indexed Logic tools # component.
This allows composite objects to be created with different color textures for different parts of the object. Additionally, auxiliary colors can be mapped to some values depending on the parameter option settings.

The output is determined by the index (fourth input) value. Input A is used where the index value is between 0 and 1. Input B is used where the the index is between 1 and 2. Input C is used where the input is between 2 and 3.


44 Packed Index Mixer is used to provide different color textures for different tiles.

Depending on various Parameter Options indexes that are outside the range can be mapped in different ways :

• Default
  - in this mode index values above 3 are mapped to the parametric color defined by Red Green and Blue. Also, -1 and -2 are mapped to the 2nd and third auxiliary colors.
  Inputs over or equal 5 maps to the depth cue color since engine 8.08.
  
• Clamp to 3
  - in this mode, values are clamped to the range from 0 through and including 2.
• Modulo 3 (loop)
  - in this mode, the index values are looped from 0 to 2. It can be used with a UVID (see 34 uvid Sweep_Volumes) index to mix several textures and all XYZA tiles (where Z is a texture index).
• modulo 3 with DC (depth cue color)
  
• modulo 4 with DC (depth cue color)
  Both modes maps input >= 5 to the depth cue color and uses a modulo 3 or 4 for the rest of the inputs indexes. With modulo 4 the fourth color is the parametric color of the tile. Inputs over or equal 5 maps to the depth cue color : xyza semiregular patterns and other tiling components often use the value of 5 to separate tiles.

usage :
Select a 44 tile and use "New compiled tree" to create a new CT from the selection (Tree Edit menu or type 'n' key).
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.
44 compiled trees can be made recursive with the option "allow Feedback" ON. That means outputs of the CT will feed inputs after the first iteration. In that case the result will be a recursively transformed 4D space or a transformed 3D space with a packed RGBA stream on output 4. When the option is turned off you will need a memory component at the end inside the CT to accumulate the results. (see Memory w Logic # discussion).
The fourth input can also be a packed RGBA stream. In that case the first 3 input can just carry the space coordinates that are transformed recursively while the 4th accumulates the RGBA data. This setup allows to create complex colored 3D objects like trees, complex plants or 3D fractals.
Even without recursion, the advantage of using 3D Space + packed RGBA input/output is that you can mix the output with other similar CTs to build up complex plant structures. For example, a first 44 CT might create the first level of branches while a second will add a different secondary branching structure and a third would add the leaves. Each CT will both transform the space for the next and add something in the fourth channel.