Book Image

Mastering openFrameworks: Creative Coding Demystified

By : Denis Perevalov
Book Image

Mastering openFrameworks: Creative Coding Demystified

By: Denis Perevalov

Overview of this book

openFrameworks is a powerful programming toolkit and library designed to assist the creative process through simplicity and intuitiveness. It's a very handy software library written in C++ to reduce the software development process, helping you to kick-start creative coding. With the help of C++ and shaders support, openFrameworks allows for the processing of all kinds of media information with your custom-developed algorithms at the lowest possible level, with the fastest speed. "Mastering openFrameworks: Creative Coding Demystified" will introduce you to a world of creative coding projects, including interactive installations, audio-visual, and sound art projects. You will learn how to make your own projects using openFrameworks. This book focuses on low-level data processing, which allows you to create really unique and cutting-edge installations and projects. "Mastering openFrameworks: Creative Coding Demystified" provides a complete introduction to openFrameworks, including installation, core capabilities, and addons. Advanced topics like shaders, computer vision, and depth cameras are also covered. We start off by discussing the basic topics such as image and video loading, rendering and processing, playing sound samples, and synthesizing new sounds. We then move on to cover 3D graphics, computer vision, and depth cameras. You will also learn a number of advanced topics such as video mapping, interactive floors and walls, video morphing, networking, and using geometry shaders. You will learn everything you need to know in order to create your own projects; create projects of all levels, ranging from simple creative-code experiments, to big interactive systems consisting of a number of computers, depth cameras, and projectors.
Table of Contents (22 chapters)
Mastering openFrameworks: Creative Coding Demystified
About the Author
About the Reviewers

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 );


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).


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).