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

• Floored+Shaded:
  The polygon elevation is clamped to zero to avoid negatives. Color hues are shaded (color fades to black at zero) with the elevation/alpha.
  
• Balanced+Shaded:
  The polygon elevation continues in negatives. Color hues are shaded (color fades to black at zero and below ) with the elevation/alpha.
  
• Balanced+frame shaded:
  The polygon elevation continues in negatives. Color hues are shaded with the elevation/alpha with an additional frame at the zero crossing.The frame uses the depth cue color.
  
• Balanced+Unshaded (DF mode):
  The polygon elevation continues in below zero with a strict relation size/amplitude that makes the elevation works as a DF profile. No shading takes place. In this mode the component can be used as a 2D colored DF profile in 3D modelling. See the DFRM guide :Modelling technics.
  

discussion :
This component is similar to color line but has diffuse edges that give a 3D or glow-like appearance. See also the 34 Color Neon Line version.

discussion :
This RGB+Alpha color shader returns the input picture's (or movie's) alpha channel if there is one in 4th output. For a general guide to Pict/Movie components, see the Using Pictures and Movies chapter of the reference manual. The image can be regulary Tiled or Jitter-tiled depending on the Algorithm choice. At "Size" parameter 1 the image fits the canvas at default zoom level (home button). This component only needs to be used if the input pict/movie has an alpha channel or for its special tiling options.
In ArtMatic Engine 8.5 all color image components have the 1.5 RGBA Picts Options set.

• Tiling regular:
  Use the "Tiling" parameter to spread the tiles. At zero no tiling takes place and the image is centered.
  
• Jitter Tiling:
  "Jitter Tiling" allows to overlap and fade randomized instances of the picture. This can create non periodic random textures using prerendered pixels. "Randomise" parameter randomises the position, scale and rotation. When the "Randomise" parameter is at zero the images keep the same orientation.
  

discussion :
Pict Atlas # uses an array of images to handle many pictures at once. The size of the array can go from 2*2 to 16*16. By convention if a pict file name includes "atlasXX" and X is in the range 2-16 it will be interpreted as a valid Atlas and the cell size will be derived from that number.You can store a lower resolution version using "atlasXXTN" to speed up browsing and previewing of ArtMatic trees using Atlases as the Atlas file can be quite large and its not necessary to load the full size version for a small preview. The size of each Atlas cell is not necessarily square but must be an integer divider of the file size. With a 16*16 Atlas image you can use up to 256 images for a single input channel set by the "Input index" parameter (The Atlas can be imported in any input channel slot). Various algorithm are available and are listed below.
If you need other layout you can control and animate the placement of each cell with the 44 Motion Pict Atlas component.
Other layouts are available in 2D and 3D with the Atlas related algorithm in the 2D Architectural # component.

In ArtMatic Engine 8.5 all color image components have the 1.5 RGBA Picts Options set.
Examples can be found in ArtMatic Designer CTX/Libraries/PictAtlas/ folder.

• Single cell:
  script call : PictAtlas.single
  A single image is displayed and you can change it with the Tile index.The effective image will be the Tile index % total images. So if the Atlas contains 3*3 picts, it will be modulo 9. You can put anything in an Atlas. This can be used with text comments to build a tutorial entirely in artmatic for example.
  
• Random cell array:
  script call : PictAtlas.random_array
  Display an infinite array of randomly chosen image from the atlas. The parameter "Density" sets the space between tiles by scaling each tile. The Tile index influence the amount of randomisation. At zero the array will be ordered.
  
  
  
  
  
  
• Voronoi random cells:
  script call : PictAtlas.voronoi_random
  Display randomly images from the atlas in a jittered way. This works nice if the atlas images have an alpha channel as they can overlap. The texture produced is infinite.
  
  
  
  
  
  
• Voronoi density cells:
  script call : PictAtlas.voronoi_density
  Same as above but with control of density. The parameter "Density" scales each voronoi tile.
  
• Voronoi random oriented :
  script call : PictAtlas.voronoi_density_random
  Same as above but each cell can be randomly rotated.
  
• Random cloud:
  script call : PictAtlas.random_cloud
  A local "cloud" of images. Needs Alpha mask as well for best results.
  
• Random cloud sorted:
  script call : PictAtlas.random_cloud_sorted
  A local "cloud" of images with the images sorted by Y position so that lower images are displayed over. Needs Alpha mask as well for best results. "Cloud shape" controls the aspect ratio of the cloud.
  
  
  
  
  
  
• Rosace cloud A:
  script call : PictAtlas.rosace
  Atlas cells are disposed in a circle pattern where parameter "Spread" controls the overall radius and cell spacing.
  
• Rosace oriented cloud:
  script call : PictAtlas.rosace_oriented
  Same ase previous but cells are oriented outwards.
  
  
  
  
  
  
• Rosace rings oriented:
  script call : PictAtlas.rosace_ring
  Atlas cells are disposed in a twirling growing pattern.
  
  
  
  
  
  

discussion :
This component provides many different tiling algorithms, and like the other XYza components, the output is a a space transform from the two leftmost outputs, an index 'z' value from the third output and an alpha/elevation channel that delineates the tiles. Colors are derived from the index in z. In general the z index output is periodic with 3 discreet values. Color Regular tiles # shares the same tiling algorithms but outputs RGB+Alpha rather than XYza output.

While only 3 regular tilings are geometrically possible with one regular polygon (square, triangle and hexagonal tiling), by relaxing the regularity of the tiling many other tilings are possible. The Cairo tiling, for example, which has been used since antiquity is especially interesting with its pentagonal angles in the 18º version. Tile rotation is available (via parameter D) for some algorithms that changes the tiling pattern and tile shape. Such algorithms have an asterisk (*) in their names.

When mirror appears in an algorithm name, it means the coordinates are using mirror symmetries on the tile edges when sent from the tile XY outputs. 'Rotation' rotates the XY output coordinates but won't change the tiling structure.
The 3th output (z) is often used as an index fed into the 44 Packed index (w) Mixer to have different textures for each tiles.
The 4th output (a) can be used for 3D DF modelling when the option 'link amplitude to frequency' is chosen. In any case 'a' will hold each cell elevation/alpha mask where the edges are at zero so its possible to use 'a' for further contour shading with 44 RGB * alpha for example.

• Rectangular:
  script call : XYza_Regular_tiles.rectangle
  Parameter D 'Tile aspect ratio' changes the aspect ratio. Square tiling is obtained when 'Tile aspect ratio' is 0. Output z hold a non periodic random unique value for each cell.
  
• Unit Square:
  script call : XYza_Regular_tiles.unit_square
  Set 'Frequency' at 1 to get a unit square grid. z output is periodic with 3 values.
  
• * Square 45°:
  script call : XYza_Regular_tiles.square_45
  The 'Frequency' is scaled by sqrt(2) to align with the square grid when using same frequency.
  
  
  Square Tiling 45 with a slight tile rotation
  
  
  
• Triangles 2:
  script call : XYza_Regular_tiles.triangles_2
  Variation of the triangle tiling with only 2 z values.
  
  
• Triangles 6:
  script call : XYza_Regular_tiles.triangles_6
  Variation of the triangle tiling with 4 z values.
  
  
• * Lozenges:
  script call : XYza_Regular_tiles.lozenges
  
  
  Lozenge Tiling with a slight tile rotation
  
  
  
• * Triangles mirror:
  script call : XYza_Regular_tiles.triangles_mirror
  Same as Triangles Tiling but with mirror symmetries on the XY outputs coordinates.
  
• Hexagonal:
  script call : XYza_Regular_tiles.hexagonal
  The perfect Hexagonal regular tiling.
  
• Cairo 18°:
  script call : XYza_Regular_tiles.cairo_18
  
  
  Cairo Tiling
  
  
  
• * Cairo mirror :
  script call : XYza_Regular_tiles.cairo_mirror
  Using the 'tile rotation' you will blend from rectangles to pentagonal polygons. At 18° the classic Cairo tiling appears.
  
• * Square mirror 45°:
  script call : XYza_Regular_tiles.square_mirror_45
  Same as Square Tiling 45 degrees but with mirror symmetries on the XY outputs coordinates.
  
• * Octagonal mirror 45°:
  script call : XYza_Regular_tiles.octagonal_mirror_45
  Tiling produced by 8 rotating triangles in a 45° lattice.
  
• Decagonal Triangles:
  script call : XYza_Regular_tiles.decagonal_triangles
  Irregular tiling produced by 10 rotating triangles sharing the same center.
  
• * PolyCairo:
  script call : XYza_Regular_tiles.polycairo
  Using the same construction method as Cairo tiling but with a more complex polygon. Slide the 'Tile rotation' to observe emerging shapes.
  

discussion :
This component implements many interesting tilings that make use of two or more polygons. While the algorithms do not include all possible tiling, they include the most interesting ones. Several different foldings are provided for the beautiful Islamic star patterns.

For most algorithms, parameter A is Scale and scales the output space. However, for some algorithms, parameter A is Tile Spread. 'Frequency' sets the tiling frequency (the size of the tiles).'Rotation' rotates the XY output coordinates.

The z-output hold an index 'z' usually periodic can be used to assign colors or textures combining multiple tiling components. Possibilities are endless. Z-output is often used as an index fed into the 44 Packed index (w) Mixer to have different textures for each tiles.
When the option 'link amplitude to frequency' is chosen the 4th output (a) can be used for 3D DF modelling.
Example file : Libraries/Components demo/24 Tiling SR.artm

• Square & triangles:
  script call : XYza_SemiregularTiles.square_triangles
  Semiregular tiling composed with Squares & Triangles with 3 z index values.
  
• Square & triangles mirror:
  script call : XYza_SemiregularTiles.square_triangles_mirror
  Same as above but with mirror symmetries on the XY outputs coordinates.
  
• Hexagons & triangles:
  script call : XYza_SemiregularTiles.hexagons_triangles
  Semiregular tiling composed with Hexagons & Triangles using 3 z index values
  
• Hexagons,squares,triangles:
  script call : XYza_SemiregularTiles.hexagons_squares_triangles
  Semiregular tiling composed with 3 polygons: Hexagons, Squares and Triangles with 3 z index values.
  
  
  Hexagons, squares, triangles pattern'
  
  
  
• Hexagons,squares,triangles mirror:
  script call : XYza_SemiregularTiles.hexagons_squares_triangles_mirror
  Same as above but with mirror symmetries on the XY outputs coordinates with 5 z index values
  
• Squares & triangles B mirror:
  script call : XYza_SemiregularTiles.squares_trianglesB_mirror
  Alternate tiling composed with Squares & Triangles.
  
• Decagons & pentagons mirror:
  script call : XYza_SemiregularTiles.decagons_pentagons_mirror
  Semiregular tiling composed with Decagons & pentagons with mirror symmetries on the XY outputs coordinates and with 4 z index values
  
  
  Decagons + pentagons pattern'
  
  
  
• Islamic sixfold A:
  script call : XYza_SemiregularTiles.islamic_sixfoldA
  
• Islamic sixfold B:
  script call : XYza_SemiregularTiles.islamic_sixfoldB
  Based on the islamic interlaced star patterns with six branches. The overall geometry follows an hexagonal lattice. 'Tile spread' controls the size of each cell's pattern. All islamic patterns outputs 5 z index values.
  
• Islamic heightfold:
  script call : XYza_SemiregularTiles.islamic_heightfold
  
• Islamic heightfold 45°:
  script call : XYza_SemiregularTiles.islamic_heightfold_45
  Based on the islamic interlaced star patterns with height branches. The overall geometry is either on a square lattice or on a 45° lattice. 'Tile spread' controls the size of each cell's pattern.
  
• Islamic ninefold:
  script call : XYza_SemiregularTiles.islamic_ninefold
  
• Islamic tenfold A:
  script call : XYza_SemiregularTiles.islamic_tenfoldA
  Islamic star patterns with ten branches. The overall geometry follows an 36° lozenge lattice.
  
  
  Islamic tenfold algorithm.
  
  
  
• Islamic tenfold B:
  script call : XYza_SemiregularTiles.islamic_tenfoldB
  Islamic star patterns with ten branches and emerging pentagons. The overall geometry follows an 36° lozenge lattice.
  
  
  Islamic tenfold B. Pentagons are in violet.
  
  
  
• Islamic twelvefold A (hexa):
  script call : XYza_SemiregularTiles.islamic_twelvefoldA
  
• Islamic twelvefold B (hexa):
  script call : XYza_SemiregularTiles.islamic_twelvefoldB
  Islamic star patterns with 12 branches. The overall geometry follows an hexagonal lattice.
  
• Islamic twelvefold C (45°):
  script call : XYza_SemiregularTiles.islamic_twelvefold_45
  Islamic star patterns with 12 branches. The overall geometry follows an 45° square lattice.
  
• Islamic sixteenfold :
  script call : XYza_SemiregularTiles.islamic_sixteenfold
  Islamic star patterns with 16 branches and 8 branches. The overall geometry follows an 45° square lattice.
  
  
  Islamic sixteenfold algorithm.
  
  
  
• Pentagonal crystal mirror:
  script call : XYza_SemiregularTiles.pentagonal_crystal
  This irregular triangle pattern emerges from a set of 5 fold symmetries.
  
  
  'PentaCristal' pattern'
  
  
  

discussion :
XYza DF zones can be used in a similar ways than 34 jitter tiling # or 3D Repeats and Tile to instantiate a large number of DF primitives or graphics objects. It basically tiles the 2D space and depending on “sparseness” will mask or not an instance in the tile using the a (alpha) output. The shape of the mask can be square or circle depending on the chosen algorithm. The z output will hold a constant random value for each cell suitable to modify a particular instance.
The 'Scale' parameter is so that 1 will use the unit grid. It supports the frequency standard option to interpret the parameter as scale, frequency (1/scale) or VY kilometers.
Learn more about DF modelling in Building 3D Objects : DFRM guide.


XYza DF zones populated with Spheres transforming into Cubes (Voyager Examples/Components/DF Zones & Clusters/DF Zones Cubes.vy)

• Mask : circles:
  Mask each active cell with a circle
  
• Mask : squares:
  Mask each active cell with a square
  

discussion :
Creates an infinite band in X of Apollonian Gasket discs packing. When incoming space is inverted with 22 complex inversion the band becomes a closed disc.
See also the 25 O Soddy Inversions for more on disc pcking fractals.

discussion :
This component provides many interesting irregular tilings and patterns. Most of the patterns are arrangements of various sized blocks.

Some of the algorithms are especially interesting for 3D architecture in ArtMatic Voyager where the z value can be used to apply different textures to different arts of a 3D object or construction. The z value (the index passed from the z output) for some patterns defines roof and ground zones. This allows you to use this component to select from different color textures when used with 44 Packed index (w) Mixer

The z-output of this component is very useful for controlling the mix of a number of textures especially when used with the Packed index Mixer . The z-output range is -2 to 3. There are several different patterns used when generating the z-value. Generally, those patterns that have a "roof" zone set z to -1 for the roof and -2 for the ground.
Some patterns are volumetric and derived from 3D textures with the 'Phase' parameter sliding the slice along the z-axis to reveal pattern variations. Otherwise, 'Phase' offsets the pattern along the x axis.
The 'smoothness' parameter determines edge rounding.
When the option 'link amplitude to frequency' is chosen the 4th output (a) can be used for 3D DF modelling. It will hold in any case the pattern tile elevation, usually zero at the cell edges.

• Random pyramids:
  script call : XYza_Patterns.random_pyramids
  A mix of several indexes that vary randomly in randomly placed blocks.
  
  
  
  
  
• Random blocks:
  script call : XYza_Patterns.random_blocks
  A mix of several indexes that vary randomly in randomly placed blocks.
  
  
  
  
  
• Mixed wall pattern:
  script call : XYza_Patterns.mixed_wall_pattern
  A pattern with thin vertical separation bands and larger horizontal bands.
  
  
  
  
  
  
• Stones wall pattern:
  script call : XYza_Patterns.stones_wall_pattern
  
  
  
  stone wall pattern used in a pentacrystal 2D space (File: Libraries/Textures/Decorative Tilings/DecaPenta Tiling.artm)
  
  
  
• Bauhaus Building:
  script call : XYza_Patterns.bauhaus_building
  Bauhaus Building - a simple geometric design suitable for modern buildings. Bahaus has a roof zone (-1) but no ground and is infinite where y<0. So, it can easily be used for towers texturing.
  
• Pattern blocks A:
  script call : XYza_Patterns.pattern_blocks_a
  
• Pattern blocks B:
  script call : XYza_Patterns.pattern_blocks_b
  
• Pattern blocks C:
  script call : XYza_Patterns.pattern_blocks_c
  Various sets of semi regular periodic patterns.
  
• Zones blocks A:
  script call : XYza_Patterns.zones_blocks_a
  Zones Blocks A provides a handy means to have different ground, wall and roof textures with a decorative band in-between as shown in the example below.
  
  
  Zones Block A Example (file: Allee ZB_A.vy)
  
  
  
• Zones blocks B:
  script call : XYza_Patterns.zones_blocks_b
  
  
  Zones Block A Example (file: Allee ZB_A.vy)
  
  
• Zones blocks C:
  script call : XYza_Patterns.zones_blocks_c
  
  
  Zones Blocks C for the decorative patterning on the building. (File: Decorated Door B)
  
  
• Zones blocks D:
  script call : XYza_Patterns.zones_blocks_d
  
  
  Zone blocks D pattern overview
  
  
  
• Western house 2L:
  script call : XYza_Patterns.western_house
  
• Bricks wall house 3L:
  script call : XYza_Patterns.bricks_wall_house
  
• Zones Chinese house:
  script call : XYza_Patterns.zones_chinese_house
  
• Zones Arcades stones 1L:
  script call : XYza_Patterns.zones_arcades_stones_1l
  
• Zones Arcades stones 2L:
  script call : XYza_Patterns.zones_arcades_stones_2l
  
• Zones Arcades mixed:
  script call : XYza_Patterns.zones_arcades_mixed
  
• Zones Roman house 1L:
  script call : XYza_Patterns.zones_roman_house_1l
  Specially designed for architecture texturing in 3D applications this group provides various layout and styles featuring windows, doors, and various material zones.
  
  
  Tuscan castle using Arcades stones 2L for the wall texture (File:34 uvid volumes tuscan castel.vy)
  
  
  Simple Mosque using Roman house 1L
  
  
  
• Halves V Splits :
  script call : XYza_Patterns.halves_vertical_splits
  
• Halves H Splits:
  script call : XYza_Patterns.halves_horizontal_splits
  These patterns divides recursively the square grid along the opposite axis of the orientation. That creates bands of tiles that becomes smaller and smaller around vertical bans or horizontal bands.
  
• Random corners:
  script call : XYza_Patterns.random_corners
  
• Random holes:
  script call : XYza_Patterns.random_holes
  
• Random splits (0° & 45°):
  script call : XYza_Patterns.random_splits45
  
• Random triangles:
  script call : XYza_Patterns.random_triangles
  
• Klimt panels:
  script call : XYza_Patterns.klimt_panels
  
• Random rectangles:
  script call : XYza_Patterns.random_rectangles
  
• Random tubes & disks:
  script call : XYza_Patterns.random_tubes_and_disks
  The last group features simpler pseudo random patterns more suited for graphic and decorative purposes.
  
• Deco Facade A:
  script call : XYza_Patterns.deco_facade_a
  
• Deco Facade B:
  script call : XYza_Patterns.deco_facade_b
  
• Deco Facade C:
  script call : XYza_Patterns.deco_facade_c
  
• Disk Inlays:
  script call : XYza_Patterns.disk_inlays
  
• Squares Inlays:
  script call : XYza_Patterns.squares_inlays
  

discussion :
RGB+Alpha color shader that creates a pattern of random blocks reminiscent of the works of Piet Mondrian.The texture has been re-implemented in 1.5 for a better match of Mondrian design. The default color palette gives the classic red yellow blue and white primaries.
The options gives full access to all color modes and freq/amp setting : see the standard 1.5 set of options.

discussion :
The color texture resembles an array of LED lights. The alpha channel is essentially a grayscale representation of the LED array. The Style parameter determines the visual style of the array. At some settings the array is sparse and LEDs are uniform; at other settings, the spacing is more dense with some variability in LED shading and shape. Leds are shaded with primary staturated colors that you can modify using Color modification tiles like 44 Color Shift.


Light LED Array with 'style' at maximum

discussion :
Accum noises # provides a set of random textures created by the accumulation of randomly placed (and sometimes rotated) RGBA shapes. The simplest shape is a disk as in Dripping dots. In general Background color is shaded with Aux color B. In DF mode contour shading and background shading are disabled.
The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Random sticks noise:
  script call : AccumNoises.random_sticks
  Accumulates random placed line segments. The background is shaded in black.
  
• Slanted disks noise:
  script call : AccumNoises.slanted_disks
  Accumulates random placed slanted disks. The shape as a surface would be a cone cut at an angle. The orientation is modulated by style parameter.
  
• Segments noise:
  script call : AccumNoises.segments
  Accumulates random placed segments, thicker than in "sticks noise". In default color mode the background is shaded in dark brown.
  
• Arcs cones:
  script call : AccumNoises.arcs_cones
  Accumulates random placed arc shapes.,
  
• Undulated cones:
  script call : AccumNoises.undulated_cones
  comment
  
• Dripping dots:
  script call : AccumNoises.dripping_dots
  Accumulates random placed disks. In non DF mode dots contours are shaded with Aux color A
  
• Color stars:
  script call : AccumNoises.color_stars
  Accumulates random dotes shaded as a light source. Background color is black in this algo.
  
• Leaves noise dense:
  script call : AccumNoises.leaves_dense
  Accumulates random placed leaves shapes. In non DF mode dots contours are shaded with Aux color A
  
• Leaves noise sparce:
  script call : AccumNoises.leaves_sparse
  Accumulates random placed leaves shapes. In non DF mode dots contours are shaded with Aux color A
  
• Capsules:
  script call : AccumNoises.capsules
  Accumulates random placed capsule shapes. A capsule is like an elongated sphere.
  

discussion :
Voronoi noises # implements a set of 2D voronoi based texture where each cell has its random color mapped in the chosen color palette. The DFV set uses a new algorithm that give a correct distance field where the distance to the lines separating the cell is accurate and not an approximation. Hence they are the preferred algorithms to be used in 3D modelling for ArtMatic Voyager. The "Style" controls several variables that depends on the algorithm but generally "Style" modulates jittering and levels. For the DFV set in DF modes when "Style" is above 0.75 cells becomes negative progressively. At "Style" 1 only the contour remains.
Voronoi noises # gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Sharp Voronoi:
  script call : VoronoiNoises.sharp
  The legacy implementation.
  
• Smooth hexa Voronoi:
  script call : VoronoiNoises.smooth_hexa
  When jittering is low the cells are placed on and haxagonal grid.
  
• Voronoi soft skin:
  script call : VoronoiNoises.softskin
  Using exponentials to achieve soft edges. This one is similar to the 21 XXX
  
• Voronoi crystal:
  script call : VoronoiNoises.crystal
  Points and distances are modified to achieve sharper edges and default colors uses ice shades.
  
• Angular voronoi:
  script call : VoronoiNoises.angular
  The distances for each cells are quantized to 45° angles.
  
• Voronoi stones wall:
  script call : VoronoiNoises.stoneswall
  comment
  
• Crystal45 DFV:
  script call : VoronoiNoises.crystal45
  Points are placed in such a way to obtain frequent 45 degree lines and octogonal shapes.
  
  
  
  
  
• Random grid DFV:
  script call : VoronoiNoises.randomgrid
  Points are randomized but within a quantized grid whith a strong probability of alignements.
  
• Nominal DFV:
  script call : VoronoiNoises.nominal_dfv
  The reference true DF Voronoi with one jittered center per cell. The style parameter controls the amount of jittering. At zero the points are on a grid.
  
  
  The nominal Voronoi with default shades (stones)
  
  
  
• Perturbed grid DFV:
  script call : VoronoiNoises.perturbedgrid
  A perturbed regular square grid. The probability of displacement is low for each point.
  
• Quasicrystal DFV:
  script call : VoronoiNoises.quasicrystal
  Points are placed in such a way to create a perturbed regular patterns.
  
  
  
  
  
  
• Splitter DFV:
  script call : VoronoiNoises.splitter_dfv
  Each Voronoi cell has a probability to be split in 2, 3 or 4 controlled by the Style parameter.
  
  
  
  
  
  
• Modulated DFV:
  script call : VoronoiNoises.modulated_dfv
  The size of cells is modulated by a low freqency noise. "Style" affects the range of modulation as well as contour levels.
  
• Recursive DFV:
  script call : VoronoiNoises.recursive_dfv
  A recursive Voronoi where certain cell contains a smaller set. "Style" affects the probability of recursion as well as levels and shading options.
  
  
  
  
  
  

discussion :
Like Accum noises, Polyhedric noises # creates textures using accumulation of randomly placed RGBA shapes but with more geometrical forms (polyhedrons or lines) for more artificial look. There is a z modulated equivalent in the 34 component z Polyhedric noises #
where z input modulates the level of the alpha. In general the background will be shaded with the Aux color B and if the contour is shaded (in non DF mode only) it will use the Aux color A. For legacy compatibility Polygons Rectangular and slanted Polygons uses a black background.
The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Polygons Rectangular:
  script call : PolyhedricNoises.polygons_rectangular
  Accumulates a set of random polyhedrons dominated by arrangements that are oriented at right angles.
  
• Slanted Polygons:
  script call : PolyhedricNoises.slanted_polygons
  Accumulates a set of polyhedrons slanted and clamped with 45 degree planes.
  
• Mondrian Mazes:
  script call : PolyhedricNoises.mondrian_mazes
  A squares and lines maze with primary colors.
  
  
  
  
  
  
• fabric 45 dense:
  script call : PolyhedricNoises.fabric_45_dense
  An accumulation of 45 degree lines segments of mutated width.
  
• fabric 45 sparce:
  script call : PolyhedricNoises.fabric_45_sparse
  Same as before but with sparcer occcurences.
  
  
  
  
  
  
• fabric 45 balanced:
  script call : PolyhedricNoises.fabric_45_balanced
  An accumulation of 45 and -45 degree lines segments of mutated width.
  
• fabric 45 and 90:
  script call : PolyhedricNoises.fabric_45_and_90
  An accumulation of 45,-45 and 90 degree lines segments of mutated width.
  
• Korean Chaos:
  script call : PolyhedricNoises.korean_chaos
  An accumulation of 90° degree lines and partial mazes.
  
  
  
  
  
  
• Mixed shapes:
  script call : PolyhedricNoises.mixed_sparse
  Accumulates a set of polyhedrons and partial mazes using overlay mode.
  
  
  
  
  
  
• Soft lines:
  script call : PolyhedricNoises.richter_lines
  Accumulates 90° lines with a strong smoothing to get a blured effect.
  
• Industrial:
  script call : PolyhedricNoises.industrial
  An accumulation of various repetitive shapes.
  
  
  
  
  
  
• Industrial Chaos:
  script call : PolyhedricNoises.industrial_chaos
  A variation of the above with more polyhedric irregular shapes; Style increases the shapes displacement.
  
  
  
  
  
  

discussion :
Periodic patterns # provides a large set of 2D DF compatible infinite repetitive patterns that were not covered in existing sets. Many designs were inspired by real life examples found in Dubai or discovering other culture designs like the Korean set. The 4th output provide the alpha channel in non DF mode or the distance estimation in DF modes. In DF mode each of these pattern can be use in 3D modelling to texture and carve objects. In general the "Style" parameter affects one or mode variables and the shading options. A contour line is added at the pattern zero crossings when style is above 0.5. Positive regions will progressively be "emptied" when style is above 0.75. At 1 only the contour remains.

The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Hexagonal phase tiles:
  script call : PeriodicPatterns.hexagonal_phase_tiles
  legacy reimplementation that supports all color/frequency modes
  
• Triangular phase tiles:
  script call : PeriodicPatterns.triangular_phase_tiles
  legacy reimplementation that supports all color/frequency modes. The "Style" parameter controls the phase.
  
• Triangular tiles:
  script call : PeriodicPatterns.triangular_tiles
  A simple triangular tiling. The "Style" parameter offers several coloring shemes.
  
• Persian Peacock:
  script call : PeriodicPatterns.persian_peacock
  Inspired by a persian design this implements the Peacock pattern in an hexagonal grid. The "Style" parameter variate coloring shemes.
  
  
  Example in Voyager CTX/Voyager Examples/VY15 Examples/DF2D patterns/
  
  
  
• Hexagonal flowers:
  script call : PeriodicPatterns.hexagonal_flowers
  A simple flower design in an hexagonal grid.
  
• Star 8 mashrabiya:
  script call : PeriodicPatterns.star8_mashrabiya
  comment
  
• Star 8 & 5 mashrabiya:
  script call : PeriodicPatterns.star85_mashrabiya
  comment
  
• Indian mashrabiya:
  script call : PeriodicPatterns.indian_mashrabiya
  Inspired by a indian design this pattern alternates 45 rotated squares which makes octogons emerge. The "Style" parameter variate coloring shemes and modulates contours width.
  
  
  Example in Voyager CTX/Voyager Examples/VY15 Examples/DF2D patterns/
  
  
  
• Indian flowers:
  script call : PeriodicPatterns.indian_flowers
  Indian inspired flower mandala in an 45° square grid.
  
  
  Example in Voyager CTX/Voyager Examples/VY15 Examples/DF2D patterns/
  
  
  
• Star 12 mashrabiya:
  script call : PeriodicPatterns.star12_mashrabiya
  comment
  
• Star 12 hexa:
  script call : PeriodicPatterns.star12_hexa
  comment
  
• Hexagon overlaps:
  script call : PeriodicPatterns.hexagon_overlaps
  comment
  
• Squares overlaps:
  script call : PeriodicPatterns.squares_overlaps
  comment
  
• Octogons overlaps:
  script call : PeriodicPatterns.octogons_overlaps
  comment
  
• Discs overlaps:
  script call : PeriodicPatterns.discs_overlaps
  comment
  
• Atomik:
  script call : PeriodicPatterns.atomik
  comment
  
• Checkboard striped:
  script call : PeriodicPatterns.checkboard_striped
  comment
  
• Korean alternated:
  script call : PeriodicPatterns.korean_alternated
  comment
  
• Korean tiles:
  script call : PeriodicPatterns.korean_tiles
  comment
  
• Korean interleaved:
  script call : PeriodicPatterns.korean_interleaved
  comment
  
• Binary splits:
  script call : PeriodicPatterns.binary_splits
  comment
  
• SciFi tiles:
  script call : PeriodicPatterns.scifi_tiles
  comment
  
• Venitian arcs:
  script call : PeriodicPatterns.venitian_arcs
  comment
  
• Disks variation:
  script call : PeriodicPatterns.disks_variation
  Discs based design.
  
  
  Example in Voyager CTX/Voyager Examples/VY15 Examples/DF2D patterns/
  
  
  
• Star 8 variation:
  script call : PeriodicPatterns.star8_variation
  comment
  
• Squares variation:
  script call : PeriodicPatterns.squares_variation
  comment
  
• Stars and octogons:
  script call : PeriodicPatterns.stars_and_octogons
  comment
  

discussion :
DF Patterns # provides a set of 2D DF compatible randomized non-periodic infinite patterns. Ranging from purely geometric, thematic, or for decorative design they can cover a wide range of use.

The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Puzzle:
  script call : DFPatterns.puzzle
  comment
  
• Disc overlap:
  script call : DFPatterns.disc_overlap
  comment
  
• Displaced:
  script call : DFPatterns.displaced_checkboard
  comment
  
• Tech flower tiles:
  script call : DFPatterns.tech_flower_tiles
  comment
  
• People tiles:
  script call : DFPatterns.people_tiles
  comment
  
• Atomik maze:
  script call : DFPatterns.atomik_maze
  comment
  
• Rect overlap:
  script call : DFPatterns.rect_overlap
  comment
  
• Mayan stonewall:
  script call : DFPatterns.mayan_stonewall
  comment
  
• Tech stonewall:
  script call : DFPatterns.tech_stonewall
  comment
  
• Stepsplit crystal:
  script call : DFPatterns.stepsplit_crystal
  comment
  
• Digital maze:
  script call : DFPatterns.digital_maze
  comment
  
• Split branches:
  script call : DFPatterns.split_branches
  comment
  
• Paul Klee tiles:
  script call : DFPatterns.paul_klee_tiles
  comment
  
• Striped patches:
  script call : DFPatterns.striped_patches
  comment
  
• Tech network:
  script call : DFPatterns.tech_network
  comment
  
• Disc variations:
  script call : DFPatterns.disc_variations
  comment
  
• Octagons variations:
  script call : DFPatterns.octagons_variations
  
• Pentagons variations:
  script call : DFPatterns.pentagons_variations
  

discussion :
2D Architectural # provides a set of complex 2D textures designed for architectural and decorative usage. They may be periodic at a large scale but often use internal randomisation even if the overall structure repeats. Sometimes the style parameter will affect the texture design and provide variations. Depending on which specific algorithm the shading may behave like the periodic patterns set (contour lines added above 0.5 etc) or not. The 4th output provide the alpha channel in non DF mode or the distance estimation in DF modes. In any case in can be used for bump mapping or terrain modulation. In DF mode each of these pattern can be use in 3D modelling to texture and carve objects.
2D Architectural has a 3D equivalent but specific stylistic designs in 3D are much more difficult so the 2D version is still often preferable even if it needs more work to get proper uv coordinates.

The options picker gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Roof tubular tiles:
  script call : Architectural.roof_tubular_tiles
  (legacy)
  Example: Roof tubular tiles.
  
• Roof alternate tiles:
  script call : Architectural.roof_alternate_tiles
  (legacy) Example: Roof alternate tiles:
  
  
  
  
  
• Roof 45° tiles:
  script call : Architectural.roof_45_tiles
  (legacy) Example: Roof 45 degrees tiles:
  
  
  
  
  
• Alternate striped:
  script call : Architectural.alternate_striped
  In a checkborad square pattern vertical and horizontal stripes alternates. The default colors suggest wood tiles.
  
• Wall bricks:
  script call : Architectural.wall_bricks
  (legacy) Example: Wall bricks:
  
  
  
  
  
• Wall large stones:
  script call : Architectural.wall_large_stones
  Randomly placed rectangular stones.
  
• Mondrian splits:
  script call : Architectural.mondrian_splits
  A mondrian design where "Style" controls the probability of a tile to be split randomly.The default colors uses yellow blue red primaries.
  
  
  
  
  
• Composite squares:
  script call : Architectural.composite_squares
  Heterogeneous pattern with squares and stripes
  
• Indian room A:
  script call : Architectural.indian_room_a
  
• Indian room B:
  script call : Architectural.indian_room_b
  A collections of various types of patterns inspired by indian designs. The set includes oriental arch doors and various decorative patterns.
  
• Atlas gallery:
  script call : Architectural.atlas_gallery
  The Atlas set position randomly images from an Atlas inside various patterns designs. The images background color uses Aux color A. "Style" controls tiles spacing and the horizontal number of image in a section. The design alternates regions where picts are densely packed or not with each image section separated by bricks and stones textures.
  
• Atlas rooms:
  script call : Architectural.atlas_rooms
  Alternates layouts modulated by "Style" without bricks patterns.
  
• Atlas patchwork:
  script call : Architectural.atlas_patchwork
  Atlas images are disposed densely in a patchwork or various size tiles. "Style" controls tiles spacing and randomises the images.
  
  
  Example: ArtMatic Designer CTX/Libraries/PictAtlas/Archi 2D Atlas patchwork.artm
  
  
  
• Voronoi panels H:
  script call : Architectural.voronoi_panels_horizontal
  
• Voronoi panels V:
  script call : Architectural.voronoi_panels_vertical
  Heterogeneous pattern with panels of various design with some voronoi filled ones
  
• Bahaus building:
  script call : Architectural.bahaus_building
  Periodic patterns of rectangles suited for building textures
  
• Persian panels A:
  script call : Architectural.persian_panels_a
  Heterogeneous panels inspired by Persian motifs
  
  
  Example in ArtMatic Designer CTX/Libraries/Component 8.5/2D Architecture/
  
  
  
• Persian panels B:
  script call : Architectural.persian_panels_b
  Heterogeneous panels inspired by Persian motifs
  
• Korean room:
  script call : Architectural.korean_room
  
• Korean panels:
  script call : Architectural.korean_panels
  Heterogeneous pattern inspired by Korean motifs.
  
  
  
  
  
• Discs panels:
  script call : Architectural.discs_panels
  Heterogeneous panels with interleaved disk patterns
  
• Octagon panels:
  script call : Architectural.octagon_panels
  Heterogeneous panels with interleaved octogonal patterns
  
• Scifi panels:
  script call : Architectural.scifi_panels
  
• Scifi room:
  script call : Architectural.scifi_room
  Sci fi themes randomly chosen in a square panel grid.
  
  
  
  
  

discussion :
RGB+Alpha version of this great noise function. The alpha channel is an independent multi-fractal noise similar to the 21 MultiFractal noise . Essentially, this component that combines the 23 MultiFractal Noise that provides the colors with a 21 MultiFractal Noise.'Roughness' controls the overall fractal dimension. 'Frequency' abides to the standard frequency options settings. 'Contrast' adjust the contrast and saturation of surface's colors.

discussion :
This version of MultiFractal Noise has a sparse distribution of the texture's colors with more neutral warm dark gray shades in the valleys. 'Roughness' controls the overall fractal dimension. 'Frequency' abides to the standard frequency options settings.


A Sparse MultiFractal terrain with a base frequency of 2km in Voyager DF mode

discussion :
This is a gray and tan fractal noise function that creates lovely textures and is very useful in ArtMatic Voyager where it creates lovely desert /volcanic surfaces and coloration. 'Roughness' controls the overall fractal dimension. 'Frequency' abides to the standard frequency options settings.

discussion :
This RGB+Alpha component creates a color texture of muted grays and an alpha channel whose contours are something like a lunar surface that has smooth areas pocked with craters and faceted ridgelines.
'Roughness' controls the overall fractal dimension. 'Frequency' abides to the standard frequency options settings.


A Fractal facets terrain with a base frequency of 5km in Voyager DF mode

discussion :
As the name implies, this component provides sand dune coloration and surface contours when used in ArtMatic Voyager. 'Amplitude' governs the dune height and 'Amount' governs the distribution and contours of the dunes.'Frequency' abides to the standard frequency options settings.

discussion :
Lunar Granite creates a chaotic texture akin a granitic rock with shades of brown and green in the rough regions. 'Contrast' adjust the contrast and saturation of surface's colors. Other parameters works as usual.'Frequency' abides to the standard frequency options settings.


A Lunar Granite terrain with a base frequency of 5km in Voyager DF mode

discussion :
Accum surfaces # provides Band-limited (high frequencies are filtered) versions of accumulation based random textures suited for terrains design for ArtMatic Voyager. They can of course be used as textures for 2D but they will "vanish" when frequencies gets above a limit level, usually below pixel level.
The options gives full access to all color and freq/amp modes with the 1.5 Color/freq Options set.

• Random Domes:
  script call : AccumSurfaces.random_domes
  Reimplement the legacy Random Domes. The new implementation provides all color palettes and frequencies/Amplitude options.
  
• Sharp Bedrock:
  script call : AccumSurfaces.sharp_bedrock
  Accumulates a set of sharp edges shapes suited for a bedrock terrain.
  
• Round Bedrock:
  script call : AccumSurfaces.round_bedrock
  Accumulates a set of round shapes suited for a bedrock terrain.
  
• Mixed Bedrock:
  script call : AccumSurfaces.mixed_bedrock
  Accumulates a set of mixed shapes suited for a bedrock terrain.
  
• Volcanoids:
  script call : AccumSurfaces.volcano
  Accumulates a sparse set of volcanoid shapes (undulated cones with a crater) suited for to mix with terrain.
  

discussion :
Color texture+elevation component useful for creating rocky surfaces in ArtMatic Voyager. In Voyager's combination mode 'Rocks' can be used to add rocky areas to built-in planets.'Tint' adjust the color shading of surface's colors with dark contrasted bluish tones in the middle to sienna earth brighter tones near maximum.'Frequency' abides to the standard frequency options settings.


'24 Rocks' terrain with a base frequency of 5km in Voyager DF mode and 'Tint' at 0.8

discussion :
Color texture+elevation component that creates the appearance of yellow-green lichen-covered rocks when used in ArtMatic Voyager. 'Amount' controls the statistical weight of the rocks. 'Frequency' abides to the standard frequency options settings.


'Lichen Rocks' terrain with a base frequency of 5km in Voyager DF mode and 'Tint' at 0.8

discussion :
Color texture+elevation component that creates a rocky landscape with boulders whose surfaces are rounded. 'Amount' controls the shape of the boulders by clamping more or less while 'Roughness' controls the overall fractal dimension.
'Frequency' abides to the standard frequency options settings.

'Dome Rock' terrain with a base frequency of 2km in Voyager DF mode and 'Amount' at 0.75

discussion :
Crossfade two RGBA packed inputs using a linear interpolation. 'Interpolate' parameter determines the balance between the two inputs. The function is also available with a packed output using 21 S:P Maths # component with the 'blend' algorithm.

Script examples:
vec4 va = color(0.8,0.1,0.6,0.5);
vec4 vb = RGBA_PictMovie(X,Y);
vec4 vout = mix(va,vb,0.75); // Implicit Packed Crossfade with parameter set to 0.75
Explicit call : RGB_Crossfade(va,vb);

• Add:
  script call : RGBAMaths.add
  
• Blend:
  script call : RGBAMaths.mix
  
• Subtract (A-B):
  script call : RGBAMaths.sub
  
• Difference |A-B|:
  script call : RGBAMaths.diff
  This groups performs the same operation as the 21 S:P Maths when used on RGBA streams. Use this version when the output needs to be unpacked.
  


• Multiply Alpha & blend Colors :
  script call : RGBAMaths.mul_ablend
  The alpha channels are multiplied and the colors of the two channels blended (interpolated). Parameters: Interpolate Color,Level Alpha A,Level Alpha B,Amplitude Alphas %
  
• Multiply All:
  script call : RGBAMaths.mul_all
  Does a strict multiply off both the alpha channels and the RGB channels. Parameter B = Scale Alpha. Parameter C is unused.
  
• Blend Alphas & Colors :
  script call : RGBAMaths.blend_all
  Blend Alphas + Colors - blend the alpha and RGB channels with different amounts. Parameter A controls the color blending while parameter B controls the alpha blending. This is useful for mixing RGBA channels and also for blending colored DF objects channels. It allows you to add bumps (for example) from one channel while keeping the color from the the other channel (unlike the normal Packed Alpha Blend component).
  
• Add Alphas & multiply Colors:
  script call : RGBAMaths.addalpha_mulcolor
  Parameter A controls the blending of color A with the result of multiplied colors of the two RGB channels. Parameter B scales the Alpha channel of the first input. Parameter C scales the Alpha channel of the second input and the two are added together. Output alpha = (Alpha A * B) + (Alpha B * C)
  
• Subtract Alphas & blend Colors:
  script call : RGBAMaths.subalpha_blencolor
  Parameters: Interpolate Color, Amplitude Alpha A, Amplitude Alpha B
  
• Blend on lows (A) :
  script call : RGBAMaths.blend_keepA
  Parameters: Interpolate Color, Interpolate Alpha,Level Offset %, Smoothness %
  
  Does a blending of colors and alpha separately and take a smoothed maximum of A with the blend of A B.
  For Terrain building it has the effect of keeping the higher parts of A intact, a useful feature to add details on the valleys while keeping the mounts of A. Level Offset adjusts the Altitude at which the blending occurs.
  
  
• Blend on highs (A) :
  Parameters: Interpolate Color, Interpolate Alpha, Level Offset %, Smoothness %
  
  "Blend on highs" has the effect of keeping the lower parts of A intact instead of the heights, a useful feature to add details on the mountains only when designing terrains.
  "Level Offset" adjusts the altitude at which the blending occurs.
  
  
• Set Reflection levels:
  script call : RGBAMaths.setreflevels
  Added in E9, this sets the reflection level to parameter A or B depending on the greatest alpha value of the two inputs. The RGB is taken from the RGBA streams that has the greatest alpha value. Useful for Voyager reflection shading x output this component allows to set the level directly with the parameters.
  
• Set Reflection auto:
  script call : RGBAMaths.setrefmax
  Useful for Voyager reflection shading x output this component returns in Alpha the maximum of the RGB component value of the RGBA streams that has the greatest alpha value. The input alpha value is thus unused to set the reflection level as its derived from the RGB levels.
  

discussion :
Packed Logic provides a variety of ways to mix two RGBA streams or two colored DF 3D objects (where object color is in the first three inputs and the distance field is in the fourth input). It is similar to 21 Logic tools # but is useful for combining colored objects.
Learn more about DF modelling in Building 3D Objects : DFRM guide.

Example: Intersection (Min) - X: Yellow Sphere and Y: Blue Cube

• Intersection (Min):
  script call : RGBALogic.intersection
  "Follow A" controls the blending of shape X and shape Y. When "Follow A" is 0, the blending is done strictly according to the selected algorithm. As the value of "Follow A" increases, the influence of shape X increases and morphing effects can be achieved. Smoothness controls the feathering at the intersection of shape X and shape Y. With no feathering, the algorithm is followed strictly and there can be very abrupt transitions. Increasing the feathering smooths the intersections.
  
• Union (Max):
  script call : RGBALogic.union
  Combines the two inputs. You may also use the 21 S:P Logic and Profiles # equivalent (LINK http://uisoftware.com/docs/artmatic/tiles_21.html#S_P_Logic_Profiles)
  
• Subtract (Min(x,-y)):
  script call : RGBALogic.subtract
  Subtract shape Y from shape X. The Colors of the subtracted part are set to Y colors. Subtraction can be use to dig a hole on a shape. Logical operations (the sign) are preserved when chaining the output of this component. As a result, subtracting from a subtracted object can yield a positive area.
  
• Framed subtract:
  script call : RGBALogic.framed_subtract
  Subtract input Y from input X framing the border of the intersection with positive values using the colors of input B. Parameter B controls the mixing of X's and Y's colors. The "frame" is controlled by "Border Thickness" and "Border Spread" parameters. This algorithm is particularly useful designing architectural features such as windows and doors. Unlike the "edged" algorithms, the border texture comes entirely from input B.
  
• Repulsive union:
  script call : RGBALogic.repulsive_union
  
• Repulsive subtract:
  script call : RGBALogic.repulsive_subtract
  
• Ripple union:
  script call : RGBALogic.ripple_union
  
• Ripple subtract:
  script call : RGBALogic.ripple_subtract
  A RGBA version of the Repulsive logic functions. See the 21 Logic tools # at the repulsive section.
  
• S-Ripple union:
  script call : RGBALogic.smooth_ripple_union
  
• S-Ripple subtract:
  script call : RGBALogic.smooth_ripple_subtract
  A RGBA version of the Ripple logic functions. See the 21 Logic tools # at the ripple section.
  
• Partial subtract:
  script call : RGBALogic.partial_subtract
  When designing DF objects Partial Subtract is useful for embossing, cutting windows, carving and texturing. When "subtract" parameter is positive it will subtract Y from X leaving a hole in X with the inner color coming from input Y. When "subtract" parameter is negative it will add a bump to X but still using the Y color. As with the edged algorithms an edge is added at the intersects of X and Y if the "Border Thickness" (C) and "Border Spread" (D) parameters are non zero. Since partial subtract keeps most of the object X intact it is a often used to carve the X surface using a volumetric texture in Y.
  
• Edged intersect:
  script call : RGBALogic.edged_intersection
  
• Edged subtract:
  script call : RGBALogic.edged_subtract
  
• Edged Union -:
  script call : RGBALogic.edged_union_minus
  
• Edged Union +:
  script call : RGBALogic.edged_union_plus
  These related algorithms performs the given logical function and adds edges at the intersect of A and B. The edges are colored with the depth cue color. "Border Thickness" controls the thickness of the edge. "NE Level" can further thicken or reduce the non-edge part of the solid but shall be kept at zero in most of the time. If you use "NE Level" to subtract significantly from the original volume you will obtain "floating" edges.
  
• Underlay (x top):
  script call : RGBALogic.underlay
  A RGBA version of the Underlay logic functions. Y shape goes below X shape and X zero crossings are preserved. See also the 21 Logic tools #
  
• Overlay (y top):
  script call : RGBALogic.overlay
  A RGBA version of the Overlay logic functions. Y shape goes above X shape and Y zero crossings are preserved. Negative alphas are set to Aux color A.
  
• Xor:
  script call : RGBALogic.xor
  A RGBA version of the Xor logic functions. Xor sets the intersection of X and Y to negative (2 positives becomes negative).
  
• Union Xor:
  script call : RGBALogic.union_xor
  A RGBA version of the Union Xor logic functions. Union Xor sets the intersection of X and Y to positive and affects them the 50% mix of X and Y color. Note the zero crossings of X AND Y are preserved by union Xor. It is necessary to add a negative offset to the result to see it.
  
• Fuzzy Intersection:
  script call : RGBALogic.fuzzy_intersection
  The packed RGBA DF texture is assumed to be connected in Y. The "range" parameter sets how far the DF of the texture will expand around the object boundaries. Negatives (spaces) of the textures completely carves the object volume. The "level adjust" parameter adjust the DF level of the Y texture.
  
  
  Fuzzy Intersection of Accumulation pills
  
  
  

ArtMatic script function :RGBA_AlphaMax

parameters :
A : Level balance (-1.0 : 1.0) E9 options
B : Follow A (0.0 : 1.0)
C : Alpha smoothing % (0.0 : 32.0)
D : Color smoothing % (0.0 : 1.0)

discussion :
Returns the RGBA stream that has the maximum alpha value. The smoothing parameter can smooth color and alpha independently. Use Alpha smoothing to avoid a sharp edge at the intersection of the 2 inputs.

ArtMatic script function :RGBA_Compose

parameters :
A : Feather % (0.0 : 2.0)
B : Threshold (-1.0 : 1.0) E9 options

discussion :
This component provides two algorithms for compositing two RGBA streams. It will use the right input alpha to compose it over left input.
The left input may or not have an alpha channel.

Script example: compose a sprite over a background
vec3 va = RGB_PictMovie(X,Y);
vec2 vb = Maths.affine(X,Y);
vec4 vc = RGBA_PictMovie(vb.x,vb.y);//put a sprite there
vec4 vout1 = RGBA_Compose.max(va,vc);

• Compose over color:
  script call : RGBA_Compose.over
  A and B composited over a colored background. This was the original algorithm. Blend the two inputs treating the alpha channels as transparency. The background color defined by parameter C shows through where the inputs are transparent. 'Feather' A and 'Feather' B control the feathering of the left input (A) and right input (B) with respect to their alpha masks. A large feathering value reduces hard mask edges by blurring the transition from transparent to opaque.
  
• Max Compose:
  script call : RGBA_Compose.max
  Adds B over A using Maximum for the alpha channels and alpha blending for the RGB channels. This mode is now the default and is well-suited for 2D graphics compositing.