SWSnowFlake Class Reference

/*
File: swSnowFlake.js
Date: 2026-05-28
Author: klp + Copilot
Purpose: SWSnowFlake class for SketchWaveJS

A composite procedural snowflake centered on an SWPoint (or SWBug), with
configurable radius, arm count, style, color, and optional border outlines.

Dependencies:
- p5.js
- SWColor
- SWPoint
- SWBug (optional center type)
*/

console.log("[swSnowFlake.js] SWSnowFlake class loaded.");

class SWSnowFlake {
    constructor(center, maxRadius = 6, armCount = 6, flakeColor = undefined, borderColor = undefined, options = {}) {
        if (typeof options === "number") {
            options = { rotationDeg: options };
        }

        this.center = SWSnowFlake.copyCenter(center);
        this.maxRadius = Math.max(0.2, Number(maxRadius) || 6);
        this.armCount = SWSnowFlake.clampArmCount(armCount);

        this.flakeColor = SWSnowFlake.copyColorOrDefault(flakeColor, new SWColor(200, 20, 100, 100, "flakeColor"));
        this.borderColor = SWSnowFlake.copyColorOrDefault(borderColor, new SWColor(210, 35, 65, 100, "flakeBorder"));

        this.borderEnabled = true;
        this.borderThickness = 0.8;
        this.style = "stellarDendrite";
        this.seed = 1;
        this.rotationDeg = Number(options.rotationDeg ?? options.rotation ?? 0) || 0;
        this._animRotDeg = Number(options.animRotationDeg ?? options.animatedRotationDeg ?? 0) || 0;
        this.recursionDepth = SWSnowFlake.clampRecursionDepth(options.recursionDepth ?? 3);
        this.recursiveScale = SWSnowFlake.clampRecursiveScale(options.recursiveScale ?? 0.58);
        this.recursiveBranchAngleDeg = SWSnowFlake.clampRecursiveBranchAngle(options.recursiveBranchAngleDeg ?? 33);

        this.shouldShowCenter = false;
        this.centerMarkerSize = 5;
    }//end constructor

    static allowedStyles() {
        return ["stellarDendrite", "fernDendrite", "plateCrystal", "needleCluster", "kochCrystal", "recursiveDendrite"];
    }//end allowedStyles

    static clampArmCount(n) {
        return Math.max(4, Math.min(16, Math.round(Number(n) || 6)));
    }//end clampArmCount

    static clampRecursionDepth(n) {
        return Math.max(0, Math.min(6, Math.round(Number(n) || 0)));
    }//end clampRecursionDepth

    static clampRecursiveScale(n) {
        const x = Number(n);
        if (!Number.isFinite(x)) return 0.58;
        return Math.max(0.35, Math.min(0.82, x));
    }//end clampRecursiveScale

    static clampRecursiveBranchAngle(n) {
        const x = Number(n);
        if (!Number.isFinite(x)) return 33;
        return Math.max(8, Math.min(85, x));
    }//end clampRecursiveBranchAngle

    static copyCenter(center) {
        if (!(center instanceof SWPoint)) {
            throw new Error("SWSnowFlake expects center to be an SWPoint or SWBug.");
        }

        if (typeof SWBug !== "undefined" && center instanceof SWBug) {
            const strokeColorCopy = center.strokeColor ? SWColor.copy(center.strokeColor) : undefined;
            const bugCopy = new SWBug(center.x, center.y, center.mode, center.speed, strokeColorCopy, {
                noiseAmount: center.noiseAmount,
                strokeWeight: center.strokeWeight,
                trailPersistence: center.trailPersistence,
                shouldWrapAround: center.shouldWrapAround,
            });

            bugCopy.label = center.label;
            bugCopy.showLabel = center.showLabel;
            bugCopy.labelOffset = { x: center.labelOffset.x, y: center.labelOffset.y };
            bugCopy.labelFontSize = center.labelFontSize;
            bugCopy.isDraggable = center.isDraggable;
            bugCopy.penOn = center.penOn;
            bugCopy.maxTrailLength = center.maxTrailLength;
            bugCopy.trail = center.trail.map(function (pt) {
                return { x: pt.x, y: pt.y, z: pt.z };
            });
            bugCopy.setShouldShowTrails(!!center.shouldShowTrails);

            return bugCopy;
        }

        return SWPoint.copy(center);
    }//end copyCenter

    static copyColorOrDefault(swColor, fallbackColor) {
        if (swColor instanceof SWColor) {
            return SWColor.copy(swColor);
        }
        return SWColor.copy(fallbackColor);
    }//end copyColorOrDefault

    static hash01(a, b = 0, c = 0) {
        const x = Math.sin(a * 12.9898 + b * 78.233 + c * 37.719) * 43758.5453;
        return x - Math.floor(x);
    }//end hash01

    setCenter(center) {
        if (center instanceof SWPoint) {
            this.center = SWSnowFlake.copyCenter(center);
        }
    }//end setCenter

    setMaxRadius(r) {
        this.maxRadius = Math.max(0.2, Number(r) || this.maxRadius);
    }//end setMaxRadius

    setArmCount(n) {
        this.armCount = SWSnowFlake.clampArmCount(n);
    }//end setArmCount

    setFlakeColor(swColor) {
        if (swColor instanceof SWColor) this.flakeColor = SWColor.copy(swColor);
    }//end setFlakeColor

    setBorderColor(swColor) {
        if (swColor instanceof SWColor) this.borderColor = SWColor.copy(swColor);
    }//end setBorderColor

    setBorderEnabled(shouldEnable) {
        this.borderEnabled = !!shouldEnable;
    }//end setBorderEnabled

    setBorderThickness(t) {
        this.borderThickness = Math.max(0, Number(t) || 0);
    }//end setBorderThickness

    setStyle(styleName) {
        if (SWSnowFlake.allowedStyles().includes(styleName)) this.style = styleName;
    }//end setStyle

    setSeed(seed) {
        this.seed = Math.max(0, Math.round(Number(seed) || 0));
    }//end setSeed

    setRotationDeg(angleDeg) {
        const n = Number(angleDeg);
        this.rotationDeg = Number.isFinite(n) ? n : this.rotationDeg;
    }//end setRotationDeg

    setRecursionDepth(n) {
        this.recursionDepth = SWSnowFlake.clampRecursionDepth(n);
    }//end setRecursionDepth

    setRecursiveScale(scale) {
        this.recursiveScale = SWSnowFlake.clampRecursiveScale(scale);
    }//end setRecursiveScale

    setRecursiveBranchAngleDeg(angleDeg) {
        this.recursiveBranchAngleDeg = SWSnowFlake.clampRecursiveBranchAngle(angleDeg);
    }//end setRecursiveBranchAngleDeg

    rotateBy(angleDeltaDeg) {
        const n = Number(angleDeltaDeg);
        if (Number.isFinite(n)) {
            this.rotationDeg += n;
        }
    }//end rotateBy

    setAnimatedRotationDeg(angleDeg) {
        const n = Number(angleDeg);
        this._animRotDeg = Number.isFinite(n) ? n : this._animRotDeg;
    }//end setAnimatedRotationDeg

    clearAnimatedRotation() {
        this._animRotDeg = 0;
    }//end clearAnimatedRotation

    get totalRotationDeg() {
        return this.rotationDeg + this._animRotDeg;
    }//end totalRotationDeg

    setShowCenter(show) {
        this.shouldShowCenter = !!show;
    }//end setShowCenter

    setCenterMarkerSize(sz) {
        this.centerMarkerSize = Math.max(1, Number(sz) || this.centerMarkerSize);
    }//end setCenterMarkerSize

    draw() {
        this._drawAt(this.center.x, this.center.y, this.maxRadius);
    }//end draw

    drawOnGrid(grid) {
        if (!grid || typeof grid.userToScreen !== "function") return;
        const pos = grid.userToScreen(this.center.x, this.center.y);
        const rx = this.maxRadius * grid.xScale;
        const ry = this.maxRadius * grid.yScale;
        const rScreen = (rx + ry) / 2;
        this._drawAt(pos.x, pos.y, rScreen);
    }//end drawOnGrid

    // Full drawing helpers omitted here for page brevity.
    // See shapeClasses/swSnowFlake.js for the full method set.

    toString() {
        return `SWSnowFlake(center: ${this.center.toString()}, maxRadius: ${this.maxRadius}, arms: ${this.armCount}, style: ${this.style}, rotation: ${this.totalRotationDeg.toFixed(1)}deg, depth: ${this.recursionDepth}, borderEnabled: ${this.borderEnabled})`;
    }//end toString
}//end class SWSnowFlake