ArtMatic 3 in 2 out components

//----------------------------//

Introduction

z Scale & Offset

z Displace

z Multiply x*z, y*z

z Weighted Multiply

z Divide x/z, y/z

z Rotate

z Rotate & Scale

Illumination

z Sin distort

z Sin warp (amp)

z Waves

z Twirl

z Random waves

z Ripples

z wipe

Gated Distance

City Light & Reflection #

Perspective Sym

Perspective Clipped

Parallel projection

Spherical projections #

Revolution & Sweeps #

Spherical disk Tile

Complex inversion

Multi bubbles

Multi inverse

Strange web

z Facet space

z Multi Perlin random

z MultiFractal displace

3D fractal Bubbles

Ocean & Foam

3D DF Cities #

3D DF Constructs #

Random 3D noise

Multi Perlin random

Turbulence 3D

MultiFractal displace

Random Fractal Space

Silex Fractal displace

Cliff Chaos displace

Ridged Fractal displace

Balanced Ridged displace

Rocky Fractal displace

Min(x z), Min(y z)

Max(x y z), Min(x y z)

Edge Logic #

Indexed Logic tools #

3D Fractal sets #

3D DF Polyhedrons #

3D DF Buildings #

32 Compiled tree

Many of these components are 2D space transforms that use a third input (called 'z') to control the transformation amount. Some 32 Components, such as Spherical Projection, transform 3D to 2D space. There are a number of specialized components useful for ArtMatic Voyager creations such for creating DFRM objects (3D objects rendered by ArtMatic Voyager) and window reflections.

Most of the 32 components are 3D vector functions that warp or distort space. By convention, we refer to the third input to these components as z, but you should keep in mind that for many of these components the "z" input is not interpreted as a spatial coordinate. The z input often acts as a control input that influences the transformation though in some cases it may act as a third spatial coordinate for components that transform 3D space into 2D space.

Most of the components that start with "Z", use the z input to control the amount of the effect (such as rotation amount or distortion amount). Many of the noise functions use the z input to control the phase or the noise pattern. When using such components, the z input can be used to animate the noise by time by connecting it to the global Z or W inputs.

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

**parameters : **

A : Displace x (-32. : 32.)

B : Displace y (-32. : 32.)

C : z Scale (0.06 : 4.)

**discussion : **

This component distorts the x and y inputs by scaling and offsetting the incoming values before passing them through to the left and right outputs respectively. The z input controls the amount of scaling. The A and B parameters control the x and y displacement and the C parameter scales the influence of the z input.

z Scale & Offset is often used with iterative trees where the iteration value is passed to the z input to scale the space by a different amount for each iteration. It can also be used whenever you need scaling controlled by another component. Note that non-constant z values will distort the space rather than just scaling it.

**parameters : **

A : Displace x (-4. : 4.)

B : Displace y (-4. : 4.)

C : Amplitude (-2. : 2.)

**discussion : **

This component uses the z input to displace the x and y inputs independently according to the displace X and displace Y parameters. It differs from z Scale and Offset in that the value of z is added to x and y values rather than multiplying them. It has a skew effect on a simple plane.

Tip: you may use z Displace whenever you need the displacement amount to be controlled by another component or by an iteration value.

**parameters : **

A : Amount (0. : 1.)

**discussion : **

Scale the x and y inputs using the third (z) input to control the scaling. This is also a basic mathematical building block for creating systems from your own mathematical formulas.

Tip: When used at the top of the system, this component can be used to create time-controlled (rather than parameter-controlled) zooms. Because larger values of x, y and z make objects farther away, an increasing value of z makes objects appear smaller. To use this component to zoom in, insert a 1D A/x filter before the third input as shown in the example file "z Multiply Zoom". Left output = x * z Right output = y * z

**parameters : **

A : z Scale x (-4. : 4.)

B : z Scale y (-4. : 4.)

C : Amplitude (-2. : 2.)

**discussion : **

This component multiplies the x and y inputs by the z input which can create complex interactions of the inputs. The amplitude determines the z input's influence. There is no influence when it is 0. The A and B parameters are offsets added to z before multiplying the x and y inputs. As with z Multiply, this component can be used to scale the x and y inputs under the control of another component.

Left output: (C * (z + A) * x) Right output: (C * (z + B) * y)

The name of this component was changed in version 2.5. In earlier versions, it was called z Multiply. The new z Multiply provides parameter-less multiplication.

**parameters : **

A : Amount (0. : 1.)

**discussion : **

This component is a useful math primitive and space distortion function. If a constant value is fed to the z input, the result is simple scaling of the space received by the x and y components. But if you send anything more interesting, you get very interesting disturbances of space. Explore sending the output of various 11 and 21 components to this component and watch what happens. The formula for the x output is x-input/z input. The formula for the y-output is y-input/z input.

**parameters : **

A : Rotation (-180. : 180.)

B : Offset x (-32. : 32.)

C : Offset y (-32. : 32.)

**discussion : **

z Rotate uses the third input to control the rotation of the space defined by the x and y inputs. When the z input has a center value of 0, nice twirl effects can be created when animating the system.

Tip: you may use **z Rotate** whenever you need the rotation amount to be controlled by another component or by an iteration value. Parameter options allow the rotation to be set in degrees.

**parameters : **

A : Rotation (-180. : 180.)

B : Scale amount (-1. : 1.)

C : Offset x (-32. : 32.)

D : Offset y (-32. : 32.)

**discussion : **

The z input determines the rotation and scaling of the input space. There are two algorithms: Default and Exponential Scale. By connecting z to master input time w you can achieve automatic rotation and zooming.

Parameters A (Rotation) or B (Scale Amount) determine the influence that the z input has. 'Offset x' and 'Offset y' are added to the resulting co-ordinates. This component is frequently used in iterated systems (so that the iteration number can influence both rotation and scaling) or with 24 XYza functions. Parameter options allow the rotation to be set in degrees.
Examples :

Libraries/Minimalism/IG squares Diff C

**parameters : **

A : Light x (-1. : 1.)

B : Light y (-1. : 1.)

C : Light z (-1. : 1.)

D : Specularity (1. : 64.)

**discussion : **

"Illumination" needs to be connected to a normal vector provided by 13 or 33 derivative components. Its parameters specify a light direction.
It will returns in x the dot product of incoming Normal vector with the light in x for diffuse illumination and the dot product of reflected light with the view vector for the specular reflection in y. Practically you will use y for reflections hilits and x for main diffuse illumination. The 'Specularity' parameter adjuts the "metallicity" of the shading and apply a power function to the specular hilit.

This Component was introduced in ArtMatic engine 8.07 and simplifies greatly shading of surfaces within ArtMatic.
The specular channel can also be obtained separatly using the **31 Dot, Plane & Line ** component with the "Dot product R.V" algorithm.

Example files :

**Default :**

The z input controls the level of zoom using exp(z*'Scale') AND the rotation amount by scaling the 'Rotation' angle as well. The Offsets are applied afterwards.**Scale only :**

The z input controls the level of zoom using 1/exp(z*'Scale') only. Rotation is applied independently of the z value and offset x and y will provide the zoom and rotation center. In this mode the range of offset is (-10:10).

**parameters : **

A : Frequency (-1. : 1.)

B : Phase (-1. : 1.)

C : Amplitude (0. : 0.50)

**discussion : **

This component is the same as **32 z Scale and Offset** with the addition of a sin filter applied to the third input. This is a nice component for creating periodic space modulations (when the x and y inputs are received from the plane or from another vector component).

**parameters : **

A : Amplitude x warp (-6.28 : 6.28)

B : Amplitude y warp (-6.28 : 6.28)

C : Frequency (-12.57 : 12.57)

**discussion : **

This component performs the a similar distortion function as the **22 Sin warp** but uses the z input to determine the amount of warping.

**parameters : **

A : Amplitude (-2. : 2.)

B : Phase (-32. : 32.)

**discussion : **

Z Waves is similar to 2D **22 Sin warp** but with the z input modulating the displacement amount. This component can create ripple-like undulations, especially when the phase is animated. If you follow this component with the Movie or pict component, you can get interesting water-like distortion.

**parameters : **

A : Amount x (0. : 1.)

B : Offset xy (-16. : 16.)

C : Offset yz (-16. : 16.)

**discussion : **

32 implementation of 22 **22 Twirl**. The z input controls the Twirl amount .

**parameters : **

A : Frequency (-2. : 2.)

B : Amplitude (0. : 1.)

C : Phase (-16. : 16.)

**discussion : **

A space distortion function that creates liquid-like wave distortions under control of the z input. The z input modulates the amplitude of the waves. The Frequency parameter controls not only the spacing of the waves but also where they start. By adjusting the frequency, you can create effects (as shown in the example file) where only a portion of the incoming space is distorted by waves.

**parameters : **

A : Frequency (0. : 4.)

B : Amplitude (0. : 1.)

C : Phase (-16. : 16.)

**discussion : **

A version of the 2D Ripples component that allows the ripples to be controlled by the z input. The Frequency parameter controls not only the spacing of the waves but also where they start.

**parameters : **

A : Threshold (-6. : 6.)

B : Distortion (-1. : 1.)

C : Frequency (0.06 : 4.)

**discussion : **

Create a wipe or mask effect controlled by the z input.The z input will come from a surface/texture generator that provides the wipe's contour. Where the z input is above value set by the threshold (parameter A), z Wipe generates infinity (which is transparent to the RGB mixing functions). Where z is below the threshold, the inputs are passed through and possibly distorted.

"Distortion" controls how much the z value will affect the scaling of the x and y inputs before passing them through. 'Frequency' will scale the output distorted space.

Example: Z Wipe controlled by a Perlin Noise.

**parameters : **

A : Threshold (-2. : 32.)

B : Amplitude x (0.25 : 4.)

C : Amplitude y (0.25 : 4.)

**discussion : **

Gated Distance is a routing component that sends its output out either the left or right outlet depending on the 2D distance of the incoming point from the origin (0, 0). Use this component to provide different shading for different regions of an image. The x and y inputs are treated as spatial coordinates. Parameter A provides the threshold which is used for determining the routing. Amplitude x and Amplitude y are multipliers applied to the left and right outlets respectively.

In the discussion below, D refers to the distance of the point x,y from the origin. The algorithm is such that when D is above the threshold (parameter A), the incoming z value is sent to the right outlet (0 is sent to the left).

When D is below the threshold, D is sent out the left outlet.
When D < Threshold left outlet = B * D right outlet =0
else (when D &Mac179; Threshold) left outlet = 0 right outlet = C * z

Example: Z Image created by the Gated Distance example file.

**parameters : **

Algorithm slider : (0 : 23)

B : Amount (0. : 2.)

C : Frequency (0. : 64.)

**discussion : **

This component provides window lights and reflections when designing city landscapes based on terrains for ArtMatic Voyager and is a companion to **34 3D Tech Noise #** (Tech Noise provides the color texture for the buildings and **32 City Light & Reflection #** provides the information about the reflections and light coming from the building windows as long as the same pattern is used for both components). The outputs are intended to mapped as extra outputs in ArtMatic Voyager. The x output value is intended to be mapped to ambient light, and the y output value should be mapped to reflections or wetness in ArtMatic Voyager.

Input values. This component is intended to be used to create a color texture for ArtMatic Voyager and so it uses Voyager-based inputs. The inputs are from left to right: latitude, elevation, longitude. (I.e. the left and right inputs are the ground co-ordinates and the middle input is the Voyager elevation).

Parameter A selects the pattern/city map to be used. The City Patchwork and Building series map to the patterns of the same name of the 34 3D Tech Noise component.

**Building A # :**

**Building B # :**

**Building C # :**

**Building D # :**

**Building E # :**

**Building F # :**

**Building G # :**

**Building H # :**

**Building I # :**

**City Patchwork A # :**

**City Patchwork B # :**

**City Patchwork C # :**

**parameters : **

A : Amplitude (-2. : 2.)

**discussion : **

This component creates a mirrored perspective transform when z input is connected to y. Two opposed planes will converge towards a horizon at y=0. The z input provides the depth of perspective transform. The 'Amplitude' parameter controls the amount of perspective. At zero the XY plane is untransformed.

**parameters : **

A : Amplitude (-2. : 2.)

**discussion : **

This component is similar to Perspective Sym except that it doesn't mirror space about the horizon. When points reach a maximum value, they are clipped to the same distance. With this effect, it is often advisable to use depth cueing to reduce noise which is likely to appear in the far distance.

Example: Z Image created by the Gated Distance example file.

**parameters : **

A : Angle xy (oZ) (-180. : 180.)

B : Angle xz (oY) (-180. : 180.)

C : Scale Y (0. : 2.)

**discussion : **

Parallel Projection implements a 3D to 2D parallel projection. The 2D image will be swept in 3D space along the direction given by the Angles parameters. Practically it is used to map a 2D texture on a 3D object.

**parameters : **

A : Scale (0. : 32.)

B : Scale Y (0.12 : 3.14)

C : Offset (-16. : 16.)

D : Rotations if available

**discussion : **

The **Spherical projections** component provides several algorithms to map a 2D texture on a 3D object with non linear or complex projections.
Algorithms 0 and 1 are useful for mapping a 2-D image onto the surface of a sphere since they take into account the curvature of the sphere in all directions. Algorithms 2 and 3 are useful for mapping a 2-D image onto a cylinder or cylinder-like object which is curved in only one direction.

Parameter options allow you to select the orientation which is set along the y axis by default.

**Spherical projection :**

Sets the xy coordinates using the standard spherical projection. In the default orientation x gets the longitudes and y the latitude with top and bottom mapping to north and south pole. You can adjust y scaling with parameter B if needed and rotate the longitudes with the parameter D (since ArtMatic Engine 8.06). Unlike 'Spherical 360' projection goes counter clockwise, that is x coordinates are increasing when rotating counter-clockwise. For a full coverage the image will have a 2 : 1 ratio with the default parameter values.

Note that there is a discontinuity at 2Π.

Output: angle(x,z), asin(y/M) (arcsine is sine inverse function and M is the length of vector(x,y,z) ).

Example :ArtMatic Designer CTX/Libraries/Maths/Projections/Sphere Map projection ,ArtMatic Explorer CTX/Libraries/Maths/Sphere Map projection **Spherical sym projection :**

The absolute value of x is used which keeps the projection symmetrical and mirroring at 2Π. Output: angle(|x|,z), asin(y/M)**Cylindric projection :**

In the default orientation y is passed out unchanged and x coordinates are increasing when rotating counter-clockwise. Introduced in ArtMatic Engine 8.06 'Rotations' parameter allows to rotate the image 360°. Use the z orientation option to map around a pseudo-3D ArtMatic tube.

Output: angle(x,z), y.

Example :ArtMatic Designer CTX/Libraries/Maths/Projections/Cylindric Tube projection ,ArtMatic Explorer CTX/Libraries/Maths/Cylindric Tube projection **Cylindric sym projection :**

This is the same as algorithm 2 except that the absolute value of x is used to make the output symmetrical and mirroring at 2Π which removes the sharp discontinuity.

Output: angle(|x|,z), y**Triple face projection :**

This mode will work coherently only on strict cubes (same length for each axis) and is rarely used. It divides the space along 45° planes to split between 3 parallel projection oriented on oX,oY and oZ.**Dome projection,**

**Dome sym projection :**

The two dome projection algorithms are useful for creating architectural textured domes by wrapping color textures around them. The center is mapped to the dome center. These algorithms minimize distortion when the slope approaches verticality.

*A dome using the Dome Projection for its texture.*

**Stereographic projection:**

This mode implement the Stereographic projection.

Example :Voyager Examples/DF Modelling/Geometry/StereoGraphic sphere proj.vy **Spherical 360 :**"Spherical 360" does a spherical projection clockwise (x coordinates are increasing when rotating clockwise) without any parameters. (Images will be inversed in x when using it in 3D). It is more suited to use on pseudo-3D sphere within ArtMatic than for 3D image mapping. You may also use this mode to "undo" the**Global Input Matrix**Voyager Sky dome projection for placing 2D elements inside a 360° 3D sky dome.

"Spherical 360" is the exact inverse of the "Inverse Spherical 360" mode used in**23 Inverse projections**

**Octahedral NFold :**

The Octahedral (8 triangular faces or 2 4 sided pyramids )set of symmetries with a N_Fold rotational symmetry in each face center.**Dodecahedral NFold :**

The Dodecahedral (12 pentagonal faces) set of symmetries with a N_Fold rotational symmetry in each face center.

Examples :Voyager Examples/DF Modelling/Geometry/DF Dodecahedral Proj...

**Icosahedral NFold :**

The Icosahedral (20 triangular faces) set of symmetries with a N_Fold rotational symmetry in each face center.

Examples :Voyager Examples/DF Modelling/Geometry/DF Icosahedral Proj...

*Icosahedral projected pattern.*

**Cube Projection :**

Projects the same image on all faces of a cube. Scale parameter needs to be adjusted depending on the scale of the cube.

**parameters : **

A : Radius (0. : 64.)

**discussion : **

This component is primarily used for constructing 3D DFRM objects for ArtMatic Voyager. It provides a number of algorithms for sweeping a 2D shape along a path (set with the algorithms popup). For example, if you rotate a vertically-oriented circle in a xz circular path, the result is a torus (a donut shape). Connect the inputs to 3D space and the outputs to a 2D surface (a 21 tile that provides the shape to be swept). Frequently, a 2D shape from 21 Profiles Shapes is used. The algorithms provide different paths along which the profile is swept.

Revolution & Sweeps returns the profile given by the algorithm in first output (x) and passes along y in the second output. In a way Revolution & sweep does the equivalent of 21 Profiles Shapes but sends the third coordinate for convenience so that it can be connected directly to a 21 Profiles Shapes tile.

In general, if the profile shape is symmetrical and bounded, the resulting volume will be open inside. If the profile is infinite in the x-minus direction, the volume will be filed. The paths are on the xz (horizontal) plane unless specified otherwise.

Example: Circle and Basic Polygonal Paths

Circle Revolution |
Triangle Revolution |
Square Revolution |

Pentagonal Revolution |
Hexagonal Revolution |
Octal Revolution |

Dodecagonal Revolution |

Example: Miscellaneous Paths 1

Arc 4 |
Star 4 |
Waves N Revolution |

Power Sines N Revolution |
Rectangle |
U-Rectangle |

Rectangle & 4 Disks |
Rectangle & 4 Disks |

Example: Miscellaneous Paths 2

Cross |
Cross+Disk |
Lines Orthogonal |

Lines Radial Arc |
Lines Radial Disk |
Dented Ring |

< Dented Rect (R-Points) |
Dented Rect (C-Points) |
Dented Rect (Lines) |

Example: Arc Paths

Power Arc xz |
Cubic Arc xz |

Power Arc xy |
Cubic Arc xy |

**Circle revolution :**

**Triangle revolution :**

**Square revolution :**

**Pentagonal revolution :**

**Hexagonal revolution :**

**Octal revolution :**

**Dodecagonal revolution :**

**Arc 4 :**

A four-sided convex arc pattern.**Star 4 :**

A four branch triangle pattern.**Waves N revolution :**

A circle modulated by sine waves. Period (parameter D) sets the number of repeats per disk. Modulation (parameter B) controls how much the disk is modified.**Power Sines N revolution :**

A circle modulated by powered sines. Period (parameter D) sets the number of repeats per disk. Modulation (parameter B) controls how much the disk is modified.**Rectangle :**

The Width (x) and Depth (z) parameters set the path dimensions.**U-Rectangle :**

A rectangle with a cut where radius (param C) sets the dimension of the cut and offset (param D) its depth. The Width (x) and Depth (z) parameters set the path dimensions.**Rectangle & 4 squares :**

A rectangle combined with 4 squares at its edges. The squares radius is controlled by param 3 and can be negative so that the squares are cutting the rectangle.**Rectangle & 4 disks :**

A rectangle combined with 4 circles at its edges. The circle radius is controlled by parameter C. If the radius is negative the disk will cut the edge with an arc. The offset parameter offsets the disk from the edge.**Cross :**

Simple cross profile.**Cross+disk :**

Simple cross profile plus a disk on one of the branches.**Lines Orthogonal :**

Creates a set of unbounded lines in a cross pattern. Period (param D) sets the number of lines per width. Lines Orthogonal generally is best suited to cutting holes in objects (for creating windows for example) but can be used if combined with another volume to create parallel sets of shapes.**Lines Radial Arc :**

Creates Lines number (parameter B) of unbounded lines radiating from a central disk. Start angle (param A)**Lines Radial Disk :**

Creates a set of bounded lines radiating from the center. Parameters are: Radius, Inner Radius,Line Width, and Period.**Dented ring :**

A circle surrounded by a set of "points".**Dented rect (R-points) :**

A rectangle surrounded by a set of squares. The exact size of the rectangle depends on the period parameter which determines the number of "dents" to create.**Dented rect (C-points) :**

A rectangle surrounded by a set of circles. This algorithm is a useful primitive for creating a building surrounded by columns.**Dented rect (lines) :**

A rectangle crossed by a set of lines. Inner radius (param C) scales the size of the rectangle.**Power Arc :**

**Cubic Arc :**

**Perlin Curve :**

**Mixed Curve :**

**ZigZag Path :**

**Arch Tower :**

**Exp Tower :**

**parameters : **

A : Amplitude (0. : 4.)

B : Angle xz (-6.28 : 6.28)

C : Angle yz (-6.28 : 6.28)

**discussion : **

This component tiles the sphere with a set of disks having each their own coordinate system that is sent in XY outputs. Used on a sphere and sent to the U&I logo will produce the image below.

**parameters : **

A : Scale (-2. : 2.)

B : Amplitude (-2. : 2.)

**discussion : **

This component is the same as the 2D version but uses 3D distance (the square root of x-squared plus y-squared plus z-squared). The z input has a skew-like effect.

**parameters : **

A : Amplitude (-2. : 2.)

B : Phase (-8. : 8.)

C : Z Scale (-2. : 2.)

**discussion : **

This component distorts space with a bump texture, and the z input provides the scale of the bumps or bubbles. This is great for stucco-like textures.

**parameters : **

A : Amplitude (0. : 1.)

B : Frequency (0.06 : 1.)

C : Phase (-8. : 8.)

**discussion : **

This is a complex component that creates islands of complex inversions, each one of which is a complete universe.

**parameters : **

A : Real (-2. : 2.)

B : Imaginary (-2. : 2.)

C : z Distort (-2. : 2.)

**discussion : **

This component distorts space with a complex number equation that has three attractors.. The z- input along with the z displace parameter determine the strength of the distortion.

**parameters : **

A : Amplitude (0.12 : 2.)

B : Delta size (0. : 6.)

C : Frequency (0. : 8.)

**discussion : **

A z-controlled version of the 22 Facet Space function. The z input controls the frequency of the tiling. Each tile has its own coordinate system centered at the parent space's origin (0,0). The Amplitude parameter controls the size of the tiles. The Delta Size is a scaling/zoom factor for the space enclosed in each tile, and Frequency controls the spacing of the tiles. This component is useful both as a space distortion function and as a texture generator. As a space distortion function, it acts like a 2D vector function whose frequency is controlled by the third input. Like the 2D Orbiters component, this one creates copies of the incoming space. It acts as a space distortion component, when it is fed by a 2D space and a 1D component. When this component precedes objects (especially finite-sized objects like spheres and cubes), the result is a multitude of randomly spaced objects. When the component is used after objects, it provides cell-like textures.

Example file:

**parameters : **

A : Amplitude (0. : 2.)

B : Octaves (1. : 128.)

C : Frequency (0. : 16.)

**discussion : **

This component implements 22 Multi Perlin Random noise with the addition of z input control of the distortion amount.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

This component implements a 2D **22 MultiFractal displace** with the addition of z input control of the phase of the function.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

This component remaps the incoming space into layers of bubbles randomly drawn from the parent space. The z input influences the phase of the pattern. Connect the z input to global Z or W for automated animation. Roughness influences the number of layers of bubbles. The size of the bubbles in each layer is different.

**parameters : **

A : Wave amp (0. : 8.)

B : Wavelet amp (0. : 2.)

C : Frequency (0. : 8.)

**discussion : **

This component was designed to facilitate designing custom seas for ArtMatic Voyager and behaves like a dual 31 component. Connect the z input to time (Global Input W in ArtMatic Voyager mode) realistic wave motion. The x-output provides the main ocean surface and the y output provides foam. This component plays a key role in ArtMatic Voyager's underwater shaders and to create alternate seas like the "Bad Sea" example below.

**parameters : **

A : Mutation % (0. : 1.)

B : Scale (0.50 : 4.)

C : Sparseness % (0. : 1.)

D : Smoothness % (0. : 1.)

**discussion : **

3D DF Cities provides several infinite procedural Volumetric Cities to explore. The various City Algorithms changes the content of the underlying map and city structure. All cities except "Utopia" mutates building taken from the **32 3D DF Buildings #** families sets (A,B,C) according to which sets are specified in the city algorithm if not 'All'.

As with 3D DF buildings, 3D DF Cities outputs 2 distances fields (DF), one for structure and the other for windows. For untextured city you can just add a color to each output and mix both using logic union (max).

Buildings are chosen at random and are mutated with the 'Mutation' parameter. The exact building choice depend on the building cell position AND the mutation parameter.
Mutation also affects the canal and pools shapes. Keep the 'Mutation' locked if you want to animate or explore a stable city.

The 'Scale' sets the city scale and is usually kept at 1 or 2.

'Sparseness' controls the global building density as an inversed density slider. In "Perlin City" the sparseness also affects the underlying City map.

Even in maximum density there are some empty spots (unbuilt areas) where you can add your own buildings. If you are interested only in a road system infrastructure you can set the sparseness to maximum.

When a 'single family' algorithm is used the "Sparseness" is set to average and the parameter sets the "Family Id".

To texture-shade cities you may use the built-in corresponding textures provided by the **34 DF City Textures #** component or texture yourself the output branches with custom Compiled Trees, or even mix both technics to add dirt in the city for example.

You may also add non-building constructions or special roads/transports systems in your cities using the **3D DF Constructs #** component that can share the same floor/road maps as a DF cities like in the example below :

*Utopia City with hyperloop nexus (file : Voyager Examples/Cities & Constructs/Utopia city/Utopia+construct explorer) *

**algorithms : **

**Grid City, set A:**

**Grid City, set B:**

**Grid City, sets A & B:**

**Grid City, single family:**

The 'Grid City' series are based on the simplest road map possible, a square lattice. Each 'cell' in the lattice has a random value that decide which building family is used and gives a unique mutation value to vary the particular building. The algorithms variants select which building families are chosen from. The Grid cities have no canals, no water pools and no avenue system and are the fastest to compute. Use this mode for cities seen from afar, when limited by another volume.

The 'Grid City, single family' algorithm is meant to display a single family with their mutations. The particular family is chosen with the DF Cities 'family id' parameter that replaces 'Sparseness'.

*Grid city from atop : the square road lattice is clearly visible*

**City sets B & C:**

**City All:**

**Cluster City:**

**City with canals:**

In this series the City floor/road Map has 2 level of hierarchy, Avenues, Basins, Canals for "City with canals". Cities are infinite and probabilistically similar except "Cluster City" that has a High rise region around zero and then an infinite sparser suburb zone.

Examples folder: Voyager Examples/Cities & Constructs/Various Cities.

*Sprites in CanalCity (Voyager Examples/Sprites examples)*

**City single family:**

This special set, using the same floor/road map as other City above is meant to display a single family with their mutations. The particular family is chosen with the DF Cities 'family id' parameter that replaces 'Sparceness'.**MetaCity A set B:**

**MetaCity A All:**

MetaCity A has a floor/road Map with 3 level of hierarchy and features Canals, Basins and Avenues system.

Examples folder: Voyager Examples/Cities & Constructs/MetaCity A

*Metacity A canal using a sparse building density*

**MetaCity B set B :**

**MetaCity B sets A & B :**

**MetaCity B All :**

MetaCity B has a floor/road Map with 5 level of hierarchy, features Basins, Avenues system and low rise building areas.

*Metacity B canal and Avenue wide view*

**Perlin City set B & C :**

**Perlin City All :**

Perlin City has a floor/road Map with 3 level of hierarchy. The overall density, building heights and basins are derived from a Perlin noise. Perlin City has the largest water areas and more realistic distribution of high rise and smaller buildings.

*Perlin City cluster*

*Perlin City with and added advertisement screen coming from the C4 city stuff family*

**Utopia All :**

Utopia has a floor/road Map with 4 level of hierarchy, more complex subdivisions , Round and Square Basins, Avenues system. Depending on the overall 'Sparseness' parameter you may have large water areas.

*Utopia high rises out of fog*

**Utopia single family :**

The 'Utopia single family',' using the same floor/road map as Utopia, will feature a single family building of Utopia building family sets. The particular family is chosen with the 'family id' parameter.

Note for advanced users: You may complexify Utopia by merging a Utopia single family with the Utopia All algorithm to increase the probability of a particular family.

DF Cities can be rendered with various ground level options:

**None:**

No ground. This would be the mode to used if you want the buildings raising out of water or to compose with a custom created ground.**Ground:**

City will be rendered with a basic ground flat plane.**Basic roads :**

City will be rendered with a basic road system and side walks.**Roads & pillars:**

**Slanted roads & pillars:**

**Beveled larger roads & pillars:**

Various roads designs. When roads with pillars are chosen some cities will place the ground below road level and the roads will be elevated at placed on pillars.

*MetaCity B (untextured) with Roads & pillars*

**Pipes:**

Places small pipes on the road centers.**Sides pipes:**

Places small pipes on each side of a flat road.

*MetaCity B (untextured) with Sides pipes*

**Side walks and lamps:**

Roads are rendered with side walks and lamps.**Vacuum tubes:**

'Vacuum tubes' adds big pipes in the middle of the roads system for Sci-Fi cities.

*MetaCity B (untextured) with Vacuum tubes*

**parameters : **

A : Density/Period % (0. : 1.)

B : Scale (0.06 : 16.)

C : Elevation % (0. : 1.)

D : Mutation % (0. : 1.)

**discussion : **

Constructs provides various DF props, artificial and urban structures that can be added to DF Volumetric cities or fantasy landscapes.
Constructs works with an uv coordinates map that is provided by the algorithm choice listed below. The Algorithm lets you chose a particular floor/road map that matches (or not) a particular **DF City**.

When adding constructs to a city it is advised to use the same map at the same size & density/sparseness to have the structs match the city features correctly but you may also use a single line or cross uv map to put the structure at a single location. Typically the construct will follow the road map defined by the city roadmap or its avenues, or some basic path like Cross or Single line.

'Mutation' parameter mostly follow the underlying city roadmap mutations and has to match the DF city 'Mutation' parameter for an exact roadmap match.
It may also modify the shapes of the construct model.

Examples of constructs can be found in Voyager Examples/Cities & Constructs/DF Constructs.

Note: Even if this component was meant to easily add custom features to the procedural DF cities, it can be used in completely different context to quickly create highly complex 3D volumes that follow a pre-defined infinite network when using the "Map uv coordinates" option.

**algorithms : **

**Single line (x) :**

Creates a single line with North/South uv coordinates**Multiple lines (x) :**

Creates a multiple periodic lines with North/South uv coordinates**Cross :**

Creates a simple cross uv coordinates with a line North/South crossing a line East/west.**Curved cross :**

Same as above but with curved junctions at the crossing.**Grid :**

Creates a simple grid uv coordinates. This can be used with Grid cities when set at same scale.**City Roadmap :**

Selects the same uv coordinates as 'City' A roads. This applies to City sets B & C, City All, Cluster City, City with canals and City single family. In other words when the scale and origin match you can superimpose the constructs into any of the cities above.**City Avenues :**Selects the 'City' avenues uv coordinates. It would make sense to add certain construction only on the main transport axis. This is exactly what 'Avenues' proposes : instead of adding a feature to the entire road system you can add the constructs only on main Avenues.**Metacity A Avenues :**Selects the Metacity A main roads uv coordinates.**Metacity A Roadmap :**Selects the Metacity A avenues uv coordinates.**Metacity B main roads :**Selects the Metacity B main roads uv coordinates. Note that Metacity B avenues are located at the same axis than Metacity A, so you can use 'Metacity A Avenues' to place constructions on Metacity B Avenues.**Perlin City main roads :**Selects the Perlin City main roads uv coordinates.**Utopia main roads :**Selects the Utopia main roads uv coordinates.**Utopia Avenues :**Selects Utopia city avenues uv coordinates.

Various constructs DF shapes are chosen using the option menu:

**Basic roads :**

Places a basic road modelled by a rectangles along the road map chosen by Algorithm. 'Basic roads' is build on rectangular pillars whose width growth with 'Mutation'.

*'Basic roads' xy profile*

**Sidewalk & roads:**

Places roads with elevated sidewalk along the road map chosen by Algorithm. This road model is build on rectangular pillars whose width growth with 'Mutation'.

*'Sidewalk & roads' xy profile*

**Slanted edged roads:**

Places slanted edged roads along the road map chosen by Algorithm. This road model is build over chisel-edge rectangular pillars whose width growth with 'Mutation'.

*'Slanted edged roads' xy profile*

**Highways:**

Places a simple highway along the road map chosen by Algorithm. The highway is build on cylindrical pillars. Note that 'Mutation' will modify pillars width.

*'Highway' with 'Curved cross' algorithm*

**Pipes:**

Places Pipes build on cylindrical pilars along the road map chosen by Algorithm.

*'Pipes' with 'Curved cross' algorithm*

**Tubes:**

Places Tubes pipelines along the road map chosen by Algorithm.

*Tubes using Metacity A Roadmap network*

**SciFi transport tube:**

Places a network of tubes pipes and stations evoking a kind of sci-fi hyperloop or aerial subway along the road map chosen by Algorithm.

*SciFi transport tube*

**SciFi highways:**

Places a network of elevated SciFi highways along the road map chosen by Algorithm. This highways features octagonal enveloping structures and pipes on the sides.

*Sci-Fi highways*

**Highways with lamps:**

Places a network of elevated highways with pipe-ramps and regular lamps on the side along the road map chosen by Algorithm. Once textured it can look like :

*Highways with lamps construct added to Utopia City*

**Map uv coordinates:**

Just returns the uv coordinates of the used map for custom constructions. The uv coordinates will provide the x & z coordinates for 2D DF elevation profiles. The u value will typically be zero in the middle of the street and will follow the road map given by the algorithm.

One can see the uv road map as an infinite xz profile that can be used to sweep any xy profile shape as described in the**DFRM guide :modeling technics**page.

**parameters : **

A : Amplitude (-2. : 2.)

B : Frequency (-2. : 2.)

C : Phase (-32. : 32.)

**discussion : **

"Random 3D noise" displaces x & y using two 3D random noises. It is a 3D version of the **22 Random noise** displacement component. The 'Amplitude' parameter controls how much the input coordinates are displaced.

**parameters : **

A : Amplitude (0. : 4.)

B : Octaves (1. : 128.)

C : Frequency (0. : 32.)

D : Roughness (0.12 : 0.75)

**discussion : **

This is a 3D implementation of Multi Perlin Random 2D displacement. It can be auto-animated by time when z is connected to global time input (w). For more information see the 22 Multi Perlin displace component. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 16.)

D : Roughness (0.25 : 0.65)

**discussion : **

Turbulence 3D is a 3D fractal 2D displacement function. The Amplitude parameter controls how much the input coordinates are displaced. Turbulence 3D is great for clouds, smoke, or to distort any 2D graphic function to give it a natural turbulent aspect. To distort a 3D graphic function, use the 33 version. This component uses adaptive resolution with band-limited output as well as the preference Max. Iterations for Fractals. It provides a simple way to animate the displacement over time when z is connected to 'time' global input. 'Frequency' has the standard **frequency options** and controls the scale of the noise. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 32.)

**discussion : **

This component is a 3D MultiFractal 2D displacement noise similar with **22 MultiFractal displace**. It can be useful when for example the displacement shall be different for each iterations in recursive systems. In that case connect the iteration number to z. Also it provides a simple way to animate the function over time when z is connected to 'time' global input. 'Frequency' has the standard **frequency options** and controls the scale of the noise.
In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 8.)

**discussion : **

Random Fractal Space can be seen as two uncorrelated 3D fractal scalar functions. It is similar to 2D **22 Random Fractal Space** except that the fractal texture varies in three dimensions where z can be connected to time. The output is truly random (rather than a distortion/displacement of the input values).

Generally, this component is used to "fractalize" an incoming 3D space (often coming from 3D objects) before applying a 2D texture or shader. This component uses adaptive resolution with band-limited output as well as the Max. Iterations for Fractals preference. 'Frequency' has the standard **frequency options** and controls the scale of the noise while 'Amplitude' scales the resulting space coordinates.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

This component creates spatial distortions typical of silex (silicate) geological formations. The z input can be connected to time to animate the noise. This component can be useful in creating surfaces for ArtMatic Voyager. 'Frequency' has the standard **frequency options**. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

Cliff Chaos Displace can add detail and complexity on any terrains designed for ArtMatic Voyager. It features sharp slopes and is quite chaotic. The underlying 3D fractal noises are added to input coordinates xy and scaled by 'Amplitude'.
'Frequency' has the standard **frequency options**. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 32.)

**discussion : **

Ridged Fractal Displace displaces the space with a 2D vector valued 3D **Ridged fractal noise**. Note the "ridges" are oriented and the noise is not rotation invariant.

'Amplitude' controls amount of displacement while 'Frequency' has the standard **frequency options**. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

Balanced Ridged Displace displaces the space with a 2D vector valued balanced 3D ridged fractal noise. While the original Ridged fractal noise is a positive only function, the ridges here append both in negative and positive directions.

'Amplitude' controls amount of displacement while 'Frequency' has the standard **frequency options**. In Voyager DF mode the amplitude is scaled by 1./8. to avoid DF field divergence.

*A DF sphere and ground displaced in x & y by "Balanced Ridged Displace".*

**parameters : **

A : Amplitude (0. : 2.)

B : Roughness (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

Rocky Fractal Displace distorts the space with a 2D vector valued 3D chaotic multi-fractal noise fine-tuned to evoke a rocky terrain.

'Amplitude' controls amount of displacement while 'Frequency' has the standard **frequency options**.

*A DF sphere and ground displaced in x & y by "Rocky Fractal Displace".*

**parameters : **

A : Smoothness % (0. : 32.)

**discussion : **

A procedural component useful as a primitive for building your own systems and implementing your own algorithms. This component simply sets the left and right outputs to the minimum of (x and z) and (y and z) respectively.

**parameters : **

A : Smoothness % (0. : 32.)

**discussion : **

This component uses the maximum of the three inputs for output 1 and uses the minimum of the three for output 2. Great for creating weird spatial distortions. Results vary greatly depending on the inputs. The result is often a complex mixing of the inputs.

**parameters : **

A : Offset z (-10. : 10.)

B : Edge height (0. : 10.)

C : Edge width (0. : 10.)

D : Smoothness % (0. : 10.)

**discussion : **

max(x,z), max(y,z) has become the following list of logic function. Since a number of DF components uses Two outputs (edges & volume) or structure volume + window volume, a logic tool handling both outputs when adding a volume proved practical. 32 Edge Logic# tools is similar to 22 Edge Logic# but takes an existing edge in x.
The third input sets the volume to be added on the 2 channels, mixing the new edge with the X input, and the volumes (y & z) to the second output. Thus when cascading boolean operation on 2 channels volumes you will want to use 32 Edge logic to handle them at once.

Note: The Algorithm pop up provides dynamic icons.

Example: Edge logic plane subtract

Example: Edge logic echoes subtract

**Edge Union :**

**Edge Intersect :**

**Edge Subtract :**

**Chisel Edge Union :**

**Chisel Edge Intersect :**

**Chisel Edge Subtract :**

**Echoes Union :**

**Echoes Intersect :**

**Echoes Subtract :**

**Max(x,z),Max(z,y) :**

**Plane Subtract :**

**Chisel Plane Subtract :**

**parameters : **

A : Thickness/Offset % (0. : 4.)

**discussion : **

The index returned by "32 Indexed Logic utils" can be useful to shade various regions of the surface differently using a gradient object or a "Packed Index Mixer object where the index value selects which shader is applied.

**Indexed max(x,y,z):**

Returns in out1 the index of the maximum winner (2 1 0) and in out2 the maximum of (x,y,z)**Indexed min(x,y,z):**

Returns in out1 the index of the minimum winner (2 1 0) and in out2 the minimum of (x,y,z)**Indexed Contour max :**

Returns in out1 the index of the maximum winner (2 1 0) in out2 the algorithm takes the maximum of (x,y,z) and subtract the previous running max to have the zones where x==y or x==z or y==z at zero. The resulting surface is always positive and is zero where x,y,z intersects. This algorithm is great for creating contour lines where three surfaces meet.**Indexed Contour comp:**

Compose positive parts of x y z surfaces on top of each others sequentially. The index returned in out1 spans 0-3 and the surface outputted in out2 is suited for contours outline.**Max(x,y),index z :**

**Min(x,y),index z :**

While the 4 first function creates an index from the comparison of the 3 inputs, the last two CHANGES a given index based on the comparison of 2 inputs. "Max(x,y),index z" sets the input z index to be the value given by parameter named "index value if y wins" if y>x or leaves it where it was if not. The index is sent as the first output and the max(x,y) as the second output. Min does the same with the min test.

In general this function will be used in 3D with components that sets a texture index (33 DFI patterns, 24 XYza Tile, 34 UVID Sweep volumes) and you need to add another element either to a new index or one of the input index based on the Max (DF union) logic. It is clearly for advanced ArtMatic programmers and you can use it also in pure programming context as a compare tool.

**parameters : **

A : Radiolaria (0. : 2.)

B : Phase (-4. : 4.)

C : Power (2. : 16.)

**discussion : **

**3D Fractal sets** provides several 3D fractal algorithms that can be rendered with ArtMatic Voyager to create amazing 3D images. The left-hand output is the distance field estimate to the fractal surface (the DF object field, see **Building 3D Objects : DFRM guide**.). The second output is intended for color mapping or ambient occlusion. When rendering in ArtMatic Voyager, use the Fractal Opaque object shader since it understands the particular needs of fractal objects (such as how to deal with the infinitely high frequencies that can occur). It is recommended that you use Ambient Occlusion (a setting in the ArtMatic Voyager objects inspector) when rendering fractal objects.

The fractal iterations are determined by the Maximum Iterations for Fractals preferences setting. Some of these algorithms converge quickly at high iteration levels. 5 to 8 is generally sufficient for high levels of detail.

Examples can be found in /Voyager Examples/DF Fractales folder.
Parameter options :

- Render limit set - Normal mode where the sets is the limit volume of the iterations
- Render as spheres - Accumulates spheres of smaller and smaller sizes
- Render as cubes - Accumulates cubes of smaller and smaller sizes
- Render as spheres & cones - Accumulates spheres & cones of smaller and smaller sizes

**MandelBulb :**

The MandelBulb set is the 3D equivalent of the Mandelbrot set. See more at MandelBulb set.**MandelBulb Julia (0,0,-1) :**

**MandelBulb Julia (a cos(b),a sin(b),0) :**

**MandelBulb Julia R1 (a cos(b),a sin(b),0) :**

**MandelBulb Julia R2 (a cos(b),a sin(b),0) :**

This series provides various Julia sets related to the of the MandelBulb set.**MandelSpheres :**

Creates a fractal based on "Power" symmetries of rotation with spheres.**MandelTubes :**

Creates a fractal based on "Power" symmetries of rotation with cylinders.**Menger Sponge :**

Learn more about Menger sponge in wikipedia.**MandelBox + :**

**MandelBox - :**

**MandelBox Julia A :**

**MandelBox Julia B :**

The MandelBox set is based on mirror foldings and spheres reflections/inversions. It is remarkable for evoking architectural shapes. Learn more about Mandelbox set in wikipedia.

*Mandel Box.*

**Abs MandelBox :**

A Mandelbox-like fractal that uses ABS(z) instead of the MandelBox folding reflections. The role of spherical reflections becomes more obvious.

*ABS MandelBox.*

**Kleinian Dream :**

A fractal based on spherical inversions.

*An ArtMatic voyager rendering of Kleinian Dream.*

**NFold 2-2 fract,**

**NFold 3-2 fract,**

**NFold 4-2 fract,**

**NFold 5-2 fract,**

**NFold 6-3 fract,**

**NFold 8-3 fract,**

**NFold 8-4 fract :**

The NFold fractal sets are based on mirror rotation foldings (see examples in the NFold folder with the DFRM 3D Fractals). Some sets like the 8-4 or 4-2 can evoke some amazing sci-fi architectures.

*A typical NFold series fractal rendered with the render as spheres option.*

**MandelBulb Tower :**

The MandelBulb tower mixes the MandelBulb equation with saw wave vertical folding, creating cyclic alien vertical structures.

*The MandelBulb tower seen in detail and far away.*

Truncated octahedron

**parameters : **

A : Radius (0. : 100.)

B : Frame width % (0. : 1.)

C : Mutations/Grids (0. : 1.)

D : Height (algorithm dependant)

**discussion : **

Outputs in DF1 the structure edges and in DF2 the volume with all faces. Various polyhedrons are implemented and can be used in architecture and modeling design work for rendering in ArtMatic Voyager. With the "Mutation/Grids" parameters various edges sub tiling variations are available for each primitive. The 'Frame width' parameter controls the radius of the added edges.

Examples can be found in /Voyager Examples/Components/DF Polyhedrons.

**Cube frames & solid :**

The cube regular platonic solid. Use that version when you need the cube edges.**4-Pyramid frames & solid :**

A 4 sided pyramid with separated edges. The volume is a Pentahedron with 5 faces, 4 triangles and 1 square. 'Mutations' over 0.25 offers truncated variations.

*Truncated Pentahedron (mutations at 0.33) shaded with Opaque &Transparent in ArtMatic Voyager.*

**Octahedron frames & solid ,**

The Octahedron regular platonic solid is composed of 8 triangles or 2 inversed 4 sided pyramids is provided when 'Mutation' is below 0.25. Otherwise see truncated versions below.**H Octahedron frames & solid :**

The H-Octahedron provides several polyhedrons depending on Mutation parameter.

'Mutation' below 0.25 : a polyhedron composed of 7 Triangles that can be constructed by joining the edges of 2 triangles with the top rotated by 90°.

'Mutation' below 0.75 : a irregular polyhedron composed of hexagons and squares. It is actually a truncated version of the Octahedron (see Truncated octahedron). In-between mutation values modify the edges repartition and structure offering interesting architectural starting points.

'Mutation' above 0.75 : a irregular polyhedron composed of triangles and squares. It's another truncated versions of the Octahedron.

*Truncated Octahedron shaded with Opaque &Transparent in ArtMatic Voyager.*

**Dodecahedron frames & solid :**

The Dodecahedron regular platonic solid is composed of 12 regular pentagons.

*Dodecahedron (mutations at 0.2) shaded with Opaque &Transparent in ArtMatic Voyager.*

**Pentagonal prism y,**

**Hexagonal prism y,**

**Triangle prism y,**

**Box prism y :**

**Octagonal prism y :**

The sweep series sweeps the set of basic regular polygon on the y axis. The additional 'Height' parameter control the height of the sweep in y.

**parameters : **

A : Mutation % (0. : 1.)

B : Scale (0.06 : 16.)

C : Height % (0. : 1.)

D : Smoothness % (0. : 1.)

**discussion : **

3D DF buildings Provides individual building from the Grid City to Perlin Cities. Volumetric Cities are made of a collection of families of buildings that can be mutated with the mutation parameter. It outputs 2 DE field to allow separate shading for different elements, typically here, window and structures. The buildings listed here are being used by all the Cities except "Utopia" which has its own set. Buildings can be textured with their default texture with 34 DF City Textures # using "Grid City single family" mode or with 33 3D DFi patterns or a custom built texture.

Examples can be found in /Voyager Examples/Cities & Constructs/Building Family and /Voyager Examples/Cities & Constructs/Building Solo

**A1 SciFi curved asym (0) :**

This family of building mixes various curved shapes in their design.

*'SciFi curved asym' family mutations set.*

**A2 SciFi curved sym (1) :**

This family of building mixes various curved shapes in their design and are often symmetrical in x or z.

*'SciFi curved sym' family mutations set.*

**A3 Angular edged (2) :**

This family of building often have prominent edges on their sides and wider radius at the top.

*'Angular edged' family mutations set.*

**A4 Gothic scifi (3) :**

The 'Gothic scifi' family often have sharp curved archs at their top, evoking gothic arches.

**A5 Segmented (4) :**

This family of building are often segmented with modules of various height that repeats verticaly.

*'Segmented' family mutations*

**B1 Cross (5) :**

The 'Cross" family creates building mostly constructed with a cross shaped floor plan. **B2 Staircased tower (6) :**

The 'Staircased tower" family of building have modules of various radius that gets smaller and smaller verticaly.**B3 Slanted box (7) :**

The 'Slanted box' family are mostly designed with boxes that are 'cut' at an angle.

**B4 Box (8) :**

The 'Box' family mostly uses simple boxes for their design in a bahaus minimalist design genre.

**B5 Cut Box (9) :**

The 'Cut Box' family often uses boxes that are 'cut' at an angle mixed with various modular structures.

**B6 Empire twins (10) :**

This family of building are inspired by neo-classic 'imperial' or even stalinian easthetics.

*'Empire twins' family mutations*

**C1 Cylindric variations (11) :**

The 'Cylindric variations' family are based on circular shaped floor plan.

*C1 family single instance mutation.*

**C2 Angular postmodern (12) :**

**C3 Fourty five (13) :**

The 'Fourty five' family mixes modular technics with Intersections of 45° rotated volumes.

*'Fourty five' family mutations*

**C4 City stuff :**

The 'City stuff" family are no building per se but city/urban constructions like work area fence, solar panels, pools, reservoirs, Adds screens, and unused space. The Adds screens are using the input picture 0 so you can place an image on theses panels. Their aspect ratio is either 2 by 4 or 16:9.

*'City stuff' family mutations*

**C5 Designer dreams :**

Buildings designed with the architect Scott Jezzard based on modular polyhedral elements.

*'Designer dreams' family mutations.*

**parameters : **

A : Scale 0:1

B : Iterations

**discussion : **

Compiled Trees are groups of tiles that can be used in place of single tiles as a kind of macro or subroutine.

A 32 CT can hold any tree with 3 inputs and 2 outputs.

**usage : **

Select a 32 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.