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


Introduction
3D Scale
3D Offset
3D Rotate
Normalise
3D Normal
3D Reflect
3D Spaces #
3D Repeats & Tile #
3D Plane Mirror
3D Mirrors & Rotates #
N-Fold Mirrors & Offset #
3D Distorts & Bend #
3D sphere
3D sphere B
3D plane
3D tube
3D parametric face
3D parametric plane
3D elevation slices
3D density slices
Conditional z set
3D Sines
3D Color techno noise
3D Color Mondrian
3D Color strata stone
3D Color Marble
3D Color Bubbles
3D Color spots
3D DFi patterns #
Max to gradient
Saturation & Lum
Color Controls #
RGB Contrast
Color Shift
HLS to RGB
RGB to HLS
RGB gamma
RGB Gaussian
RGB dither
RGB Quantize
Memory Min
Memory Max
3D Random vector
3D Multi Perlin displace
3D Fractal displace
3D time turbulence
3D MultiFractal displace #
3D Perlin Vector Noise
3D Color Perlin noise
3D Color Fractal noise
3D Color MultiFractal
3D Caustics
Packed RGB Crossfade
Packed RGB Alpha
Packed RGB Add
Packed RGB Max
Packed Maths #
Packed random Mix
Packed XYZ Depth sort
Packed XYA logic #
Memory Packed Alpha
Memory Add
Memory Diff
Memory Depth sort
33 Compiled tree


Introduction

The components in this group cover a wide range of applications: 3D space distortion and object creation, color/light manipulation, and mixing. An essential in-depth discussion of function categories is found in the Getting Deeper chapter and is recommended reading for everyone. The inputs to the components are referred to as x, y, and z for the left, middle and right inputs. Vector packed values are reffered using upper cases X,Y, Z or A B C. Keep in mind that they may or may not actually be spatial coordinates. While many of these components were designed with particular applications in mind, it is worth exploring non-typical applications.

Tip: Try using the space manipulation components (rotate, sphere, etc.) as color manipulation tools. For example, insert Rotate or Sphere or 3D Random Vector components between RGB/HLS and HLS/RGB components to manipulate image color.
An essential in-depth discussion of ArtMatic structures Trees and components is found in ArtMatic Designer References and in Building trees.


33 3D Scale

parameters :
A : Scale x (-8. : 8.)
B : Scale y (-8. : 8.)
C : Scale z (-8. : 8.)

discussion :
Scale the input space independently on each axis or uniformly depending on which option is chosen. This component can also be viewed as three independent parallel 1D scale filters. Avoid its use for DF modelling as scaled space distorts the distance estimate (see
S-Space Scale).

Parameter Options:




33 3D Offset

parameters :
A : Offset x (-64. : 64.)
B : Offset y (-64. : 64.)
C : Offset z (-64. : 64.)

discussion :
Add an offset to the incoming values. Formula: xout = A + x yout = B + y zout = C + z




33 3D Rotate

parameters :
A : Angle xy (oZ) (-180. : 180.)
B : Angle xz (oY) (-180. : 180.)
C : Angle yz (oX) (-180. : 180.)

discussion :
This component provides a few different methods of 3D rotations. While this component was designed to take a 3D space as its input, it can have an interesting affect when applied to color manipulation. Some algorithms provide both 3D rotation and 3D offset making them more efficient than the standard 3D Rotate plus an additional offset component. Component options allows to set the angle in radians or degrees. Existing values are remapped when changing the angle unit.


algorithms :


33 Normalise

parameters :
A : Magnitude (0.50 : 8.)

discussion :
This is a mathematical primitive that normalizes the incoming 3D vector(x,y,z) by dividing it with its length. The vector's magnitude is set to unity and maintains its orientation. The 'Magnitude' parameter scales the resulting vector magnitude.

Formula: Returns the vector (xM,yM,zM) with M = A/sqrt(x^2 + y^2 + z^2)




33 3D Normal

parameters :
A : Magnitude (0. : 4.)

discussion :
3D Normal uses finite differences to calculate the orientation of the incoming space/object. The normal is the vector perpendicular to the surface's tangent plane. 3D Normal generally needs to be followed by a dot-product with light vector to yield a meaningful lighting effect (see
Illumination). Using this component directly as an RGB-shader creates the illusion that red, green and blue lights are illuminating the object.
Parameter A controls the Magnitude of the Normal vector and should be left at 1 in most cases.
The derivatives are taken by evaluating the tree above several times. Thus this component has to "see" the function above which means it cannot be used within a CT to compute the derivative of a function depending on values computed outside. Practically if you create a CT for a function and needs its derivative, put the derivative component outside the CT and connect the derivative to the CT output.
When used with loopers the derivative component shall be placed outside the loop, that is, after a memory component like 33 Memory Max.
Note: This component has been reimplemented in ArtMatic engine 8.07 to provide a more exact normal, in particular with pseudo 3D primitives. It is meant to be used with 3D vector valued function only. To get the 3D Normal of a 3D scalar field or a 2D surface, use the 13 3D derivative (dx,dy,dz) component.




33 3D Reflect

parameters :
A : Viewvec scale (0. : 2.)

discussion :
Implemented in ArtMatic engine 8.07, 3D reflects simplifies the implementation of reflection shaders. It takes a 3D vector as input (usually a 3D Normal) and returns a reflected 3D vector relative to an implicit view vector V. The reflected vector is computed as R= V - 2*V.N * N, N being the incoming Normale vector. The 'Viewvec scale' parameter determines how narrow is the virtual viewport which is oriented in z and will use global x & y canvas coordinates independently of canvas zoom and position. The reflected output vector can be fed to a 360° environment picture with a spherical projection or a procedural 3D function to define the reflection shading content. ArtMatic pseudo 3D objects like
3D plane can reflects things correctly when using the 3D Normal component described above.

Example files : Libraries/Components 8.07/2D surface DEnvRef, Libraries/Components 8.07/3D objects DEnvRef


Reflective Julia fractal. (Libraries/Components 8.07/F OAN DEnvRef Shaded.artm)


33 3D Spaces #

parameters :
A : Rotation (d) (-180. : 180.)
B : Translate X (-32. : 32.)
C : Translate Y (-32. : 32.)
D : Translate Z (-32. : 32.)

discussion :
This component provides some useful preset 3D spaces that are especially useful for creating DFRM objects. Parameters may change depending on the Algorithm.
Parameter Options note: orient +, orient -, orient + and offsets*10, orient - & offsets*10. The "*10" options are useful when you need offsets larger than the provided range. The +/- options only have significance when the algorithm uses absolute value, such as Bilateral Split |y|.

See the series of examples provided with ArtMatic Voyager to get some idea of how it is used.
ArtMatic Voyager CTX/Voyager Examples/DF Modelling/
ArtMatic Voyager CTX/Voyager Examples/Components/DF 44 Spaces/

algorithms :


33 3D Repeats & Tile #

parameters :
A : Tile X % (0. : 1.)
B : Tile Y % (0. : 1.)
C : Tile Z % (0. : 1.)

discussion :
Formerly 3D Tile, this component provides several flavors of 3D Tiling and repetition. It is useful for creating regular tilings of space which can be useful for creating 3D objects that feature repeating patterns. The Cell Radius parameter defines the spacing between the repetitions. The repetition parameters set the number of repeats along the specified axis. For some algorithm, a fourth parameter is available and specifies an optional randomized rotation for the repeats. This rotation is useful for creating sets of plants or other objects that you don't want to look identical.

Notes: The produced space is not continuous at cell boundaries. So, care should be taken that objects don't extend to or beyond the cell boundary. You may need to use the value*10 parameter option to set the cell radius.

Parameters: A - Tile X, B - Tile Y, C - Tile Z. The parameter range for A, B and C is 0 to 1. The parameter value sets the spacing of the tiling along the associated axis. When the parameter is 0 , there is no tiling along that axis.

Parameter options:

Example: Overhead view of the line, rect, cross and ring sets using a disk for each instances



Example: Overhead view of Array, Arch & Corners sets using a disk for each instances.


Example: This Arcade element repeated with the Ring algorithm.



Example: This Arcade patio uses the Corner mode to repeat the arcades.


Algorithm Notes: The Infinite and Repeats algorithms repeat the input cell in a three dimensional pattern with parameters A-C setting the spacing along the three axes. The Sets algorithms are useful for architectural design and modeling. They deposit copies of the input cell along the path shape described by the algorithm.

algorithms :


33 3D Plane Mirror

parameters :
A : Plane Nx (-2. : 2.)
B : Plane Ny (-2. : 2.)
C : Plane Nz (-2. : 2.)
D : Offset (-50. : 50.)

discussion :
3D Plane Mirror implements a mirroring of space in respect with a plane that can be oriented by its normal. The Normal is set by Parameters Nx,Ny,Nz. A ground plane will be (0,-1,0) while a plane oriented in x will have (1,0,0) as its normal. The plane can be translated in space by parameter 'Offset'. Plane Mirror is a very useful tool for DF modeling and its the 3D equivalent of the
2D Mirror tile.
Mirroring can be used for creating directional symmetries, 3D fractals, and a wide range of shapes and architectures as demonstrated by the examples in the DF Modeling Voyager folder.

algorithms :



3D fractal example based on 2 Plane mirrors and 2 abs.

33 3D Mirrors & Rotates #

parameters :
Algorithm slider : (0 : 19)
B : N rotate (2 : 32)
C : Angle (0. : 90.)

discussion :
This component provides several 3D space transformations that are especially useful for 3D objects modeling. The transforms include a variety of rotation and mirroring algorithms along with tools specific for plants like randomized spread or bendings.

Many primitive plants and animals have a rotational symmetries and Mirrors and Rotates is a practical tool to implement theses types of structures. For more complex plant structures you may also use the
34 Jitter Axial and Jitter Spherical components or even combine them with 3D Mirrors and Rotates.

3D Mirrors and Rotates is a pretty useful for architecture and ornamental design. See also the 2D version of rotational symmetries N-Fold Mirrors and Branch N.

Example: Alien Plant using Rotate N xz & Spread & Bend Up with N=9 rotations and an angle of 48 degree. The randomized spread makes branch of different heights and the bending gives the plant a more natural look.



Example: Same Plant using Rotate N xz & Branch 3 with N=4 rotations and an angle of 23 degree. The Branch 3 subdivides the space to yield 3 sub branches.



Example: Same Plant usingBilateral(x) Rotate N xy with N=5 rotations and an angle of 86 degree (other branches are rotated downward).


algorithms :


33 N-Fold Mirrors & Offset #

parameters :
A : Rotation (d) (-180. : 180.)
B : Offset x (-100. : 100.)
C : Offset y (-100. : 100.)
D : Offset z (-100. : 100.)

discussion :
This component implements
rotational symmetries with mirroring. It is similar to Mirrors & Rotates but offers a choice of orientations and higher ranges for displacements.
Parameters: 'Offsets' (x,y,z) provide post-rotation displacements in each dimension. Parameter 'Rotation' sets the pre-folding rotation of the space. The number of symmetries N is defined by the Options pop up.
The resulting space has N symmetrical branches. This component is often used with 21 Profile Shapes # or 34 Uvid Sweep Volumes.

algorithms :


33 3D Distorts & Bend #

parameters :
Algorithm slider : (0 : 32)
B : Amount (-2. : 2.)
C : Scale / period (0. : 16.)

discussion :
This component provides a variety of 3D space distortion effects that are particularly useful for warping simple 3D primitives into complex shapes. It is generally used to modify the shape of objects by being used above them in the structure tree (which warps objects by modifying the space in which they occur).

Parameter options are available for most algorithms: apply everywhere, fade near center, log increase, main dir +, main dir -, sideways, sideways opposite, opposite fades.

Parameter Options. 8 parameter options are available. The options adapt the basic algorithm. Several options allow the distortion amount to be faded. When fading is performed, the fading (for parameter options that perform fading) depends on the scale/period parameter for those algorithms that fade the distortion (usually near 0). See also :
DFRM guide :modeling technics.

Example: Spread Gaudi Plant example.



Note: Algorithm Name Conventions use the following conventions in their names. A capitalized X, Y or Z indicates an axis of motion or orientation. A lower-case x,y or z indicates a direction that only applies if the appropriate parameter option is selected. For example, Undulate Y in Zx indicates that there will be undulations of the Y direction (vertical) along the Z (depth) axis and that there can be optional motion along x (the horizontal direction).

algorithms :


33 3D sphere

parameters :
A : Angle xz (-12.57 : 12.57)
B : Angle yz (0. : 2.)
C : Displace z (0. : 1.)

discussion :
Renders a pseudo 3D sphere that stick out of a plane located at z origin. It returns the 3D coordinates of the sphere and the plane surface. This 3D object behaves a bit differently than the other 3D objects : infinity is not used as the value for the regions outside of the sphere. The sphere appears against the same background that provides its surface texture. The object is rendered on the (x,y) canvas and the extra z input is used only to distort the space.




33 3D sphere B

parameters :
A : Offset x (-16. : 16.)
B : Offset y (-16. : 16.)
C : Offset z (-16. : 16.)

discussion :
Renders a pseudo 3D sphere into ArtMatic canvas and returns the 3D XYZ coordinates of the sphere surface. The region outside of the sphere is given the value infinity (which is treated as transparent by many of the mixing components). To rotate the sphere, place a 3D rotation component after the sphere. To move the sphere in an orbit, place a rotation before the sphere. The object is rendered on the (x,y) canvas and the extra z input is used only to distort the space.
See
3D plane for more details on pseudo 3D objects.




33 3D plane

parameters :
A : Banking X (-1.57 : 1.57)
B : Plane Offset (-16. : 16.)
C : Z slope (-3.14 : 3.14)

discussion :
Create a 3D plane which can be banked and tilted. Like all 3D object components, the area outside the object is mapped to infinity (which is painted with the first auxiliary color -- the
Depth cue color.) The components which follow the plane component provide the surface's texture. Banking x controls the horizontal tilt, Plane offset provides an altitude offset, and z Slope controls the forward/back tilt.




33 3D tube

parameters :
A : Offset x (-16. : 16.)
B : Offset y (-16. : 16.)
C : Radius (1. : 12.57)

discussion :
Similar to the 23
3D tube this version has an additional input z that modulates the distance to the virtual "camera".




33 3D parametric face

parameters :
A : Angle xy (-Π2 : Π2)
B : Angle zx (-Π2 : Π2)
C : Offset z (-32. : 32.)
D : Height (-3 : 3)

discussion :
Similar to the 23
3D parametric face this version has an additional input z that modulates the distance to the virtual "camera". A non-constant z input will cause the face to be distorted. ArtMatic Engine 8.0 provides a new parameter 'Height' to set the aspect ratio of the face. Use zero 'Height' to get a square.
See 3D plane for more details on pseudo 3D objects.




33 3D parametric plane

parameters :
A : Angle xy (-Π2 : Π2)
B : Angle zx (-Π2 : Π2)
C : Offset z (-32. : 32.)

discussion :
Similar to the 23
3D plane this version has an additional input that modulates the distance to the virtual "camera". The z value can set by the Iteration component when you need a series of 3D parallel planes. A non-constant z input will cause the plane to be distorted. The x & y outputs should be used for 2D texturing. Unlike 3D parametric face above the plane is infinite in dimension.




33 3D elevation slices

parameters :
A : Scale (0.25 : 8.)
B : Slope (0. : 4.)
C : Offset z (-32. : 32.)

discussion :
This is an advanced component that makes certain kinds of 3D modeling possible. This component can be used to visualize 2D surfaces or terrains by iteratively drawing slices over the z-axis. Since true 3D modeling is beyond ArtMatic's current capabilities, this component was added to simulate 3D rendering of some systems. The third input must be connected to a 21 function to be evaluated or to a 21 compiled tree. The first two inputs determine the points to be evaluated. Scale acts as a magnification control. Slope controls angle of view of the 3D space. Offset controls the spacing of the slices on the z axis.

Examples: Look for the word "elevation" in the examples library for examples of this component.




33 3D density slices

parameters :
A : Scale (0.25 : 4.)
B : Surface level (0.12 : 4.)
C : Offset z (-16. : 16.)

discussion :
Another component for simulating 3D modeling. This component works by taking an input function and sampling it iteratively over the z-axis. It is a primitive sort of volumetric rendering. The slices are limited to a plane bounded by -Pi and +Pi on the z-axis. The third input must be connected to a 31 component which will be the function to evaluated iteratively.

Examples: Look for the word "density' in the examples library for examples of this component.Memory Functions The next several components (all with Memory in their names) are intended for use in (and are only meaningful in) iterative systems which are discussed in detail in the chapter Compiled Trees and Iteration.




33 Conditional z set

parameters :
A : Threshold (0. : 32.)
B : Minimum (0. : 1.)

discussion :
This is an advanced component that can be used to create "levelset'-type shading when implementing classical-style fractals such as the Mandelbrot or Julia sets. When the distance (of the x, y inputs from the origin (0, 0)) is above the Threshold parameter or below the Minimum parameter the incoming z value is passed to the third outlet otherwise 0 is sent out the third outlet. x and y are passed through unchanged to the left and middle outlets. Hence, when x,y is within a specific range, the third outlet is non-zero and can be used for shading.

Generally, the z-input will be connected to the output of the Iteration component in a system with memory components. In such a system, it is possible to color a point whose value is infinity with a color related to the number of iterations required to reach infinity. This component can also be used to create distance masking as in the Clock example file.




33 3D Sines

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0.03 : 16.)

discussion :
3D math primitive which generates sin(x) in the red channel, sin(y) in the green channel and sin(z) in the blue channel. This periodic component is equivalent to three parallel 1D sine filters.




33 3D Color techno noise

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)

discussion :
An RGB version of the 31 3D Techno Noise.




33 3D Color Mondrian

parameters :
A : Line Width (0. : 1.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)

discussion :
Computes a color 3D texture inspired by Mondrian paintings with primary colors in rectangular random arrangements.




33 3D Color strata stone

parameters :
A : Chroma (0. : 1.)
B : Distortion (-2. : 2.)
C : Frequency (0. : 8.)

discussion :
RGB version of the 31
3D Stratified noise. The 'Chroma' parameter interpolates between grayscale and colored output. Parameter 'Distortion' controls the amount of vertical distortion.




33 3D Color Marble

parameters :
A : Hue Rotation (0. : 1.)
B : Saturation (0. : 1.)
C : Frequency (0. : 8.)

discussion :
3D color shading function that creates a veined, simple marble-like texture. 'Hue Rotation' controls the tint of the resulting texture while 'Saturation' controls the color saturation, and 'Frequency' controls the spacing of the veins.




33 3D Color Bubbles

parameters :
A : Amplitude (0. : 1.)
B : Phase (-32. : 32.)
C : Frequency (0. : 8.)

discussion :
RGB shading function that provides randomly shaped and colored bubbles.




33 3D Color spots

parameters :
A : Chroma (0. : 1.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)

discussion :
An RGB version of the
31 3D Spots noise function. The 'Chroma' parameter interpolates between grayscale and color output.




33 3D DFi patterns #

parameters :
A : Thickness (-1. : 1.)
B : Phase (-32. : 32.)
C : Frequency (0.03 : 32.)
D : Smoothness % (0. : 1.)

discussion :
This new tile produces 2 DF fields and one index value. It was added to provide a texturing solution for 2 DF output tiles like the DF cities, DF buildings, DF polyhedron and constructs. The index can be used to switch between various colors or textures. The idea for 2 DF output is to allow separate shading for different elements, typically here window and structures.

The texture provides details information that typically will be added to a volume using logic tools # "bump intersect" or "partial subtract".

Example: Building Pattern B applied to a 3D DF Surfaces.



Example:"Star Ship pattern P" for Sci Fi constructions and ships.



algorithms :


33 Max to gradient

parameters :
A : Amplitude X (0. : 2.)
B : Amplitude Y (0. : 2.)
C : Amplitude Z (0. : 2.)

discussion :
Treat the three inputs as three surfaces (fx, fy, fz). For each point, the output is the maximum of fx, fy and fz. If the maximum is fx, the left part of the gradient provides the color. If the maximum is fy, the middle of the gradient is used. If the maximum is fz, the righthand part of the gradient is used. The Amplitude parameter sets the range of colors of the gradient that is used (with a value of 0 a constant color is used for each area). For more information and an illustration, see the discussion of the 23 version of this component.

Note: Max to Gradient was designed to be used with ArtMatic Voyager to provide colors for a surface based on the maximum of the inputs (as with the 3/1 MinMax) component. Each "winner" of the maximum will have its own color.



33 Saturation & Lum

parameters :
A : Saturation (0. : 1.)
B : Brightness (0. : 2.)

discussion :
This component provides direct control of the saturation and luminosity of the incoming RGB values. The output values are restricted to a valid range. (No negative values are passed out).



33 Color Controls #

parameters :
Algorithm dependent

discussion :
This component provides various useful algorithms for color adjustment and color filtering:

algorithms :


33 RGB Contrast

parameters :
A : Contrast amount (-1. : 1.)
B : Offset (-4. : 4.)

discussion :
A component for controlling the contrast of RGB images. When the Contrast parameter is 0, there is no effect. At the maximum value, there are only two output values. The offset parameter controls the contrast divide point. With RGB output, the offset adjusts the overall luminosity. Colors are clamped to valid ranges (no negative values).



33 Color Shift

parameters :
A : Hue shift (-6. : 6.)
B : Lightness % (-2. : 2.)
C : Saturation % (0. : 2.)

discussion :
Like the 44 version, this component controls hue, saturation and luminosity and clamps the colors to valid nominal ranges (0 - 8).




33 HLS to RGB

parameters :
A : Contrast Hue (0. : 2.)
B : Contrast Luminance (0. : 2.)
C : Contrast Saturation (0. : 2.)

discussion :
Colorspace function that converts an HLS-based color stream back to RGB. This component is almost always used at some point following an RGB to HLS component. By inserting components between this component and the HLS to RGB component, you can manipulate the hue, luminance and saturation of an image which make many interesting color manipulations possible.



33 RGB to HLS

parameters :
A : Amplitude (0.50 : 2.)

discussion :
Colorspace function that converts RGB-based color to HLS (hue, luminance, saturation). By inserting components between this component and the HLS to RGB component, you can manipulate the hue, luminance and saturation of an image which make many interesting color manipulations possible.




33 RGB gamma

parameters :
A : Gamma red (0.12 : 8.)
B : Gamma green (0.12 : 8.)
C : Gamma blue (0.12 : 8.)

discussion :
Color manipulation function that provides independent control of the gamma (color response curve) of the red, green and blue channels. No changes are taking place when Gamma red green blue parameters are (1,1,1). Alternatively you can use RGB gamma to apply three power function in parallel.



33 RGB Gaussian

parameters :
A : Offset x (-16. : 16.)
B : Offset y (-16. : 16.)
C : Offset z (-16. : 16.)
D : Scale (0. : 32.)

discussion :
A gaussian filter is applied in parallel to the (x,y,z) inputs. The Offset parameter for each input displaces the center position of the gaussian curves while 'Scale' parameter (engine 8.07) sets the width of the bell curve. RGB gaussian creates symmetrical red, green and blue gaussian bands.



33 RGB dither

parameters :
A : Amplitude (0. : 10.)

discussion :
Add high frequency random noise to the RGB inputs. When using direct RGB systems (systems with 3 outputs), RGB dither can be added at the end of the tree before the final quantization into 8 bit per channel RGB to minimize banding and color quantization artifacts. This function's noise algorithm is independent of the canvas' current zoom and position.



33 RGB Quantize

parameters :
A : Frequency (0.12 : 4.)
B : Phase (-4. : 4.)
C : Amplitude (0. : 1.)

discussion :
Similar to the
11 Quantize component but operates on all inputs simultaneously. When applied to RGB data, it reduces the number of output colors and creates a posterisation effect.



33 Memory Min

parameters :
No parameters.

discussion :
This memory component stores the minimum of the red, green and blue of the current iteration and the stored values. It is used in looped/iterated/recursive trees to combine the results of each pass through the loop. Infinities are transmitted and incoming infinities are treated as transparent.

recursion formula:
mem_red =Min(red,mem_red)
mem_green=Min(green,mem_green)
mem_blue =Min(blue,mem_blue)


33 Memory Max

parameters :
No parameters.

discussion :
This memory component stores the maximum of the red, green and blue of the current iteration and the stored values. It is used in looped/iterated/recursive trees to combine the results of each pass through the loop. Infinities are transmitted and incoming infinities are treated as transparent.

recursion formula:
mem_red =Max(red,mem_red)
mem_green=Max(green,mem_green)
mem_blue =Max(blue,mem_blue)



33 3D Random vector

parameters :
A : Amplitude (-4. : 4.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)

discussion :
3D space distortion function. Place this after a 3D object to provide surface texture. If you place a noise component before a 3D object, you will warp the space in which the object exists (and thus warp the object). This is a distortion-type noise whose output is made up of randomized modulations of the input values.




33 3D Multi Perlin displace

parameters :
A : Amplitude (-8. : 8.)
B : Octaves (1. : 128.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

discussion :
This component sums a series of 3D Perlin noise functions with the frequency doubling for each function in the series. The maximum value for the 'Octaves' parameter is 128 (2^7) and provides seven "octaves". This component allows very fine control of the frequency content. It is especially useful when used with very low frequency values to create surfaces for ArtMatic Voyager. See also 2D Multi Perlin noise and the 31 scalar version of 3D Multi Perlin noise.
'Frequency' abides to the standard
frequency options while 'Amplitude' controls the displacement amount. 'Roughness' adjust the fractal dimension : at 0.5 amplitude is divided by 2 when frequency is multiplied by 2. 'Roughness' has an effect only when more than 2 octaves are present.




33 3D Fractal displace

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

discussion :
Fractal version of the 3D Random vector component. Like the other fractal noise components, there are many frequencies of noise and the complexity/detail can be adjusted with the Maximum Iterations for Fractals preference. This function is a great primitive for marble or clouds or any complicated non-repeating texture.
'Frequency' abides to the standard
frequency options while 'Amplitude' controls the displacement amount. 'Roughness' adjust the fractal dimension.




33 3D time turbulence

parameters :
A : Amplitude (0. : 8.)
B : Feedback (-12. : 12.)
C : Frequency (0. : 32.)
D : Pace (0. : 10)

discussion :
A 3D fractal vector displacement function with feedback. The feedback parameter causes displacements of lower frequencies to be added to the higher frequencies. It is a good primitive for 3D fractal flow and smoke. This component is automatically modulated by time (even when locked). Parameter D, and Pace control the speed of the time-related animation.




33 3D MultiFractal displace #

parameters :
A : Amplitude (0. : 8.)
B : Mutation % (0. : 1.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

discussion :
This 3D MultiFractal vector displacement function provides several algorithms listed below.
'Frequency' abides to the standard
frequency options while 'Amplitude' controls the displacement amount. 'Roughness' adjust the fractal dimension : at 0.5 amplitude is divided by 2 when frequency is multiplied by 2.

algorithms :


33 3D Perlin Vector Noise

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)

discussion :
Returns the absolute value of three independent 3D vector Perlin Noise functions. It is a useful primitive for creating random RGB gradient curves. Use the phase parameter to select the colors.




33 3D Color Perlin noise

parameters :
A : Hue Rotation (-1. : 1.)
B : Saturation (0. : 1.)
C : Frequency (0. : 8.)
D : Variance (0. : 8.)

discussion :
A color texture based on scalar 3D Perlin noise. 'Hue Rotation' changes the main hue, and 'Saturation' sets the saturation of the colors. A zero value will give you a gray scale noise.
'Variance', introduced in ArtMatic engine 8.06 controls how many hues will be used to color the noise.
Tip : Connecting the z input to global time will animate the texture independently of keyframes presence.




33 3D Color Fractal noise

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)

discussion :
This component is the 3D RGB valued fractal noise equivalent of the 2D 23 Random Fractal noise function. The 'Amplitude' parameter augments the contrast of the RGB channels. This component yields interesting effects when combined with other color texture functions. "Color fractal noise" can also be used as a space displacement function.




33 3D Color MultiFractal

parameters :
A : Amplitude (0. : 2.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)
D : Roughness (0.25 : 0.95)

discussion :
3D RGB fractal noise with varying fractal dimension (roughness) created by summing 3D Perlin noise functions at increasing frequencies for each RGB channel. It can be seen as a 3D vector version of the 3D Multifractal noise with an offset to avoid negative colors. It can be used as a multifractal displacement function when it is connected at the top of a three input system.




33 3D Caustics

parameters :
A : Amplitude (0. : 4.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)

discussion :
A 3D fractal vector function that simulates caustics. Caustics are the patterns formed when a point light source is reflected or refracted by a curved surface -- such as one sees on the bottom of a swimming pool on a sunny day. This component is based on 3 independent 3D Ridged Perlin noise. It generates RGB caustic-like shapes. See
21 Ridged noise # You can use the Colorize component to modify the colors to give a bluish-watery caustic look. The Phase parameter can be used to create convincing, natural-looking animation.




33 Packed RGB Crossfade

parameters :
A : Interpolate AB (0. : 1.)
B : Interpolate C (0. : 1.)

discussion :
Crossfade between three RGB images. See the description of the 23 version for a more detailed description. The parameters determine the contribution that the inputs make to the final output.




33 Packed RGB Alpha

parameters :
A : A Threshold (-1. : 1.)
B : B Feather (0. : 1.)

discussion :
Mix two RGB-based images while applying an alpha (transparency) mask provided by the third input. The third input will usually be a simple value (non-packed stream) and acts as an alpha channel for masking the inputs. If the third input is a packed stream then the effect is a complex mixing of the first two images treating the R, G and B layers of the third image as masks to apply to the red, green and blue layers separately. If input x or y is not packed it will be treated as a gray shade.

Options specifies how infinity is handled:




33 Packed RGB Add

parameters :
A : Amplitude A (0. : 2.)
B : Amplitude B (0. : 2.)
C : Amplitude C (0. : 2.)

discussion :
Perform an additive weighted mix of the 3 inputs. If any input is not packed it will be treated as a gray shade. It is similar with the
21 S:P Maths Add function on two inputs, except it outputs the RGB summed values separately and works on 3 inputs. "Amplitude A,B,C" scales the inputs prior summation. Infinity in any of the input will make the result infinity.




33 Packed RGB Max

parameters :
A : Amplitude A (0. : 2.)
B : Amplitude B (0. : 2.)
C : Amplitude C (0. : 2.)

discussion :
Compares the RGB values of all inputs in parallel and returns the highest. "Amplitude A,B,C" scales the inputs prior comparison.
Packed RGB Max can be used as 6 logical MAX performed in parallel if the input vectors are not RGB.




33 Packed Maths #

parameters :
A : Amplitude x (0. : 1.)
B : Amplitude y (0. : 1.)
C : Amplitude z (-1. : 1.)

discussion :
Introduced in ArtMatic engine V 8.07 33 Packed Maths # provides various algorithms to mix 3 RGB or vector streams at once and performs various images compositing. It replaces the old packed add & mul and mul & add components. It is useful as both a mixer and as a basic mathematical building block for implementing specific equations on 3D vectors. 33 Packed Maths # can accomodate unpacked inputs (scalar) as they will be converted to grayscale RGB vectors internally. When the output can or has to be packed you may use the 31
S:P Maths # version that provides the same functions with a packed output.
Infinities are handled as usual as transparent.

algorithms :


33 Packed random Mix

parameters :
A : Amount (0. : 2.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)

discussion :
Packed Random Mix takes three RGB packed streams and randomly mixes them using a low frequency built-in random noise function. Use the 34 equivalent
34 Packed random Mix when the alpha/elevation is required like when designing terrains for landscapes rendering in ArtMatic Voyager
"Phase" and 'Frequency' adjusts the mixing noise while 'Amount' controls how much input B & C will be mixed in.




33 Packed XYZ Depth sort

parameters :
A : z offset (-16. : 16.)

discussion :
This component mixes three 3D objects into a single set of 3D outputs. The inputs should be the packed outputs of 3D objects. The algorithm is such that for each set of points received, the set with the lowest value of z wins; in other words, the coordinates closest to the viewer win.




33 Packed XYA logic #

parameters :
A : Smoothness % (0. : 16.)

discussion :
Useful in 2D geometry applications, this components return a point (x,y,z) based on the z comparison of 3 packed 3D vectors A,B,C. If a scalar is sent to input 3 (Cz) its value will affect the z output only that will be the max of (Az,Bz,Cz).
The returned point may be either of the input depending on the chosen algorithm. 'Smoothness' parameter will blend the transitions between 2D spaces if non zero. 33 Packed XYA logic can be used to create 2D IFS fractals and 2D graphics by splitting the space according to z values.

algorithms :


IFS fractal based on XYA logic. Example file : Libraries/Components demo/XYA logic IFS

33 Memory Packed Alpha

parameters :
A : A Threshold (-1. : 1.)
B : B Feather (0. : 1.)

discussion :
This is an accumulating version of the
Packed RGB Alpha component designed to be used in iterated trees. Usually, inputs 1 and 2 will be packed RGB streams and input 3 will be a simple value acting as an alpha channel mask. Adjusting the 'Threshold' and 'Feather' can have a dramatic effect when using this component as it adjust the alpha level and contrast. Keep the feather at 1 and level at zero to leave the incoming alpha unchanged.


33 Memory Add

parameters :
A : Start Value (-4. : 2.)
B : Sum Gain (0. : 2.)
C : Auto Gain (0. : 1.)

discussion :
This component adds the vector (x,y,z) of each iteration to the accumulated values initialized with the parameter "Start value". It is basically a summation over iterations and the output sum vector is scaled by 'Sum Gain' parameter.
When 'Auto Gain' is set at 1 the weight will be calculated using the context iteration max to keep the sum independent of the iteration number. Lower values will blend with the 'Sum Gain' setting.
Incoming infinities are discarded and treated as transparent.


33 Memory Diff

parameters :
No parameters.

discussion :
Memory Diff performs the absolute value of the difference between input vector and stored values initialized at (0,0,0).


33 Memory Depth sort

parameters :
No parameters.

discussion :
This component is a memory-based version of the other depth sort functions. Rather than performing a depth sort between two sets of inputs, the depth sort is performed between the current set of values and the stored values from the previous iteration. Depth Sort preserves the values that correspond to the frontmost pixel when the three values are considered as 3D position. The frontmost pixel corresponds to the value with the lowest valued z (third) coordinate. This component is useful for accumulating pseudo 3D objects in recursive and iterative trees.
Example: Libraries/Components demo/Ammonite



33 Compiled Tree :

parameters :
A : Blend 0:1
B : Recursions

discussion :
Compiled trees are groups of tiles that can be used in place of single tiles as a kind of macro or subroutine. 33 CTs can hold groups of 3D space transformations or can be used to manipulate 3 streams of datas : scalar single values or 3D or 4D packed vectors.

usage :
Select a 33 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.

CTs can be used recursively if the option "Allow feedback" is set. In that case output is fed to the input at second iteration and the transform will be applied "N" times, N being set by the "Recursions" parameter.
When recursed the type of input shall match the type of ouputs. It is possible to recurse 2D coordinates in XY while using a packed RGBA stream for input3. The CT has then to accumulate the color+alpha data that will be sent to third output using a Memory tile (see
44 Memory w Logic # discussion).
33 CTs can also (ArtMatic Engine 8.0) recurse a packed RGBA stream in third input/output. In that case you may also use S:P Logic &Profiles to accumulate the RGBA data within the CT. In both ways you can create advanced color-shaded 2D fractals using 33 Compiled Tree.