☀️ SketchWave Sun Class Reference

/*
File:    swSun.js
Date:    2026-05-18
Author:  klp
Workspace: SketchWaveTNT2026-05-01-Stg9
Purpose: SWSun class — a styled sun (or moon) with a central SWDisk ball,
         optional radiating shapes, a soft multi-layer glow, and support
         for breathing, rotation, and sinusoid ripple animations.

Dependencies: p5.js, swColor.js, swPoint.js, swDisk.js,
              swLine.js, swArrow.js, swTriangle.js
*/

console.log("[swSun.js] SWSun class loaded.");

class SWSun {

    constructor(cx, cy, ballRadius, ballFillColor, options = {}) {
        this.cx = cx;
        this.cy = cy;
        this.ballRadius         = ballRadius;
        this.originalBallRadius = ballRadius;

        // ── Ball styling ──────────────────────────────────────────────────
        this.ballFillColor   = ballFillColor           ? SWColor.copy(ballFillColor)           : undefined;
        this.ballStrokeColor = options.ballStrokeColor ? SWColor.copy(options.ballStrokeColor) : undefined;
        this.ballThickness   = options.ballThickness  ?? 2;

        // ── Ball visibility ────────────────────────────────────────────────
        this.showBall   = options.showBall   ?? true;

        // ── Glow ──────────────────────────────────────────────────────────
        this.showGlow   = options.showGlow   ?? true;
        this.glowColor  = options.glowColor
                          ? SWColor.copy(options.glowColor)
                          : (ballFillColor ? SWColor.copy(ballFillColor) : undefined);
        this.glowScale  = options.glowScale  ?? 2.5;
        this.glowLayers = options.glowLayers ?? 5;
        this.glowAlpha  = options.glowAlpha  ?? 35;

        // ── Ray styling ───────────────────────────────────────────────────
        this.showRays       = options.showRays      ?? true;
        this.rayType        = options.rayType       ?? "sinusoid";
        this.rayCount       = options.rayCount      ?? 8;
        this.rayLength      = options.rayLength     ?? ballRadius * 1.5;
        this.originalRayLength = this.rayLength;
        this.rayThickness   = options.rayThickness  ?? 3;

        if (options.rayColors && options.rayColors.length > 0) {
            this.rayColors = options.rayColors.slice(0, 5).map(c => c ? SWColor.copy(c) : undefined);
        } else {
            this.rayColors = [ballFillColor ? SWColor.copy(ballFillColor) : undefined];
        }

        // ── Sinusoid ray options ──────────────────────────────────────────
        this.sinAmplitude  = options.sinAmplitude  ?? ballRadius * 0.25;
        this.sinPeriods   = options.sinPeriods   ?? 2.5;
        this.sinPhase     = 0;
        this.rippleOutward = options.rippleOutward ?? true;   // true = waves travel away from sun

        // ── Triangle ray options ──────────────────────────────────────────
        this.triWidth = options.triWidth ?? ballRadius * 0.5;

        // ── Arrow ray options ─────────────────────────────────────────────
        this.arrowTipAngle  = options.arrowTipAngle  ?? 25;
        this.arrowTipFactor = options.arrowTipFactor ?? 0.35;

        // ── Internal animation state ──────────────────────────────────────
        this._rotationAngle    = 0;
        this._currentRadius    = ballRadius;
        this._currentRayLength = this.rayLength;

        this._buildDisk();
    }//end constructor

    _buildDisk() {
        const center = new SWPoint(this.cx, this.cy, undefined, 0, this.ballStrokeColor);
        this.disk = new SWDisk(
            center, this._currentRadius,
            this.ballThickness, this.ballFillColor, this.ballStrokeColor
        );
        this.disk.shouldShowCenter = false;
    }

    draw() {
        this._drawAtPosition(this.cx, this.cy, this._currentRadius, this._currentRayLength);
    }

    drawOnGrid(grid) {
        const { x: sx, y: sy } = grid.userToScreen(this.cx, this.cy);
        const sr  = this._currentRadius    * grid.xScale;
        const srl = this._currentRayLength * grid.xScale;
        this._drawAtPosition(sx, sy, sr, srl);
    }

    _drawAtPosition(cx, cy, ballR, rayLen) {
        if (this.showGlow) this._drawGlow(cx, cy, ballR);
        if (this.showRays && this.rayCount > 0 && rayLen > 0) this._drawRays(cx, cy, ballR, rayLen);
        this.disk.center.x = cx;
        this.disk.center.y = cy;
        this.disk.radius   = ballR;
        if (this.showBall) {
            fill(0, 0, 0, 0);
            this.disk.draw();
        }
    }

    _drawGlow(cx, cy, ballR) {
        const gc = this.glowColor;
        if (!gc) return;
        push();
        noStroke();
        for (let i = 0; i < this.glowLayers; i++) {
            const t = (this.glowLayers > 1) ? i / (this.glowLayers - 1) : 1;
            const r = ballR * lerp(this.glowScale, 1.08, t);
            const a = lerp(0, this.glowAlpha, t);
            if (a > 0.4) { fill(gc.h, gc.s, gc.b, a); ellipse(cx, cy, r * 2, r * 2); }
        }
        pop();
    }

    _drawRays(cx, cy, ballR, rayLen) {
        const angleStep = 360 / this.rayCount;
        for (let i = 0; i < this.rayCount; i++) {
            const angleDeg = i * angleStep + this._rotationAngle;
            const col      = this.rayColors[i % this.rayColors.length];
            this._drawSingleRay(cx, cy, ballR, rayLen, angleDeg, col);
        }
    }

    _drawSingleRay(cx, cy, ballR, rayLen, angleDeg, swColor) {
        switch (this.rayType) {
            case "line":     this._drawLineRay    (cx, cy, ballR, rayLen, angleDeg, swColor); break;
            case "arrow":    this._drawArrowRay   (cx, cy, ballR, rayLen, angleDeg, swColor); break;
            case "triangle": this._drawTriangleRay(cx, cy, ballR, rayLen, angleDeg, swColor); break;
            case "sinusoid":
            default:         this._drawSinusoidRay(cx, cy, ballR, rayLen, angleDeg, swColor); break;
        }
    }

    _drawLineRay(cx, cy, ballR, rayLen, angleDeg, swColor) {
        const ar  = radians(angleDeg);
        const gap = ballR + this.ballThickness * 0.5;
        push();
        if (swColor && swColor.col) stroke(swColor.col); else noStroke();
        strokeWeight(this.rayThickness);
        strokeCap(ROUND);
        noFill();
        line(cx + cos(ar)*gap, cy + sin(ar)*gap,
             cx + cos(ar)*(gap+rayLen), cy + sin(ar)*(gap+rayLen));
        pop();
    }

    _drawArrowRay(cx, cy, ballR, rayLen, angleDeg, swColor) {
        const ar  = radians(angleDeg);
        const gap = ballR + this.ballThickness * 0.5;
        const ptA = new SWPoint(cx+cos(ar)*gap,         cy+sin(ar)*gap,         undefined, 0, swColor);
        const ptB = new SWPoint(cx+cos(ar)*(gap+rayLen),cy+sin(ar)*(gap+rayLen),undefined, 0, swColor);
        push();
        const arrow = new SWArrow(ptA, ptB, this.rayThickness, swColor,
                                  this.arrowTipAngle, this.arrowTipFactor);
        arrow.shouldShowMidpoint  = false;
        arrow.shouldShowTailPoint = false;
        arrow.draw();
        pop();
    }

    _drawTriangleRay(cx, cy, ballR, rayLen, angleDeg, swColor) {
        const ar    = radians(angleDeg);
        const perp  = ar + HALF_PI;
        const gap   = ballR + this.ballThickness * 0.5;
        const halfW = this.triWidth / 2;
        const tipX  = cx + cos(ar) * (gap + rayLen);
        const tipY  = cy + sin(ar) * (gap + rayLen);
        const baseX = cx + cos(ar) * gap;
        const baseY = cy + sin(ar) * gap;
        const ptTip   = new SWPoint(tipX, tipY);
        const ptLeft  = new SWPoint(baseX + cos(perp)*halfW, baseY + sin(perp)*halfW);
        const ptRight = new SWPoint(baseX - cos(perp)*halfW, baseY - sin(perp)*halfW);
        push();
        const fillC = swColor || new SWColor(55, 80, 100, 100, "rayFill");
        const tri   = new SWTriangle(ptTip, ptLeft, ptRight, fillC,
                                     { strokeColor:fillC, strokeWeight:1,
                                       showVertices:false, showCentroid:false });
        tri.draw();
        pop();
    }

    _drawSinusoidRay(cx, cy, ballR, rayLen, angleDeg, swColor) {
        const ar    = radians(angleDeg);
        const perp  = ar + HALF_PI;
        const gap   = ballR + this.ballThickness * 0.5;
        const nPts  = 40;
        const bFreq = (TWO_PI * this.sinPeriods) / rayLen;
        push();
        if (swColor && swColor.col) stroke(swColor.col); else noStroke();
        strokeWeight(this.rayThickness);
        strokeCap(ROUND);
        strokeJoin(ROUND);
        noFill();
        beginShape();
        for (let i = 0; i <= nPts; i++) {
            const t      = i / nPts;
            const d      = gap + t * rayLen;
            const taper  = sin(t * PI);
            const phaseSign = this.rippleOutward ? -1 : 1;
            const offset = sin(bFreq * t * rayLen + phaseSign * this.sinPhase) * this.sinAmplitude * taper;
            vertex(cx + cos(ar)*d + cos(perp)*offset,
                   cy + sin(ar)*d + sin(perp)*offset);
        }
        endShape();
        pop();
    }

    breathe(sinusoid, t) {
        const scale            = sinusoid.getValue(t);
        this._currentRadius    = this.originalBallRadius * scale;
        this._currentRayLength = this.originalRayLength  * scale;
        this.disk.radius       = this._currentRadius;
    }

    rotateRays(degPerSec, t)      { this._rotationAngle = degPerSec * t; }
    animateSinusoid(phaseDegPerSec, t) { this.sinPhase = radians(phaseDegPerSec) * t; }

    transform({ sinusoid=null, t=0, degPerSec=null, phaseDegPerSec=null } = {}) {
        if (sinusoid       !== null) this.breathe(sinusoid, t);
        if (degPerSec      !== null) this.rotateRays(degPerSec, t);
        if (phaseDegPerSec !== null) this.animateSinusoid(phaseDegPerSec, t);
    }

    reset() {
        this._currentRadius    = this.originalBallRadius;
        this._currentRayLength = this.originalRayLength;
        this._rotationAngle    = 0;
        this.sinPhase          = 0;
        this.disk.radius       = this.originalBallRadius;
    }

    setCenter(cx, cy)     { this.cx = cx; this.cy = cy; }
    setBallRadius(r)      {
        this.ballRadius = this.originalBallRadius = this._currentRadius = r;
        this.disk.setRadius(r);
    }
    setBallFillColor(swColor)   { this.ballFillColor   = swColor ? SWColor.copy(swColor) : undefined; this.disk.setFillColor(swColor);   }
    setBallStrokeColor(swColor) { this.ballStrokeColor = swColor ? SWColor.copy(swColor) : undefined; this.disk.setStrokeColor(swColor); }
    setGlowColor(swColor)  { this.glowColor  = swColor ? SWColor.copy(swColor) : undefined; }
    setGlowAlpha(a)        { this.glowAlpha  = constrain(a, 0, 100); }
    setGlowScale(s)        { this.glowScale  = max(1.05, s); }
    setRayType(type)       { this.rayType    = type; }
    setRayCount(count)     { this.rayCount   = max(0, Math.round(count)); }
    setRayLength(len)      {
        this.rayLength = this.originalRayLength = this._currentRayLength = len;
    }
    setRayThickness(w)     { this.rayThickness  = max(1, w); }
    setRayColors(arr)      { if (arr && arr.length) this.rayColors = arr.slice(0,5).map(c => c ? SWColor.copy(c) : undefined); }
    setSinAmplitude(a)     { this.sinAmplitude  = max(0, a); }
    setSinPeriods(p)       { this.sinPeriods    = max(0.25, p); }
    setRippleOutward(v)    { this.rippleOutward = !!v; }
    setTriWidth(w)         { this.triWidth      = max(1, w); }

    toString() {
        return `SWSun(cx:${this.cx.toFixed(1)}, cy:${this.cy.toFixed(1)}, ` +
               `r:${this.ballRadius.toFixed(1)}, rays:${this.rayCount}×${this.rayType})`;
    }

}//end class SWSun