@3driseai/3drise-core 1.0.20 → 1.0.21

package/dist/data/gridsDefaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridsDefaults.d.ts","sourceRoot":"","sources":["../../src/data/gridsDefaults.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAiR/E,CAAC"}
+{"version":3,"file":"gridsDefaults.d.ts","sourceRoot":"","sources":["../../src/data/gridsDefaults.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAkZ/E,CAAC"}

package/dist/data/gridsDefaults.js

@@ -287,4 +287,133 @@ export const GRIDS_ANIMATABLE = {
         { value: 'glowColor', label: 'Glow Color' },
         { value: 'bgColor', label: 'Bg Color' },
     ],
+    lensingGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'mass', label: 'Mass' },
+        { value: 'orbit', label: 'Orbit' },
+        { value: 'ringGlow', label: 'Ring Glow' },
+    ],
+    conformalGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'poleSpread', label: 'Pole Spread' },
+        { value: 'circulation', label: 'Circulation' },
+        { value: 'drift', label: 'Drift' },
+        { value: 'fill', label: 'Fill' },
+        { value: 'dye', label: 'Dye' },
+    ],
+    truchetGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'flip', label: 'Flip' },
+        { value: 'bias', label: 'Bias' },
+        { value: 'pulse', label: 'Pulse' },
+        { value: 'regionFill', label: 'Region Fill' },
+    ],
+    phyllotaxisGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'divergence', label: 'Divergence' },
+        { value: 'bloomRate', label: 'Bloom Rate' },
+        { value: 'relief', label: 'Relief' },
+        { value: 'shapeSize', label: 'Shape Size' },
+        { value: 'shapeGlow', label: 'Shape Glow' },
+    ],
+    parastichyGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'divergence', label: 'Divergence' },
+        { value: 'third', label: 'Third' },
+        { value: 'sap', label: 'Sap' },
+        { value: 'fill', label: 'Fill' },
+    ],
+    apollonianGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'morph', label: 'Morph' },
+    ],
+    hilbertGrid: [
+        { value: 'cellSize', label: 'Cell Size' },
+        { value: 'lineWidth', label: 'Line Width' },
+        { value: 'sectionWidth', label: 'Section Width' },
+        { value: 'animSpeed', label: 'Anim Speed' },
+        { value: 'animScale', label: 'Anim Scale' },
+        { value: 'animIntensity', label: 'Anim Intensity' },
+        { value: 'fadeStrength', label: 'Fade Strength' },
+        { value: 'bgOpacity', label: 'Bg Opacity' },
+        { value: 'lineColor', label: 'Line Color' },
+        { value: 'sectionColor', label: 'Section Color' },
+        { value: 'cellColor', label: 'Cell Color' },
+        { value: 'glowColor', label: 'Glow Color' },
+        { value: 'bgColor', label: 'Bg Color' },
+        { value: 'trail', label: 'Trail' },
+        { value: 'signalSpeed', label: 'Signal Speed' },
+    ],
 };

package/dist/properties/tables/gridProperties.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridProperties.d.ts","sourceRoot":"","sources":["../../../src/properties/tables/gridProperties.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAiB7D,4CAA4C;AAC5C,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,EAwBrD,CAAC;AAmFF,sFAAsF;AACtF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAE9D,CAAC"}
+{"version":3,"file":"gridProperties.d.ts","sourceRoot":"","sources":["../../../src/properties/tables/gridProperties.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAiB7D,4CAA4C;AAC5C,eAAO,MAAM,uBAAuB,EAAE,gBAAgB,EAwBrD,CAAC;AAiKF,sFAAsF;AACtF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAE9D,CAAC"}

package/dist/properties/tables/gridProperties.js

@@ -117,5 +117,83 @@ const own = {
         { name: 'tileCells', description: 'Cells covered by one simulation tile', type: 'number', min: 1, max: 20, step: 1 },
     ],
 };
+/**
+ * Grids that always lie flat (the parent object's transform orients them) and
+ * leave pointer behaviour to the Pointer tab: their surface rows have no `flat`
+ * and no `followMouse`. `section` re-describes `sectionSize` where the grid
+ * gives it its own meaning (spiral count, bloom rings, inversion levels).
+ */
+const SURFACE_PARENT_ORIENTED = GRID_SURFACE_PROPERTIES.filter((p) => p.name !== 'flat' && p.name !== 'followMouse');
+const surfaceFor = (section) => section ? SURFACE_PARENT_ORIENTED.map((p) => (p.name === 'sectionSize' ? { ...p, ...section } : p)) : SURFACE_PARENT_ORIENTED;
+const parentOriented = {
+    lensingGrid: {
+        own: [
+            { name: 'mass', description: "Einstein radius of the lens, in cells; 0 leaves the lattice undistorted", type: 'number', min: 0, max: 12, step: 0.1 },
+            { name: 'orbit', description: "Radius the lens circles the centre on, in cells; 0 holds it at the centre", type: 'number', min: 0, max: 15, step: 0.1 },
+            { name: 'ringGlow', description: "Brightness of the Einstein ring and its halo", type: 'number', min: 0, max: 3, step: 0.05 },
+        ],
+    },
+    conformalGrid: {
+        own: [
+            { name: 'flowMap', description: "The flow: 0 source + sink, 1 spiral vortex, 2 spinning cylinder, 3 corner", type: 'select', options: ['0', '1', '2', '3'], optionLabels: ['Source + sink', 'Spiral vortex', 'Spinning cylinder', 'Corner'] },
+            { name: 'poleSpread', description: "Distance from the centre to the poles, or the cylinder radius, in world units", type: 'number', min: 1, max: 25, step: 0.1 },
+            { name: 'spokes', description: "Lattice lines per turn round a pole (whole number, so the log seam closes)", type: 'number', min: 4, max: 64, step: 1 },
+            { name: 'arms', description: "Spiral arms of the vortex flow; 0 gives a plain polar web", type: 'number', min: -8, max: 8, step: 1 },
+            { name: 'circulation', description: "Circulation round the cylinder (lift); at ±2 both stagnation points meet", type: 'number', min: -3, max: 3, step: 0.01 },
+            { name: 'drift', description: "How fast the lattice streams along the flow; negative reverses it", type: 'number', min: -1, max: 1, step: 0.01 },
+            { name: 'fill', description: "Strength of the speed-coloured stream-tube fill", type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'dye', description: "Brightness of the dashes carried along the streamlines", type: 'number', min: 0, max: 2, step: 0.01 },
+        ],
+        section: { description: "Streamlines per accent streamline" },
+    },
+    truchetGrid: {
+        own: [
+            { name: 'flip', description: "Chance a tile re-deals its orientation each epoch; 0 freezes the paths", type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'bias', description: "Balance of the two tile orientations: 0.5 is a maze, the ends are stripes", type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'pulse', description: "Brightness of the comets travelling the loops", type: 'number', min: 0, max: 2, step: 0.01 },
+            { name: 'regionFill', description: "Fill of one colour of the two-colouring", type: 'number', min: 0, max: 1, step: 0.01 },
+        ],
+        section: { description: "Tiles per tile of the coarser Truchet accent layer" },
+    },
+    phyllotaxisGrid: {
+        own: [
+            { name: 'divergence', description: "Angle between successive seeds, degrees; 137.508 is the golden angle", type: 'number', min: 130, max: 145, step: 0.001 },
+            { name: 'bloomRate', description: "Speed of the bloom rings travelling rim to centre; negative reverses them", type: 'number', min: -0.3, max: 0.3, step: 0.001 },
+            { name: 'relief', description: "Depth of the lit dome on each floret", type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'shape', description: "The mark each floret carries (0 draws only the domes)", type: 'select', options: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21'], optionLabels: ['Domes only', 'Seed', 'Ring', 'Crescent', 'Sparkle', 'Reuleaux', 'Spiral', 'Target', 'Pebble', 'Dot', 'Dots (sunflower)', 'Square', 'Star', 'Hexagon', 'Triangle', 'Cross', 'Heart', 'Chevron', 'Infinity', 'Gear', 'Atom', 'Sunburst'] },
+            { name: 'shapeSize', description: "Size of the mark relative to its floret", type: 'number', min: 0.3, max: 1.2, step: 0.01 },
+            { name: 'shapeGlow', description: "Brightness of the marks", type: 'number', min: 0, max: 2, step: 0.01 },
+        ],
+        section: { description: "Bloom rings across the head at once", min: 1, max: 6, step: 1 },
+    },
+    parastichyGrid: {
+        own: [
+            { name: 'divergence', description: "Angle between successive seeds, degrees; 137.508 is the golden angle", type: 'number', min: 135, max: 140, step: 0.001 },
+            { name: 'third', description: "Weight of the third spiral family that splits cells into triangles", type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'sap', description: "Brightness of the light running inward along the spirals", type: 'number', min: 0, max: 2, step: 0.01 },
+            { name: 'fill', description: "Strength of the faceted cell fill", type: 'number', min: 0, max: 1, step: 0.01 },
+        ],
+        section: { description: "Spirals in the main family (a Fibonacci number: 13, 21, 34, 55)", min: 3, max: 55, step: 1 },
+    },
+    apollonianGrid: {
+        own: [
+            { name: 'depth', description: "Inversion levels: how deep the packing nests", type: 'number', min: 1, max: 24, step: 1 },
+            { name: 'morph', description: "Strength of the Möbius flow that re-balances the packing; 0 holds it symmetric", type: 'number', min: 0, max: 0.9, step: 0.01 },
+        ],
+        section: { description: "Circles shallower than this many levels get the accent rim", min: 0, max: 12, step: 1 },
+    },
+    hilbertGrid: {
+        own: [
+            { name: 'order', description: "Curve order: the loop covers 2^order cells per side", type: 'number', min: 2, max: 8, step: 1 },
+            { name: 'signals', description: "Signals circulating round the loop", type: 'number', min: 1, max: 32, step: 1 },
+            { name: 'trail', description: "Length of each signal trail, in cells", type: 'number', min: 1, max: 128, step: 0.5 },
+            { name: 'signalSpeed', description: "Signal speed, in cells per second", type: 'number', min: 0, max: 40, step: 0.1 },
+        ],
+        section: { description: "Cells per cell of the coarser accent curve (a power of two)", min: 0, max: 32, step: 1 },
+    },
+};
 /** Every shader-plane grid's inputs: its own knobs first, then the shared surface. */
 export const GRID_PROPERTIES = Object.fromEntries(Object.entries(own).map(([type, props]) => [type, [...props, ...GRID_SURFACE_PROPERTIES]]));
+for (const [type, { own: props, section }] of Object.entries(parentOriented)) {
+    GRID_PROPERTIES[type] = [...props, ...surfaceFor(section)];
+}

package/dist/properties/tables/index.d.ts

@@ -4,6 +4,5 @@ export * from './particlesProperties';
 export * from './effectsProperties';
 export * from './gridProperties';
 export * from './materialBounds';
-export * from './getPropertyConfig';
 export * from './geometryProperties';
 //# sourceMappingURL=index.d.ts.map

package/dist/properties/tables/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/properties/tables/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/properties/tables/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dist/properties/tables/index.js

@@ -4,5 +4,4 @@ export * from './particlesProperties.js';
 export * from './effectsProperties.js';
 export * from './gridProperties.js';
 export * from './materialBounds.js';
-export * from './getPropertyConfig.js';
 export * from './geometryProperties.js';

package/dist/properties/tables/lightProperties.js

@@ -1,4 +1,4 @@
-// Moved from client (client/app/utils/lightProperties.ts). Property tables — the registry (../registry) is built on these.
+// Property table (moved from the client). The registry (../registry.ts) is built on these tables.
 // =============================================================================
 // lightProperties — the knobs LightControllerUi shows, per light type
 // =============================================================================

package/dist/properties/tables/materialBounds.js

@@ -1,4 +1,4 @@
-// Moved from client (client/app/containers/pages/controllers/materialBounds.ts). Property tables — the registry (../registry) is built on these.
+// Property table (moved from the client). The registry (../registry.ts) is built on these tables.
 // =============================================================================
 // MATERIAL PROPERTY BOUNDS — Min/Max/Step for Slider Controls
 // =============================================================================

package/dist/shaders/ApollonianGridMaterial.d.ts

@@ -0,0 +1,70 @@
+import * as THREE from 'three';
+export interface ApollonianGridMaterialUniforms {
+    /** elapsed seconds (useGridSurface) */
+    u_time: number;
+    /** size of one cell, in world units */
+    u_cellSize: number;
+    /** line thickness, in pixels */
+    u_lineWidth: number;
+    u_sectionSize: number;
+    /** accent thickness, in pixels; 0 disables the layer */
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    /** ripple / reveal origin; stays at the origin */
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    /** 0..1 assemble / dissolve */
+    u_reveal: number;
+    /** Inversion levels: how deep the packing nests */
+    u_depth: number;
+    /** Strength of the Möbius flow that re-balances the packing; 0 holds it symmetric */
+    u_morph: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        apollonianGridMaterial: ThreeElements['shaderMaterial'] & Partial<ApollonianGridMaterialUniforms>;
+    }
+}
+export declare const apollonianGridMaterialDefaults: ApollonianGridMaterialUniforms;
+export declare const ApollonianGridMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_time: number;
+    u_cellSize: number;
+    u_lineWidth: number;
+    u_sectionSize: number;
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    u_reveal: number;
+    u_depth: number;
+    u_morph: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=ApollonianGridMaterial.d.ts.map

package/dist/shaders/ApollonianGridMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApollonianGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ApollonianGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAgB/B,MAAM,WAAW,8BAA8B;IAC3C,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC;IAC5B,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,kDAAkD;IAClD,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,sBAAsB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAC;KACrG;CACJ;AAED,eAAO,MAAM,8BAA8B,EAAE,8BAyB5C,CAAC;AA6OF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlC,CAAC"}

package/dist/shaders/ApollonianGridMaterial.js

@@ -0,0 +1,289 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const apollonianGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 2,
+    u_lineWidth: 1.1,
+    u_sectionSize: 2,
+    u_sectionWidth: 2,
+    u_lineColor: new THREE.Color('#6a90c8'),
+    u_sectionColor: new THREE.Color('#c9e4ff'),
+    u_cellColor: new THREE.Color('#1a2f5c'),
+    u_glowColor: new THREE.Color('#8fb8ff'),
+    u_bgColor: new THREE.Color('#03050c'),
+    u_bgOpacity: 0,
+    u_lineMode: 0,
+    u_cellMode: 1,
+    u_animSpeed: 1,
+    u_animScale: 0.5,
+    u_animIntensity: 0.6,
+    u_fadeDistance: 25,
+    u_fadeStrength: 0.15,
+    u_focus: new THREE.Vector2(0, 0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_displace: 0,
+    u_reveal: 1,
+    u_depth: 12,
+    u_morph: 0.25,
+};
+const vertex = /* glsl */ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+
+  
+  const float PI  = 3.14159265359;
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      float t = u_time * u_animSpeed;
+      float d = length(position.xy) / max(u_cellSize, 1e-4);
+      pos.z += sin(d * u_animScale - t) * u_displace;
+    }
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragment = /* glsl */ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_lineWidth;
+  uniform float u_sectionSize;
+  uniform float u_sectionWidth;
+  uniform vec3  u_lineColor;
+  uniform vec3  u_sectionColor;
+  uniform vec3  u_cellColor;
+  uniform vec3  u_glowColor;
+  uniform vec3  u_bgColor;
+  uniform float u_bgOpacity;
+  uniform float u_lineMode;
+  uniform float u_cellMode;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_animIntensity;
+  uniform float u_fadeDistance;
+  uniform float u_fadeStrength;
+  uniform vec2  u_focus;
+  uniform float u_reveal;
+
+  uniform float u_depth;
+  uniform float u_morph;
+
+  varying vec2 vGridPos;
+
+  
+  const float PI  = 3.14159265359;
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+
+
+  float lineAt(float c, float width, float fp){
+    float d = abs(fract(c - 0.5) - 0.5);
+    return 1.0 - clamp(d / max(fp * max(width, 0.05), 1e-6), 0.0, 1.0);
+  }
+
+  vec2 cmul(vec2 a, vec2 b){ return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x); }
+  vec2 cdiv(vec2 a, vec2 b){ return vec2(a.x * b.x + a.y * b.y, a.y * b.x - a.x * b.y) / max(dot(b, b), 1e-8); }
+
+  void main(){
+    vec2 coord = vGridPos / max(u_cellSize, 1e-4);
+    vec2 focus = u_focus / max(u_cellSize, 1e-4);
+    float t  = u_time * u_animSpeed;
+
+    // Apollonian gasket by circle inversion. Inside the unit circle sit three
+    // mutually tangent circles of radius 2*sqrt(3)-3. Each of the four
+    // curvilinear gaps between the circles is cut out by a "dual" circle through
+    // its three tangency points, orthogonal to the circles that bound it.
+    // Inverting in a gap's dual circle keeps those circles fixed and maps the
+    // fourth circle onto the gap's inscribed circle, so a point is walked out of
+    // nested gaps one inversion per level until it lands in a base circle. The
+    // number of inversions is its depth; the product of their scale factors takes
+    // distances back to the plane, so every circle gets a pixel-true stroke.
+    float R  = u_fadeDistance * 0.9;
+    vec2  z  = vGridPos / R;
+    float fpz = max(max(fwidth(z.x), fwidth(z.y)), 1e-6);
+
+    // A Mobius automorphism of the disk, z -> (z - a) / (1 - conj(a) z), maps the
+    // gasket onto another Apollonian gasket. Orbiting a slowly makes the packing
+    // flow and re-balance while every circle stays a circle and every tangency holds.
+    vec2  am  = u_morph * 0.8 * vec2(cos(t * 0.13), sin(t * 0.19));
+    vec2  den = vec2(1.0, 0.0) - cmul(vec2(am.x, -am.y), z);
+    vec2  w   = cdiv(z - am, den);
+    float J   = (1.0 - dot(am, am)) / max(dot(den, den), 1e-8);   // |dw/dz|
+
+    const float RHO = 0.46410161514;   // 2 sqrt(3) - 3
+    const float DC  = 0.53589838486;   // 1 - RHO: centre distance of the three
+    const float SQ3 = 1.73205080757;
+    float maxD  = clamp(floor(u_depth + 0.5), 1.0, 24.0);
+    float depth = 0.0;
+    float path  = 0.37;
+    float term  = -1.0;
+    vec2  cc = vec2(0.0);
+    float cr = 1.0;
+    for (int i = 0; i < 25; i++){
+      // landed in one of the three base circles (centres at 90, 210, 330 deg)?
+      for (int k = 0; k < 3; k++){
+        float ak = PI * 0.5 + float(k) * TAU / 3.0;
+        vec2  ck = DC * vec2(cos(ak), sin(ak));
+        if (length(w - ck) < RHO){ term = float(k) + 1.0; cc = ck; cr = RHO; }
+      }
+      if (term > 0.0) break;
+      if (length(w) > 1.0){ term = 0.0; cc = vec2(0.0); cr = 1.0; break; }
+      if (depth >= maxD) break;
+      // which gap: the central one, or the outer gap facing 30, 150 or 270 deg
+      vec2  dcen; float drad; float gap;
+      if (length(w) < DC * 0.5){
+        dcen = vec2(0.0); drad = DC * 0.5; gap = 0.0;
+      } else {
+        float ang = atan(w.y, w.x);
+        float kk = floor(mod(ang - PI / 6.0 + PI / 3.0, TAU) / (TAU / 3.0));
+        float ag = PI / 6.0 + kk * TAU / 3.0;
+        dcen = 2.0 * vec2(cos(ag), sin(ag)); drad = SQ3; gap = kk + 1.0;
+      }
+      vec2  v  = w - dcen;
+      float v2 = max(dot(v, v), 1e-10);
+      w = dcen + drad * drad * v / v2;
+      J *= drad * drad / v2;
+      depth += 1.0;
+      path = hash21(vec2(path * 17.0 + gap, depth));
+    }
+
+    float found = step(-0.5, term);
+    float outside = found * step(term, 0.5) * step(depth, 0.5);  // beyond the outer circle
+    float dz = abs(length(w - cc) - cr) / max(J, 1e-12);           // distance to this circle, z units
+    // this circle's radius, z units. Inside an image of the outer circle the point
+    // can sit near the pole of the inversion, where cr/J collapses; the distance
+    // to the rim is the safe lower bound there.
+    float rz = max(cr / max(J, 1e-12), dz);
+    float dens = smoothstep(1.0, 3.0, rz / fpz) * found;           // circles under ~2px fade out
+
+    float lines = (1.0 - clamp(dz / (fpz * max(u_lineWidth, 0.05)), 0.0, 1.0)) * dens;
+    float accent = 0.0;
+    if (u_sectionWidth > 0.0 && depth < u_sectionSize){
+      accent = (1.0 - clamp(dz / (fpz * max(u_sectionWidth, 0.05)), 0.0, 1.0)) * dens;
+    }
+
+    float dmin = clamp(dz / max(rz, 1e-9), 0.0, 1.0) * dens * (1.0 - outside);
+    // fills are per circle, so the wave and the ripple both step down the levels
+    float idAcc = depth * 20.0;
+    vec2  cellPos = focus + vec2(depth * 2.0, 0.0);
+    float cellH = hash21(vec2(path, term + 1.0));
+    float tone = step(0.55, cellH);
+
+    // a soft inner bevel along every rim, brightest on the shallow circles
+    float bevel = exp(-pow(dz / max(rz * 0.12, fpz), 2.0)) * dens * (1.0 - outside);
+    float lvl = 1.0 / (1.0 + depth * 0.45);
+    vec3  extraCol = u_glowColor * (bevel * 0.35 + lines * 0.5) * lvl;
+    float extraA = bevel * 0.3 * lvl;
+
+    // ---- line animation --------------------------------------------------
+    float lineAnim = 1.0;
+    // Mode 0 is static: the chain starts at 0.5 so 0 never falls into flow.
+    if (u_lineMode < 0.5){
+    } else if (u_lineMode < 1.5){
+      lineAnim = 0.5 + 0.5 * sin(length(cellPos - focus) * u_animScale - t);
+    } else if (u_lineMode < 2.5){
+      lineAnim = 0.5 + 0.5 * sin(dot(cellPos, vec2(0.5, 0.5)) * u_animScale - t);
+    } else if (u_lineMode < 3.5){
+      float s = fract((coord.x + coord.y) * 0.05 * u_animScale - t * 0.15);
+      lineAnim = 0.25 + smoothstep(0.0, 0.15, s) * (1.0 - smoothstep(0.15, 0.35, s));
+    } else if (u_lineMode < 4.5){
+      lineAnim = 0.5 + 0.5 * sin(t);
+    }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+
+    // ---- cell fill -------------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode < 0.5){
+    } else if (u_cellMode < 1.5){
+      cell = 0.5 + 0.5 * sin(idAcc * 0.05 * u_animScale - t);
+    } else if (u_cellMode < 2.5){
+      cell = 0.5 + 0.5 * sin(t * (0.6 + cellH) + cellH * TAU);
+    } else if (u_cellMode < 3.5){
+      cell = smoothstep(0.6, 1.0, sin(length(cellPos - focus) * u_animScale - t));
+    } else if (u_cellMode < 4.5){
+      cell = step(0.5, cellH) * (0.5 + 0.5 * sin(t));
+    }
+    cell *= u_animIntensity;
+    cell *= smoothstep(0.0, 0.16, dmin); // keep the fill off its own edges
+
+    float r = length(vGridPos) / max(u_fadeDistance, 1e-4);
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, r);
+
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    col += mix(u_cellColor, u_cellColor * 2.2, tone) * cell;
+    a = max(a, cell * 0.9);
+    float linesI = lines * lineAnim;
+    col += u_lineColor * linesI;            a = max(a, linesI);
+    float accentI = accent * lineAnim;
+    col += u_sectionColor * accentI;        a = max(a, accentI);
+    col += u_glowColor * (linesI * 0.2 + cell * 0.35) * u_animIntensity;
+    col += extraCol;                        a = max(a, extraA);
+
+    col *= fade;
+    a   *= fade;
+
+    // ---- reveal ----------------------------------------------------------
+    if (u_reveal < 0.999){
+      float rd = length(vGridPos - u_focus) / max(u_fadeDistance, 1e-4);
+      float edge = u_reveal * 1.1;
+      float mask = 1.0 - smoothstep(edge - 0.05, edge, rd);
+      float front = mask * smoothstep(edge - 0.22, edge - 0.05, rd);
+      col = col * mask + u_glowColor * front * (a * 1.8 + 0.08);
+      a   = max(a * mask, front * 0.10);
+    }
+
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(col, a);
+  }
+`;
+export const ApollonianGridMaterial = shaderMaterial({
+    u_time: apollonianGridMaterialDefaults.u_time,
+    u_cellSize: apollonianGridMaterialDefaults.u_cellSize,
+    u_lineWidth: apollonianGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: apollonianGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: apollonianGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: apollonianGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: apollonianGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: apollonianGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: apollonianGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: apollonianGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: apollonianGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: apollonianGridMaterialDefaults.u_lineMode,
+    u_cellMode: apollonianGridMaterialDefaults.u_cellMode,
+    u_animSpeed: apollonianGridMaterialDefaults.u_animSpeed,
+    u_animScale: apollonianGridMaterialDefaults.u_animScale,
+    u_animIntensity: apollonianGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: apollonianGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: apollonianGridMaterialDefaults.u_fadeStrength,
+    u_focus: apollonianGridMaterialDefaults.u_focus.clone(),
+    u_mouse: apollonianGridMaterialDefaults.u_mouse.clone(),
+    u_displace: apollonianGridMaterialDefaults.u_displace,
+    u_reveal: apollonianGridMaterialDefaults.u_reveal,
+    u_depth: apollonianGridMaterialDefaults.u_depth,
+    u_morph: apollonianGridMaterialDefaults.u_morph,
+}, vertex, fragment);
+extend({ ApollonianGridMaterial });