@naniteninja/trait-visual 1.0.1

package/lib/services/stellar-dust-field.d.ts

@@ -0,0 +1,101 @@
+import * as THREE from 'three';
+import { DustMode, DustOptions, DustPaletteOptions, DustPaletteStop } from '../types/dust-field.types';
+export type { DustMode, DustOptions, DustPaletteOptions, DustPaletteStop };
+/**
+ * StellarDustField
+ *
+ * A true 3D, GPU‑animated particle disk that orbits a given center (the sun).
+ * It uses two draw calls: a dense mid/far bed of tiny points and a sparse
+ * foreground bokeh cohort of large, soft discs. Motion is computed fully on
+ * the GPU (vertex shader) from per‑particle attributes; the CPU only updates
+ * a few uniforms per frame.
+ */
+export declare class StellarDustField {
+    private scene;
+    private group;
+    private points;
+    private readonly MAX_ATTRACTORS;
+    private readonly MAX_PALETTE_STOPS;
+    private attractorWorldPos;
+    private attractorWorldRad;
+    private attractorLocalPos;
+    private attractorRadius;
+    private nearRadiusFactor;
+    private stickEpsRel;
+    private stickEpsMin;
+    private stickEpsMax;
+    private attractStrength;
+    private tangentialBias;
+    private debugDustTouch;
+    private lastDustLogMs;
+    private useAttract;
+    private debugLogPalette;
+    private debugLogBands;
+    private debugEdgeMix;
+    private debugDimLights;
+    private whitenScale;
+    private alphaScale;
+    private paletteStops;
+    private paletteHueBiasScale;
+    private paletteBackgroundLift;
+    private paletteCoreIntensity;
+    private paletteUniformColors;
+    private paletteUniformStops;
+    private paletteUniformIntensities;
+    private paletteUniformCount;
+    private diskFraction;
+    private diskBokehFraction;
+    private haloRadiusMultiplier;
+    private armCount;
+    private armPopulation;
+    private armSpread;
+    private armTwist;
+    private haloArmPopulation;
+    private haloArmSpread;
+    private haloArmTwist;
+    private dustMode;
+    private sphereJitter;
+    private static readonly DEFAULT_PALETTE;
+    private opts;
+    private time;
+    private viewportHeight;
+    constructor(scene: THREE.Scene, options?: DustOptions);
+    setBrightnessScale(scale: number): void;
+    setWhitenScale(scale: number): void;
+    setBrightness(value01: number): void;
+    applyOptions(o: DustOptions): void;
+    setMode(mode: DustMode): void;
+    setSphereParameters(params: {
+        jitter?: number;
+    }): void;
+    setDiskNormal(normal: THREE.Vector3): void;
+    setViewportHeight(h: number): void;
+    private buildPaletteFromLegacyColors;
+    private applyPalette;
+    private syncLegacyColorsFromPalette;
+    private updatePaletteUniformsOnMaterials;
+    private samplePaletteAt;
+    private colorToHexString;
+    logPaletteRamp(samples?: number): void;
+    private logDiskBandStats;
+    private refreshPaletteUniformData;
+    update(dt: number, center: THREE.Vector3): void;
+    dispose(): void;
+    /**
+     * Provide world-space node centers and radii; internally converted to
+     * dust-local coordinates and pushed to shader uniforms.
+     */
+    setAttractorsWorld(attractors: {
+        position: THREE.Vector3;
+        radius: number;
+    }[]): void;
+    setAttractEnabled(enabled: boolean): void;
+    private build;
+    private makeCohort;
+    private makeMaterial;
+    private valueNoise2D;
+    private samplePeriodicFbm;
+    private sampleAndLogContacts;
+    private hashFloat;
+    private syncAttractorUniforms;
+}

package/lib/trait-visual.component.d.ts

@@ -0,0 +1,73 @@
+import { ElementRef, OnInit, AfterViewInit, OnDestroy, Renderer2, NgZone, OnChanges, SimpleChanges } from '@angular/core';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { INodeData } from './app.types';
+import { Cluster } from './objects/Cluster';
+import { Node } from './objects/Node';
+import * as i0 from "@angular/core";
+export declare class TraitVisualComponent implements OnInit, AfterViewInit, OnDestroy, OnChanges {
+    private renderer2;
+    private ngZone;
+    canvasRef: ElementRef;
+    nodeData: INodeData[];
+    attributeWeights: number[];
+    preferenceWeights: number[];
+    attributeCount?: number;
+    preferenceCount?: number;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    renderer: THREE.WebGLRenderer;
+    controls: OrbitControls;
+    raycaster: THREE.Raycaster;
+    mouse: THREE.Vector2;
+    cluster: Cluster;
+    selectedNode: Node | null;
+    draggingNode: Node | null;
+    dragPlane: THREE.Plane;
+    dragOffset: THREE.Vector3;
+    newNodeCounter: number;
+    isCameraLocked: boolean;
+    private nodeAuras;
+    private starFieldNear;
+    private starFieldFar;
+    private starTexture;
+    private dustField;
+    private readonly pointerPitchAxis;
+    private readonly pointerYawAxis;
+    private pointerPitchCurrent;
+    private pointerPitchTarget;
+    private pointerYawCurrent;
+    private pointerYawTarget;
+    private pointerYawAccumulated;
+    private readonly pointerOffset;
+    private readonly pointerPitchMax;
+    private readonly pointerYawMax;
+    private readonly pointerYawSpeed;
+    private readonly pointerPitchDamping;
+    private readonly pointerYawDamping;
+    constructor(renderer2: Renderer2, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    currentCentral(): Node | null;
+    nonSuns(): Node[];
+    private syncNodeWeightGlobals;
+    private initScene;
+    private loadNodes;
+    private onWindowResize;
+    private onRightClick;
+    private onMouseMove;
+    private onDragStart;
+    private onDragMove;
+    private onDragEnd;
+    private onCanvasLeave;
+    private resetPointerPitch;
+    private updateCameraOrbitFromPointer;
+    private animate;
+    private ensureNodeAuras;
+    private createStarField;
+    private getStarTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TraitVisualComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TraitVisualComponent, "tv-trait-visual", never, { "nodeData": { "alias": "nodeData"; "required": false; }; "attributeWeights": { "alias": "attributeWeights"; "required": false; }; "preferenceWeights": { "alias": "preferenceWeights"; "required": false; }; "attributeCount": { "alias": "attributeCount"; "required": false; }; "preferenceCount": { "alias": "preferenceCount"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/types/dust-field.types.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+export type DustMode = 'disk' | 'sphere';
+export interface DustPaletteStop {
+    /**
+     * Normalized radial position within the dust field (0 = core, 1 = outer edge).
+     */
+    at: number;
+    /**
+     * Color at this stop. Accepts any THREE color representation.
+     */
+    color: THREE.ColorRepresentation;
+    /**
+     * Optional intensity multiplier applied when lerping between stops.
+     * Defaults to 1.0.
+     */
+    intensity?: number;
+}
+export interface DustPaletteOptions {
+    /**
+     * Ordered palette stops that describe the desired color ramp.
+     * Values outside [0, 1] will be clamped.
+     */
+    stops: DustPaletteStop[];
+    /**
+     * Strength multiplier for hue bias modulation in the shader.
+     * Defaults to 0.65.
+     */
+    hueBiasScale?: number;
+    /**
+     * Minimum luminance floor to keep blacks saturated but not crushed.
+     * Defaults to 0.06.
+     */
+    backgroundLift?: number;
+    /**
+     * Maximum brightness applied to the core (radialT ~ 0).
+     * Defaults to 1.4.
+     */
+    coreIntensity?: number;
+}
+export interface DustOptions {
+    innerRadius?: number;
+    outerRadius?: number;
+    thickness?: number;
+    countMidFar?: number;
+    countBokeh?: number;
+    minAngularVel?: number;
+    maxAngularVel?: number;
+    noiseStrength?: number;
+    colorInner?: THREE.ColorRepresentation;
+    colorMid?: THREE.ColorRepresentation;
+    colorOuter?: THREE.ColorRepresentation;
+    palette?: DustPaletteOptions;
+    renderOrder?: number;
+}
+export type Cohort = 'disk' | 'diskBokeh' | 'halo' | 'haloBokeh';

package/lib/types/glow.types.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+export type GlowUniforms = {
+    glowColor: {
+        value: THREE.Color;
+    };
+    opacity: {
+        value: number;
+    };
+    c?: {
+        value: number;
+    };
+    p?: {
+        value: number;
+    };
+    base?: {
+        value: number;
+    };
+};

package/lib/types/particle-field.types.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+export interface ParticleFieldOptions {
+    coreRadius: number;
+    particleCount?: number;
+    palette?: 'sun' | 'planet';
+    distribution?: 'surface' | 'banded';
+    speedScale?: number;
+}
+export interface FlowParticle {
+    type: 'topCurve' | 'bottomCurve' | 'orbit' | 'topCap' | 'bottomCap' | 'surface';
+    radius: number;
+    angle: number;
+    angularSpeed: number;
+    radialJitterAmp: number;
+    radialJitterFreq: number;
+    verticalOffset?: number;
+    size: number;
+    color: THREE.Color;
+    opacity: number;
+    lifetime: number;
+    age: number;
+    ellipse: number;
+    upBias: number;
+    depthBias: number;
+    wigglePhase: number;
+    wiggleFreqUp: number;
+    wiggleFreqDepth: number;
+    capRadBias?: number;
+    arcUpAmp: number;
+    arcDepthAmp: number;
+    arcRadAmp: number;
+    arcFreq: number;
+    angleWanderAmp: number;
+    angleWanderFreq: number;
+    angleWanderPhase: number;
+    tiltUF?: number;
+    phi?: number;
+    thetaMargin?: number;
+    frontCurveAngle?: number;
+    phiAmp?: number;
+    axis?: THREE.Vector3;
+    u?: THREE.Vector3;
+    v?: THREE.Vector3;
+    dirSign?: 1 | -1;
+    precessAxis?: THREE.Vector3;
+    precessSpeed?: number;
+    baseOmega?: number;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@naniteninja/trait-visual",
+  "version": "1.0.1",
+  "description": "Angular library for visualizing trait-based relationships in 3D space using Three.js",
+  "keywords": [
+    "angular",
+    "three.js",
+    "visualization",
+    "3d",
+    "traits",
+    "pca",
+    "personality",
+    "test"
+  ],
+  "author": "naniteninja",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/naniteninja/trait-visual.git"
+  },
+  "peerDependencies": {
+    "@angular/common": "^19.2.0",
+    "@angular/core": "^19.2.0"
+  },
+  "dependencies": {
+    "three": "^0.174.0",
+    "ml-pca": "^4.1.1",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/naniteninja-trait-visual.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/naniteninja-trait-visual.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/trait-visual.component';
+export * from './lib/app.types';
+export { dynamicCounts, updateCounts, attributeWeights, nodeData } from './lib/data/nodes.data';