Writing Custom GLSL Materials 

/*{
    "CREDIT": "Mad Team",
    "DESCRIPTION": "Dunes.",
    "VSN": "1.0",
    "TAGS": "graphic",
    
    // ---------------------------------------------------------
    // 1. INPUTS: These create the UI controls in MadMapper
    // ---------------------------------------------------------
    "INPUTS": [
        // Creates a slider for zooming in/out
        { "LABEL": "Scale", "NAME": "scale", "TYPE": "float", "DEFAULT": 1.0, "MIN": 0.0, "MAX": 4.0 },
        
        // Creates a slider for animation speed
        { "LABEL": "Speed", "NAME": "speed", "TYPE": "float", "MIN" : 0.0, "MAX" : 4.0, "DEFAULT": 1.0 },
        
        // Creates a push-button to reverse the animation direction
        { "LABEL": "Reverse", "NAME": "reverse", "TYPE": "bool", "DEFAULT": false, "FLAGS": "button" },
        
        // Creates a color picker for the dune lines
        { "LABEL": "Color/Front Color", "NAME": "foregroundColor", "TYPE": "color", "DEFAULT": [ 1.0, 1.0, 1.0, 1.0 ] },  
        
        // Creates sliders for brightness and contrast
        { "LABEL": "Color/Brightness", "NAME": "brightness", "TYPE": "float", "MIN": -1.0, "MAX": 1.0, "DEFAULT": 0 },
        { "LABEL": "Color/Contrast", "NAME": "contrast", "TYPE": "float", "MIN": 1.0, "MAX": 3.0, "DEFAULT": 1 },
    ],
    
    // ---------------------------------------------------------
    // 2. GENERATORS: Smoothly handling time and speed
    // ---------------------------------------------------------
    "GENERATORS": [
        // This generates a variable called 'animation_time'. 
        // It uses the 'speed' and 'reverse' inputs to calculate a smooth time value, 
        // preventing the animation from jumping when the user drags the speed slider.
        // It also links this animation directly to MadMapper's global BPM.
        { "NAME": "animation_time", "TYPE": "time_base", "PARAMS": {"speed": "speed", "reverse": "reverse", "speed_curve": 3, "link_speed_to_global_bpm":true} }
    ]
}*/

// ---------------------------------------------------------
// 3. MATH & NOISE FUNCTIONS
// Because shaders calculate everything mathematically per-pixel, 
// we use procedural formulas to generate random numbers and noise.
// ---------------------------------------------------------

// A hashing function that takes a 2D coordinate and returns a pseudo-random 2D vector.
vec2 hash( vec2 p ) {
  p = vec2(dot(p,vec2(127.1,311.7)),
           dot(p,vec2(269.5,183.3)));
  return -1. + 2.*fract(sin(p+20.)*53758.5453123);
}

// A 2D noise function based on the hash above. 
// It smooths out the random numbers to create organic, cloud-like values.
float dunes_noise( in vec2 x ) {
  vec2 p = floor(x);
  vec2 f = fract(x);
  f = f*f*(3.0-2.0*f);
  vec2 uv = (p+vec2(37.0,17.0)) + f;
  vec2 rg = hash( uv/256.0 ).yx;
  return 0.5*mix( rg.x, rg.y, 0.5 );
}

// A simple wrapper function to easily get a random float using two integers
float rnd(int i, int j) {
  return dunes_noise(vec2(i, j));
}

// ---------------------------------------------------------
// 4. THE PATTERN GENERATOR (Gabor Noise)
// ---------------------------------------------------------
#define GABOR_BLOBS_NB 10       // How many overlapping waves to create
#define GABOR_BLOBS_SIZE 0.25   // The size of each wave

// This function creates the actual "Dune" look by layering multiple sine waves 
// (blobs) moving in slightly different random directions.
float DuneStripes (vec2 uv, float d, float freq, float time) {
  float hv = 0.;
  
  // Loop through and create 10 different blobs
  for (int i=0; i<GABOR_BLOBS_NB; i++) {
    // Give each blob a random position and direction
    vec2 pos = vec2(rnd(i,0), rnd(i,1));
    vec2 dir = (.15+d)*vec2(rnd(i,2),rnd(i,3)) - d;
    
    // Add this blob's mathematical wave to our total height value (hv)
    hv += GABOR_BLOBS_SIZE * sin(dot(uv-pos, freq*dir) * 6. + time);
  }
  
  // Return the final combined wave pattern
  return hv;
}

// ---------------------------------------------------------
// 5. THE MAIN FUNCTION
// This is executed for every single pixel on the surface.
// ---------------------------------------------------------
vec4 materialColorForPixel(vec2 texCoord) {
    
  // Step A: Coordinate Setup
  // Center the coordinates around 0.5, apply the user's Scale slider, 
  // and then shift them back. This zooms the pattern in and out from the center.
  vec2 uv = vec2(0.5,0.5) + (texCoord-vec2(0.5,0.5)) * scale;
  
  // Step B: Generate the Pattern
  // Call our DuneStripes function using the scaled coordinates.
  // We pass in our perfectly smooth 'animation_time' generator to make it move!
  float h = DuneStripes(uv, -.5, 10.0, -3.5 * animation_time);
  
  // Step C: Apply Color
  // Multiply the user's chosen Foreground Color by our dune pattern (h).
  // clamp() ensures the brightness values don't drop below 0.0 or exceed 1.0.
  vec3 color = foregroundColor.rgb * clamp(h, 0.0, 1.0);

  // Step D: Apply Contrast
  // mix() blends between a flat gray (vec3(0.5)) and our current color based on the Contrast slider.
  color = mix(vec3(0.5), color, contrast);

  // Step E: Apply Brightness
  // Simply add or subtract the brightness slider value from the final color.
  color += vec3(brightness);

  // Step F: Output the Pixel
  // Return the final calculated color, with an Alpha (transparency) of 1.0 (fully opaque).
  return vec4(color, 1.0);
}