Reference:Function Pattern

Allows you to use a function { } block as pattern.

```pigment {
function { USER_DEFINED_FUNCTIONS }
[PIGMENT_MODIFIERS...]
}
```

Declaring a function:
By default a function takes three parameters (x,y,z) and you do not have to explicitly specify the parameter names when declaring it. When using the identifier, the parameters must be specified.

```#declare Foo = function { x + y + z}

pigment {
function { Foo(x, y, z) }
[PIGMENT_MODIFIERS...]
}
```

On the other hand, if you need more or less than three parameters when declaring a function, you also have to explicitly specify the parameter names.

```#declare Foo = function(x,y,z,t) { x + y + z + t}

pigment {
function { Foo(x, y, z, 4) }
[PIGMENT_MODIFIERS...]
}
```

Using function in a normal:

```#declare Foo = function { x + y + z}

normal {
function { Foo(x, y, z) } [Bump_Size]
[MODIFIERS...]
}
```
 function pattern used as pigment and normal respectively

What can be used

All float expressions and operators. See the section User-Defined Functions for what is legal in POV-Ray. Of special interest here is the `pattern` option, that makes it possible to use patterns as functions

```#declare FOO = function {
pattern {
checker
}
}
```

User defined functions (like equations).

Since pigments can be declared as functions, they can also be used in functions. They must be declared first. When using the identifier, you have to specify which component of the color vector should be used. To do this, the dot notation is used: Function(x,y,z).red

```#declare FOO = function {pigment { checker } }
pigment {
function { FOO(x,y,z).green }
[PIGMENT_MODIFIERS...]
}
```

POV-Ray has a large amount of pre-defined functions. These are mainly algebraic surfaces but there is also a mesh function and noise3d function. See section Internal Functions for a complete list and some explanation on the parameters to use. These internal functions can be included through the functions.inc include file.

```
#include "functions.inc"
#declare FOO = function {pigment { checker } }
pigment {
function { FOO(x,y,z).green & f_noise3d(x*2, y*3,z)}
[PIGMENT_MODIFIERS...]
}
```

Function Image

Syntax :

`function Width, Height { FUNCTION_BODY }`

Not a real pattern, but listed here for convenience. This keyword defines a new 'internal' bitmap image type. The pixels of the image are derived from the Function_Body, with Function_Body either being a regular function, a pattern function or a pigment function. In case of a pigment function the output image will be in color, in case of a pattern or regular function the output image will be grayscale. All variants of grayscale pigment functions are available using the regular function syntax, too. In either case the image will use 16 bit per component

Note: Functions are evaluated on the x-y plane. This is different from the pattern image type for the reason that it makes using uv functions easier.

Width and Height specify the resolution of the resulting 'internal' bitmap image. The image is taken from the square region `<0,0,0>, <1,1,0>`

The `function` statement can be used wherever an image specifier like `tga` or `png` may be used. Some uses include creating heightfields from procedural textures or wrapping a slice of a 3d texture or function around a cylinder or extrude it along an axis.

Examples:

```plane {y, -1
pigment {
image_map {
function 10,10 {
pigment { checker 1,0 scale .5  }
}
}
rotate x*90
}
}
```
```height_field {
function 200,200 {
pattern {
bozo
}
}
translate -0.5
scale 10
pigment {rgb 1}
}
```

Note: For height fields and other situations where color is not needed it is easier to use `function n,n {pattern{...}}` than `function n,n {pigment{...}}`. The pattern functions are returning a scalar, not a color vector, thus a pattern is grayscale.