Noise factory

import { constructors } from '../core/library.js';
import { mergeOver, λnull, λthis, λfirstArg, removeItem, seededRandomNumberGenerator, interpolate, easeOutSine, easeInSine, easeOutInSine, easeOutQuad, easeInQuad, easeOutInQuad, easeOutCubic, easeInCubic, easeOutInCubic, easeOutQuart, easeInQuart, easeOutInQuart, easeOutQuint, easeInQuint, easeOutInQuint, easeOutExpo, easeInExpo, easeOutInExpo, easeOutCirc, easeInCirc, easeOutInCirc, easeOutBack, easeInBack, easeOutInBack, easeOutElastic, easeInElastic, easeOutInElastic, easeOutBounce, easeInBounce, easeOutInBounce } from '../core/utilities.js';

import { makeColor } from './color.js';

import baseMix from '../mixin/base.js';
import assetMix from '../mixin/asset.js';
import patternMix from '../mixin/pattern.js';

const Noise = function (items = {}) {

    this.makeName(items.name);
    this.register();

    let mycanvas = document.createElement('canvas');
    mycanvas.id = this.name;
    this.installElement(mycanvas);

    this.perm = [];
    this.permMod8 = [];
    this.values = [];
    this.grad = [];

    this.subscribers = [];

    this.colorFactory = makeColor({
        name: `${this.name}-color-factory`,
        minimumColor: items.gradientStart || 'red',
        maximumColor: items.gradientEnd || 'green',
    });

    this.set(this.defs);
    this.set(items);

    if (items.subscribe) this.subscribers.push(items.subscribe);

    this.dirtyOutput = true;

    return this;
};

let P = Noise.prototype = Object.create(Object.prototype);
P.type = 'Noise';
P.lib = 'asset';
P.isArtefact = false;
P.isAsset = true;

P = baseMix(P);
P = assetMix(P);
P = patternMix(P);

let defaultAttributes = {

    width: 300,
    height: 150,

    color: 'monochrome',

    monochromeStart: 0,
    monochromeRange: 255,

    gradientStart: '#ff0000',
    gradientEnd: '#00ff00',

    hueStart: 0,
    hueRange: 120,
    saturation: 100,
    luminosity: 50,

    noiseEngine: 'simplex',

    seed: 'any_random_string_will_do',
    size: 256,

    scale: 50,

    octaves: 1,
    octaveFunction: 'none',
    persistence: 0.5,
    lacunarity: 2,

    smoothing: 'quintic',

    sumFunction: 'none',
    sineFrequencyCoeff: 1,
    modularAmplitude: 5,


};
P.defs = mergeOver(P.defs, defaultAttributes);

delete P.defs.source;
delete P.defs.sourceLoaded;

P.stringifyFunction = λnull;
P.processPacketOut = λnull;
P.finalizePacketOut = λnull;
P.saveAsPacket = function () {

    return `[${this.name}, ${this.type}, ${this.lib}, {}]`
};

P.clone = λthis;

let G = P.getters,
    S = P.setters,
    D = P.deltaSetters;

S.source = λnull;

S.subscribers = λnull;

S.octaveFunction = function (item) {

    this.octaveFunction = this.octaveFunctions[item] || λfirstArg;
    this.dirtyNoise = true;
    this.dirtyOutput = true;
};

S.sumFunction = function (item) {

    this.sumFunction = this.sumFunctions[item] || λfirstArg;
    this.dirtyNoise = true;
    this.dirtyOutput = true;
};

S.smoothing = function (item) {

    this.smoothing = this.smoothingFunctions[item] || λfirstArg;
    this.dirtyNoise = true;
    this.dirtyOutput = true;
};

S.noiseEngine = function (item) {

    this.noiseEngine = this.noiseEngines[item] || this.noiseEngines['simplex'];
    this.dirtyNoise = true;
    this.dirtyOutput = true;
};

S.octaves = function (item) {

    if (item.toFixed) {

        this.octaves = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.seed = function (item) {

    if (item.substring) {

        this.seed = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

P.supportedColorSchemes = ['monochrome', 'gradient', 'hue'];
S.color = function (item) {

    if (this.supportedColorSchemes.indexOf(item) >= 0) {

        this.color = item;
        this.dirtyOutput = true;
    }
};

S.scale = function (item) {

    if (item.toFixed) {

        this.scale = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.size = function (item) {

    if (item.toFixed) {

        this.size = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.persistence = function (item) {

    if (item.toFixed) {

        this.persistence = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.lacunarity = function (item) {

    if (item.toFixed) {

        this.lacunarity = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.gradientStart = function (item) {

    if (item.substring) {

        this.colorFactory.setMinimumColor(item);
        this.dirtyOutput = true;
    }
};

S.gradientEnd = function (item) {

    if (item.substring) {

        this.colorFactory.setMaximumColor(item);
        this.dirtyOutput = true;
    }
};

S.monochromeStart = function (item) {

    if (item.toFixed && item >= 0) {

        this.monochromeStart = item % 360;
        this.dirtyOutput = true;
    }
};

S.monochromeRange = function (item) {

    if (item.toFixed && item >= -255 && item < 256) {

        this.monochromeRange = Math.floor(item);
        this.dirtyOutput = true;
    }
};

S.hueStart = function (item) {

    if (item.toFixed) {

        this.hueStart = item;
        this.dirtyOutput = true;
    }
};

S.hueRange = function (item) {

    if (item.toFixed) {

        this.hueRange = item;
        this.dirtyOutput = true;
    }
};

S.saturation = function (item) {

    if (item.toFixed && item >= 0 && item <= 100) {

        this.saturation = Math.floor(item);
        this.dirtyOutput = true;
    }
};

S.luminosity = function (item) {

    if (item.toFixed && item >= 0 && item <= 100) {

        this.luminosity = Math.floor(item);
        this.dirtyOutput = true;
    }
};

S.sineFrequencyCoeff = function (item) {

    if (item.toFixed) {

        this.sineFrequencyCoeff = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.modularAmplitude = function (item) {

    if (item.toFixed) {

        this.modularAmplitude = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.width = function (item) {

    if (item.toFixed) {

        this.width = item;
        this.sourceNaturalWidth = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

S.height = function (item) {

    if (item.toFixed) {

        this.height = item;
        this.sourceNaturalHeight = item;
        this.dirtyNoise = true;
        this.dirtyOutput = true;
    }
};

P.installElement = function (element) {

    this.element = element;
    this.engine = this.element.getContext('2d');

    return this;
};

P.checkSource = function (width, height) {

    this.notifySubscribers();
};

P.getData = function (entity, cell) {

    this.notifySubscribers();

    return this.buildStyle(cell);
};

P.notifySubscribers = function () {

    if (this.dirtyOutput || this.dirtyNoise) this.cleanOutput();

    this.subscribers.forEach(sub => this.notifySubscriber(sub), this);
};

P.notifySubscriber = function (sub) {

    sub.sourceNaturalWidth = this.width;
    sub.sourceNaturalHeight = this.height;
    sub.sourceLoaded = true;
    sub.source = this.element;
    sub.dirtyImage = true;
    sub.dirtyCopyStart = true;
    sub.dirtyCopyDimensions = true;
    sub.dirtyImageSubscribers = true;
};

P.cleanOutput = function () {

    if (this.dirtyNoise) this.cleanNoise();
    if (this.dirtyOutput) this.paintCanvas();
};

P.cleanNoise = function () {

    if (this.dirtyNoise) {

        this.dirtyNoise = false;

        let {noiseEngine, seed, width, height, element, engine, octaves, lacunarity, persistence, scale, octaveFunction, sumFunction} = this;

        if (noiseEngine && noiseEngine.init) {

            this.rndEngine = seededRandomNumberGenerator(seed);

            this.generatePermutationTable();

            noiseEngine.init.call(this);

            let x, y, o, i, iz,
                noiseValues = [],
                scaledX, scaledY,
                totalNoise, amplitude, frequency;

            for (y = 0; y < height; y++) {

                noiseValues[y] = [];

                for (x = 0; x < width; x++) {
                    noiseValues[y][x] = [];
                }
            }

            let relativeScale = Math.pow(width, -scale / 100);

            let max = -1000, 
                min = 1000;

            for (y = 0; y < height; y++) {
                for (x = 0; x < width; x++) {

                    scaledX = x * relativeScale;
                    scaledY = y * relativeScale;

                    totalNoise = 0;
                    amplitude = 1; 
                    frequency = 1;

                    for (o = 0; o < octaves; o++) {

                        let octaveNoise = noiseEngine.getNoiseValue.call(this, scaledX * frequency, scaledY * frequency);

                        octaveNoise = octaveFunction(octaveNoise, scaledX, scaledY, o + 1);

                        octaveNoise *= amplitude;
                        totalNoise += octaveNoise;

                        frequency *= lacunarity;
                        amplitude *= persistence;
                    }

                    noiseValues[y][x] = totalNoise;

                    min = Math.min(min, totalNoise);
                    max = Math.max(max, totalNoise);
                }
            }

            let noiseSpan = max - min;

            for (y = 0; y < height; y++) {
                for (x = 0; x < width; x++) {

                    scaledX = x * relativeScale;
                    scaledY = y * relativeScale;

                    let clampedVal = (noiseValues[y][x] - min) / noiseSpan;
                    noiseValues[y][x] = sumFunction.call(this, clampedVal, x * relativeScale, y * relativeScale);
                }
            }

            this.noiseValues = noiseValues;
        }
        else this.dirtyNoise = true;
    }
};

P.paintCanvas = function () {

    if (this.dirtyOutput) {

        this.dirtyOutput = false;

        let {noiseValues, element, engine, width, height, color, colorFactory, monochromeStart, monochromeRange, hueStart, hueRange, saturation, luminosity} = this;

        if (null != noiseValues) {

            element.width = width;
            element.height = height;

            switch (color) {

                case 'hue' :

                    for (let y = 0; y < height; y++) {
                        for (let x = 0; x < width; x++) {

                            engine.fillStyle = `hsl(${(hueStart + (noiseValues[y][x] * hueRange)) % 360}, ${saturation}%, ${luminosity}%)`;
                            engine.fillRect(x, y, 1, 1);
                        }
                    }
                    break;

                case 'gradient' :

                    for (let y = 0; y < height; y++) {
                        for (let x = 0; x < width; x++) {

                            engine.fillStyle = colorFactory.getRangeColor(noiseValues[y][x]);
                            engine.fillRect(x, y, 1, 1);
                        }
                    }
                    break;

                default :

                    if (monochromeRange > 0) {

                        if (monochromeStart + monochromeRange > 255) monochromeRange = 255 - monochromeStart;
                    }
                    else if (monochromeRange < 0) {

                        if (monochromeStart - monochromeRange < 0) monochromeRange = monochromeStart;
                    }

                    for (let y = 0; y < height; y++) {
                        for (let x = 0; x < width; x++) {

                            let gray = Math.floor(monochromeStart + (noiseValues[y][x] * monochromeRange));

                            engine.fillStyle = `rgb(${gray}, ${gray}, ${gray})`;

                            engine.fillRect(x, y, 1, 1);
                        }
                    }
            }
        }
        else this.dirtyOutput = true;
    }
};

P.simplexConstantF = 0.5 * (Math.sqrt(3) - 1);
P.simplexConstantG = (3 - Math.sqrt(3)) / 6;
P.simplexConstantDoubleG = ((3 - Math.sqrt(3)) / 6) * 2;
P.perlinGrad = [[1, 1], [-1, 1], [1, -1], [-1, -1], [1, 0], [-1, 0], [0, 1], [0, -1]];

P.noiseEngines = {

    'perlin': {

        init: function () {

            const {grad, size, rndEngine} = this;

            let dist;
            
            grad.length = 0;

            for(let i = 0; i < size; i++) {

                grad[i] = [(rndEngine.random() * 2) - 1, (rndEngine.random() * 2) - 1];
                dist = Math.sqrt(grad[i][0] *  grad[i][0] + grad[i][1] * grad[i][1]);
                grad[i][0] /= dist;
                grad[i][1] /= dist;
            }
        },

        getNoiseValue: function (x, y) {

            const {size, perm, grad, smoothing} = this;

            let a, b, u, v;

            let bx0 = Math.floor(x) % size,
                bx1 = (bx0 + 1) % size;

            let rx0 = x - Math.floor(x),
                rx1 = rx0 - 1;

            let by0 = Math.floor(y) % size,
                by1 = (by0 + 1) % size;

            let ry0 = y - Math.floor(y),
                ry1 = ry0 - 1;

            let i = perm[bx0],
                j = perm[bx1];

            let b00 = perm[i + by0],
                b10 = perm[j + by0],
                b01 = perm[i + by1],
                b11 = perm[j + by1];

            let sx = smoothing(rx0),
                sy = smoothing(ry0);
            
            u = rx0 * grad[b00][0] + ry0 * grad[b00][1];
            v = rx1 * grad[b10][0] + ry0 * grad[b10][1];
            a = interpolate(sx, u, v);
            
            u = rx0 * grad[b01][0] + ry1 * grad[b01][1];
            v = rx1 * grad[b11][0] + ry1 * grad[b11][1];
            b = interpolate(sx, u, v);
            
            return 0.5 * (1 + interpolate(sy, a, b));
        },
    },

    'improved-perlin': {

        init: λnull,

        getNoiseValue: function (x, y) {

            const {size, perm, permMod8, perlinGrad, smoothing} = this;

            let a, b, u, v;

            let bx0 = Math.floor(x) % size, 
                bx1 = (bx0 + 1) % size;

            let rx0 = x - Math.floor(x), 
                rx1 = rx0 - 1;

            let by0 = Math.floor(y) % size, 
                by1 = (by0 + 1) % size;

            let ry0 = y - Math.floor(y), 
                ry1 = ry0 - 1;

            let i = perm[bx0], 
                j = perm[bx1]; 

            let b00 = permMod8[i + by0], 
                b10 = permMod8[j + by0], 
                b01 = permMod8[i + by1], 
                b11 = permMod8[j + by1];
            
            let sx = smoothing(rx0),
                sy = smoothing(ry0);
            
            u = rx0 * perlinGrad[b00][0] + ry0 * perlinGrad[b00][1];
            v = rx1 * perlinGrad[b10][0] + ry0 * perlinGrad[b10][1];
            a = interpolate(sx, u, v);
            
            u = rx0 * perlinGrad[b01][0] + ry1 * perlinGrad[b01][1];
            v = rx1 * perlinGrad[b11][0] + ry1 * perlinGrad[b11][1];
            b = interpolate(sx, u, v);

            return 0.5 * (1 + interpolate(sy, a, b));
        }
    },

    'simplex': {

        init: λnull,

        getNoiseValue: function (x, y) {

            const getCornerNoise = function (cx, cy, gridPos) {

                let calc = 0.5 - (cx * cx) - (cy * cy);
                if (calc < 0) return 0;

                let [gx, gy] = perlinGrad[gridPos];
                return calc * calc * ((gx * cx) + (gy * cy));
            };
            
            const {simplexConstantF, simplexConstantG, simplexConstantDoubleG, size, perlinGrad, perm, permMod8} = this;
            
            let summedCoordinates = (x + y) * simplexConstantF,
                summedX = Math.floor(x + summedCoordinates),
                summedY = Math.floor(y + summedCoordinates),
                modifiedSummedCoordinates = (summedX + summedY) * simplexConstantG;

            let cornerX = x - (summedX - modifiedSummedCoordinates),
                cornerY = y - (summedY - modifiedSummedCoordinates);
            
            let remainderX = summedX % size,
                remainderY = summedY % size;

            let pos = permMod8[remainderX + perm[remainderY]],
                noise = getCornerNoise(cornerX, cornerY, pos);

            pos = permMod8[remainderX + 1 + perm[remainderY + 1]]
            noise += getCornerNoise((cornerX - 1 + simplexConstantDoubleG), (cornerY - 1 + simplexConstantDoubleG), pos);

            let unitA = 0,
                unitB = 1;

            if (cornerX > cornerY) {
                unitA = 1;
                unitB = 0;
            }

            pos = permMod8[remainderX + unitA + perm[remainderY + unitB]];
            noise += getCornerNoise((cornerX - unitA + simplexConstantG), (cornerY - unitB + simplexConstantG), pos);

            return 0.5 + (35 * noise);
        },
    },

    'value': {

        init: function () {

            const {values, size, rndEngine} = this;

            values.length = 0;

            for(let i = 0; i < size; i++) {

                values[i] = values[i + size] = rndEngine.random();
            }
        },

        getNoiseValue: function (x, y) {

            const {values, size, perm, smoothing} = this;

            let x0 = Math.floor(x) % size,
                y0 = Math.floor(y) % size,
                x1 = (x0 + 1) % size,
                y1 = (y0 + 1) % size,
                vx = x - Math.floor(x),
                vy = y - Math.floor(y),
                sx = smoothing(vx),
                sy = smoothing(vy),
                i = perm[x0],
                j = perm[x1],
                p00 = perm[i + y0],
                p10 = perm[j + y0],
                p01 = perm[i + y1],
                p11 = perm[j + y1],
                i1 = interpolate(sx, values[p00], values[p10]),
                i2 = interpolate(sx, values[p01], values[p11]);

            return interpolate(sy, i1, i2);
        },
    },
};

P.generatePermutationTable = function () {

    const {perm, permMod8, rndEngine, size} = this;

    perm.length = 0;
    permMod8.length = 0;

    let i, j, k;

    for(i = 0; i < size; i++) {

        perm[i] = i;
    }
    
    while (--i) {

        j = Math.floor(rndEngine.random() * size);
        k = perm[i];
        perm[i] = perm[j];
        perm[j] = k;
    }
    
    for(i = 0; i < size; i++) {

        perm[i + size] = perm[i];
        permMod8[i] = permMod8[i + size] = perm[i] % 8;
    }
};

P.octaveFunctions = {

    none: λfirstArg,
    absolute: function (octave) { return Math.abs((octave * 2) - 1) },
};

P.sumFunctions = {

    none: λfirstArg,

    'sine-x': function (v, sx, sy) { return 0.5 + (Math.sin((sx * this.sineFrequencyCoeff) + v) / 2) },
    'sine-y': function (v, sx, sy) { return 0.5 + (Math.sin((sy * this.sineFrequencyCoeff) + v) / 2) },
    sine: function (v, sx, sy) { return 0.5 + (Math.sin((sx * this.sineFrequencyCoeff) + v) / 4) + (Math.sin((sy * this.sineFrequencyCoeff) + v) / 4) },

    modular: function(v) {
        let g = v * this.modularAmplitude;
        return g - Math.floor(g);
    },
};

P.smoothingFunctions = {

    none: λfirstArg,

    easeOutSine,
    easeInSine,
    easeOutInSine,
    easeOutQuad,
    easeInQuad,
    easeOutInQuad,
    easeOutCubic,
    easeInCubic,
    easeOutInCubic,
    easeOutQuart,
    easeInQuart,
    easeOutInQuart,
    easeOutQuint,
    easeInQuint,
    easeOutInQuint,
    easeOutExpo,
    easeInExpo,
    easeOutInExpo,
    easeOutCirc,
    easeInCirc,
    easeOutInCirc,
    easeOutBack,
    easeInBack,
    easeOutInBack,
    easeOutElastic,
    easeInElastic,
    easeOutInElastic,
    easeOutBounce,
    easeInBounce,
    easeOutInBounce,

    cosine: function(t) { return .5 * (1 + Math.cos((1 - t) * Math.PI)) },

    hermite: function(t) { return t * t * (-t * 2 + 3) },

    quintic: function(t) { return t * t * t * (t * (t * 6 - 15) + 10) },
};

const makeNoise = function (items) {
    return new Noise(items);
};

constructors.Noise = Noise;

export {
    makeNoise,
};