#### Overview of this book

Mastering openFrameworks: Creative Coding Demystified
Credits
Foreword
Acknowledgement
www.PacktPub.com
Preface
Free Chapter
openFrameworks Basics
Drawing in 2D
Building a Simple Particle System
Images and Textures
Working with Videos
Working with Sounds
Drawing in 3D
Computer Vision with OpenCV
Using Depth Cameras
Networking
Perlin Noise
Index

## Space-coherent noise

There are a number of overloaded `ofNoise()` functions that depend on two, three, or four parameters: `ofNoise( x, y )`, `ofNoise( x, y, z `), and `ofNoise( x, y, z, t )`. They have behavior like `ofNoise( t )` but use several input parameters. Their coordinates may be scaled as 2D or 3D space coordinates of some point and may even include time. So such functions give a way for generating 2D, 3D, and 4D fields with coherently changing values that are static or evolving with time. For example, the `ofNoise( x, y )` function can be used for drawing a smooth random texture in the following way:

```float scaleX = 0.007;    //1.0 / scaleX is coherence in x
float scaleY = 0.008;    //1.0 / scaleY is coherence in y
float posX0 = 593.2;
float posY0 = 43.7;
for (int y=0; y<500; y++) {
for (int x=0; x<500; x++) {
float value = ofNoise( x*scaleX+posX0, y*scaleY+posY0 );
ofSetColor( value*255, value*255, value*255 );
ofRect( x, y, 1, 1 );
}
}```

### Note

This is example `13-PerlinNoise/03-PerlinTexture`.

On running the code, you will see the following texture:

Now add the third parameter in the calling function `ofNoise()`, which increases with time, and you will obtain a texture that slowly evolves with time.

```float value = ofNoise( x*scaleX+posX0, y*scaleY+posY0,
time*0.1 + 445.6 );```

This code is simple and great for demonstrating the idea. But it works extremely slowly because we render each texture's pixel as a separate rectangle with size 1 × 1. To obtain real-time performance, prepare the texture colors in the `ofImage image` object and draw it in one step using `image.draw()` (see the Creating images section in Chapter 4, Images and Textures).

### Tip

The fastest way of generating textures is by using shaders; see the A liquify distortion example section in Chapter 8, Using Shaders. Though the example is about texture distortion with Perlin noise, it is simple to change it for generating textures. Using shaders is especially useful while generating really big textures in real time.

A similar technique can be used for generating values for evolving height maps of 3D surfaces (see The oscillating plane example section in Chapter 7, Drawing in 3D).