Cog factory

import { constructors } from '../core/library.js';
import { addStrings, doCreate, mergeOver, Ωempty } from '../helper/utilities.js';

import { releaseVector, requestVector } from '../untracked-factory/vector.js';

import baseMix from '../mixin/base.js';
import shapeMix from '../mixin/shape-basic.js';

import { BEZIER, ENTITY, QUADRATIC, ZERO_PATH, ZERO_STR } from '../helper/shared-vars.js';

const PERMITTED_CURVES = ['line', 'quadratic', 'bezier'],
    T_COG = 'Cog';

const Cog = function (items = Ωempty) {

    this.shapeInit(items);
    return this;
};

const P = Cog.prototype = doCreate();
P.type = T_COG;
P.lib = ENTITY;
P.isArtefact = true;
P.isAsset = false;

baseMix(P);
shapeMix(P);

const defaultAttributes = {

    outerRadius: 0,
    innerRadius: 0,
    outerControlsDistance: 0,
    innerControlsDistance: 0,
    outerControlsOffset: 0,
    innerControlsOffset: 0,
    points: 0,
    twist: 0,
    curve: BEZIER,
};
P.defs = mergeOver(P.defs, defaultAttributes);

const S = P.setters,
    D = P.deltaSetters;

S.outerRadius = function (item) {

    this.outerRadius = item;
    this.updateDirty();
};
D.outerRadius = function (item) {

    this.outerRadius = addStrings(this.outerRadius, item);
    this.updateDirty();
};
S.innerRadius = function (item) {

    this.innerRadius = item;
    this.updateDirty();
};
D.innerRadius = function (item) {

    this.innerRadius = addStrings(this.innerRadius, item);
    this.updateDirty();
};

S.outerControlsDistance = function (item) {

    this.outerControlsDistance = item;
    this.updateDirty();
};
D.outerControlsDistance = function (item) {

    this.outerControlsDistance = addStrings(this.outerControlsDistance, item);
    this.updateDirty();
};
S.innerControlsDistance = function (item) {

    this.innerControlsDistance = item;
    this.updateDirty();
};
D.innerControlsDistance = function (item) {

    this.innerControlsDistance = addStrings(this.innerControlsDistance, item);
    this.updateDirty();
};

S.outerControlsOffset = function (item) {

    this.outerControlsOffset = item;
    this.updateDirty();
};
D.outerControlsOffset = function (item) {

    this.outerControlsOffset = addStrings(this.outerControlsOffset, item);
    this.updateDirty();
};
S.innerControlsOffset = function (item) {

    this.innerControlsOffset = item;
    this.updateDirty();
};
D.innerControlsOffset = function (item) {

    this.innerControlsOffset = addStrings(this.innerControlsOffset, item);
    this.updateDirty();
};

S.points = function (item) {

    this.points = item;
    this.updateDirty();
};
D.points = function (item) {

    this.points += item;
    this.updateDirty();
};

S.twist = function (item) {

    this.twist = item;
    this.updateDirty();
};
D.twist = function (item) {

    this.twist += item;
    this.updateDirty();
};

S.curve = function (item) {

    if (item && PERMITTED_CURVES.includes(item)) this.curve = item;
    else this.curve = BEZIER;

    this.updateDirty();
};

P.cleanSpecies = function () {

    this.dirtySpecies = false;
    this.pathDefinition = this.makeCogPath();
};

P.makeCogPath = function () {

    const { points, twist, curve } = this;

    let { outerRadius, innerRadius, outerControlsDistance, innerControlsDistance, outerControlsOffset, innerControlsOffset } = this;

    const turn = 360 / points;

    let currentPointX, currentPointY, deltaX, deltaY, i,
        myPath = ZERO_STR;

    if (outerRadius.substring || innerRadius.substring || outerControlsDistance.substring || innerControlsDistance.substring || outerControlsOffset.substring || innerControlsOffset.substring) {

        const host = this.getHost();

        if (host) {

            const [hW] = host.currentDimensions;

            outerRadius = (outerRadius.substring) ? (parseFloat(outerRadius) / 100) * hW : outerRadius;
            innerRadius = (innerRadius.substring) ? (parseFloat(innerRadius) / 100) * hW : innerRadius;
            outerControlsDistance = (outerControlsDistance.substring) ? (parseFloat(outerControlsDistance) / 100) * hW : outerControlsDistance;
            innerControlsDistance = (innerControlsDistance.substring) ? (parseFloat(innerControlsDistance) / 100) * hW : innerControlsDistance;
            outerControlsOffset = (outerControlsOffset.substring) ? (parseFloat(outerControlsOffset) / 100) * hW : outerControlsOffset;
            innerControlsOffset = (innerControlsOffset.substring) ? (parseFloat(innerControlsOffset) / 100) * hW : innerControlsOffset;
        }
    }

    const outerPoint = requestVector({x: 0, y: -outerRadius}),
        innerPoint = requestVector({x: 0, y: -innerRadius}),
        outerPointLead = requestVector({x: outerControlsDistance + outerControlsOffset, y: -outerRadius}),
        innerPointTrail = requestVector({x: -innerControlsDistance + innerControlsOffset, y: -innerRadius}),
        innerPointLead = requestVector({x: innerControlsDistance + innerControlsOffset, y: -innerRadius}),
        outerPointTrail = requestVector({x: -outerControlsDistance + outerControlsOffset, y: -outerRadius});

    innerPointTrail.rotate(-turn/2);
    innerPointTrail.rotate(twist);
    innerPoint.rotate(-turn/2);
    innerPoint.rotate(twist);
    innerPointLead.rotate(-turn/2);
    innerPointLead.rotate(twist);

    currentPointX = outerPoint.x;
    currentPointY = outerPoint.y;

    if (curve === BEZIER) {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            innerPointTrail.rotate(turn);
            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPointTrail.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointTrail.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            outerPointTrail.rotate(turn);
            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPointTrail.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointTrail.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    else if (curve === QUADRATIC) {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    else {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            innerPointTrail.rotate(turn);
            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPointTrail.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((innerPointTrail.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            outerPointTrail.rotate(turn);
            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPointTrail.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((outerPointTrail.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    releaseVector(outerPoint, outerPointLead, outerPointTrail, innerPoint, innerPointLead, innerPointTrail);

    if (curve === BEZIER) return `${ZERO_PATH}c${myPath}z`;
    if (curve === QUADRATIC) return `${ZERO_PATH}q${myPath}z`;
    return `${ZERO_PATH}l${myPath}z`;
};

P.calculateLocalPathAdditionalActions = function () {

    let scale = this.scale;

    if (scale < 0.001) scale = 0.001;

    const [x, y] = this.localBox;

    this.pathDefinition = this.pathDefinition.replace(ZERO_PATH, `m${-x / scale},${-y / scale}`);

    this.pathCalculatedOnce = false;

    this.calculateLocalPath(this.pathDefinition, true);
};

export const makeCog = function (items) {

    if (!items) return false;
    items.species = 'cog';
    return new Cog(items);
};

constructors.Cog = Cog;