function run(inputs, controls) { const trace = inputs?.capture ? [] : null; const path = []; const feet = [[-3,-3,0],[3,-3,0],[3,3,0],[-3,3,0]]; const clamp = (n, low, high) => Math.max(low, Math.min(high, n)); const mix = (a, b, t) => a + (b - a) * t; const add = (a, b) => a.map((v, i) => v + b[i]); const scale = (a, n) => a.map(v => v * n); const sub = (a, b) => add(a, scale(b, -1)); const dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0); const length = v => Math.hypot(...v); const unit = a => scale(a, 1 / Math.max(1e-8,length(a))); const cross = ([a,b,c], [x,y,z]) => [b*z-c*y, c*x-a*z, a*y-b*x]; const lerp = (a,b,t) => add(a,scale(sub(b,a),t)); const smooth = t => { const p=clamp(t,0,1); return p*p*(3-2*p); }; const clip = ([x,y,z])=>[clamp(x,-3,3),clamp(y,-3,3),clamp(z,.14,4.8)]; // Keep the site and the four contacts fixed. Each rule supplies its own route. function append(route) { path.push(...route.slice(path.length ? 1 : 0)); } function round(route, amount, steps) { const points=[route[0]]; for(let i=1;i>> 0; return () => { state = (Math.imul(state, 1664525) + 1013904223) >>> 0; return state / 4294967296; }; } function checkedSeed(seed) { if (!Number.isInteger(seed) || seed < 1 || seed > 9999) throw new Error('Choose a seed from 1 to 9999.'); return randomFrom(seed); } const { seed, stitches } = controls; if(!Number.isInteger(stitches) || stitches<0 || stitches>24) throw Error('Choose 0 to 24 stitches.'); const random = checkedSeed(seed); const limits = p => [clamp(p[0],-3,3),clamp(p[1],-3,3),clamp(p[2],.12,4.8)]; const step = .41; // A rising bias starts four colonies. Samples pull their active tips // sideways into a shared volume. Points in the central clearing are excluded. const sites = Array.from({length:76},()=>[ 5.55*(random()-.5),5.55*(random()-.5),2.5+2.12*random() ]); const nodes=feet.map(p=>({p,parent:-1,root:true,children:0})); const edges=[], frames=[]; const nearby=(a,b)=>length(sub(a,b)); function addEdge(a,b){ edges.push([a,b]); } let targets=[...sites]; for(let tick=0;tick<26 && targets.length;tick++){ const groups=nodes.map(()=>[]); targets=targets.filter(p=>{ let closest=-1, best=Infinity; for(let i=0;i=0) groups[closest].push(p); return true; }); for(let i=0;i=152) continue; const from=nodes[i].p; const incident=nodes[i].parent<0?[0,0,1]:unit(sub(from,nodes[nodes[i].parent].p)); const directions=samples.map(p=>unit(sub(p,from))); const attraction=unit(directions.reduce(add,[0,0,0])); const flow=unit(add(scale(attraction,1.15),scale(incident,.44))); const spread=nodes[i].children===0?[0,0,0]:scale(cross(flow,[0,0,1]),.31); let direction=unit(add(flow,spread)); const p=limits(add(from,scale(direction,step))); if(p[2]<2.25 && Math.abs(p[0])<1.44 && Math.abs(p[1])<1.44){ direction=unit(add(direction,[0,0,1.3])); } const next=limits(add(from,scale(direction,step))); if(nodes.some(n=>nearby(n.p,next)<.22)) continue; nodes[i].children++; addEdge(i,nodes.length); nodes.push({p:next,parent:i,children:0}); } if(trace) frames.push(edges.map(([a,b])=>[nodes[a].p,nodes[b].p])); } // Neighbouring colonies can link overhead. Three cross-links join the // four roots while keeping a tree that can be threaded without forks. const labels=nodes.map((n,i)=>n.root?i:0); for(let i=feet.length;i2.34) links.push([nearby(a,b),i,j]); } links.sort((a,b)=>a[0]-b[0]); const joins=[]; for(const [gap,i,j] of links){ if(labels[i]===labels[j]) continue; const old=labels[j], next=labels[i]; labels.forEach((label,k)=>{if(label===old) labels[k]=next;}); addEdge(i,j); joins.push([nodes[i].p,nodes[j].p]); if(joins.length===3) break; } if(joins.length!==3) throw Error('The four colonies did not meet above the clearing.'); // Drop the short terminal shoots. The longer branches and the connections // are what the single tube follows. No node is removed from a through route. const network=nodes.map(()=>[]); for(const [a,b] of edges){network[a].push(b);network[b].push(a);} // Trim just the shortest shoots. Keep room for new connections overhead. for(const [i,neighbours] of network.entries()){ if(i<4 || neighbours.length!==1) continue; const j=neighbours[0]; if(network[j].length<3) continue; network[j]=network[j].filter(k=>k!==i); network[i]=[]; } function distances(from){ const route=nodes.map(()=>Infinity), prev=nodes.map(()=>-1); const open=new Set([from]); route[from]=0; while(open.size){ const i=[...open].reduce((a,b)=>route[a]2.36 || route[j]b.score-a.score); const stitch=[]; const usedNodes=new Set(); for(const {i,j} of possible){ if(stitch.length===stitches) break; if(network[i].length>=4 || network[j].length>=4 || usedNodes.has(i) || usedNodes.has(j)) continue; const {route}=distances(i); if(route[j]near.forEach(j=>{if(i((near.length%2) !== Number(i===0 || i===3))?i:-1).filter(i=>i>=0); while(unmatched.length){ const a=unmatched.shift(); const {route,prev}=distances(a); const index=unmatched.reduce((best,j,i)=>route[j][]); const copies=new Map(); const key=(a,b)=>Math.min(a,b)+':'+Math.max(a,b); threads.forEach((edge,i)=>{ const {a,b}=edge,k=key(a,b); if(!copies.has(k)) copies.set(k,[]); copies.get(k).push(i); incident[a].push(i); incident[b].push(i); }); const used=new Set(), hops=[]; function visit(a,from){ while(true){ const options=incident[a].filter(i=>!used.has(i)).map(i=>{ const e=threads[i], b=e.a===a?e.b:e.a; const turn=from<0?0:dot(unit(sub(nodes[a].p,nodes[from].p)),unit(sub(nodes[b].p,nodes[a].p))); return {i,b,turn}; }); if(!options.length) return; options.sort((a,b)=>b.turn-a.turn); const {i,b}=options[0]; used.add(i); visit(b,a); hops.push([a,b,i]); } } visit(0,-1); hops.reverse(); if(hops.length!==threads.length || hops.at(-1)[1]!==3) throw Error('The canopy did not produce one open trail.'); // Parallel copies occupy separate tracks around the same growth edge. const walked=[feet[0]]; for(const [a,b,i] of hops){ const p=nodes[a].p,q=nodes[b].p; const side=unit(cross(sub(nodes[Math.max(a,b)].p,nodes[Math.min(a,b)].p),[.33,-.21,1])); const lanes=copies.get(key(a,b)); const offset=scale(side,(lanes.indexOf(i)-(lanes.length-1)/2)*.235); walked.push(limits(add(lerp(p,q,.24),offset)),limits(add(lerp(p,q,.76),offset))); if(b<4) walked.push(q); } let span=[walked[0]]; for(const p of walked.slice(1)){ span.push(p); if(p[2]===0){ append(round(span,.32,2)); span=[p]; } } if(trace) trace.push({sites,frames,joins,stitch,walked}); // Give overlapping passes room for the tube, leaving the four contacts fixed. // The simulation decides the route. This step only moves near neighbours. const gap = 0.185; const fixed = path.map(p => p[2] === 0); const stations = [0]; for (let i=1; igap || Math.min(c[k],d[k])-Math.max(a[k],b[k])>gap) return false; } const u=sub(b,a), v=sub(d,c), r=sub(a,c); const uu=dot(u,u), vv=dot(v,v), uv=dot(u,v); const ru=dot(r,u), rv=dot(r,v), den=uu*vv-uv*uv; let s=den>1e-10 ? clamp((uv*rv-vv*ru)/den,0,1) : 0; let t=(uv*s+rv)/vv; if(t<0 || t>1){ t=clamp(t,0,1); s=clamp((uv*t-ru)/uu,0,1); } const delta=sub(add(r,scale(u,s)),scale(v,t)); const distance=Math.hypot(...delta); if(distance>=gap) return false; const direction=distance>1e-7 ? scale(delta,1/distance) : [1,0,0]; const weights=[1-s,s,t-1,-t].map((weight,k)=>fixed[[i,i+1,j,j+1][k]] ? 0 : weight); const total=dot(weights,weights); if(total<1e-8) return false; const shift=scale(direction,0.72*(gap-distance)/total); [i,i+1,j,j+1].forEach((k,n)=>{ if(fixed[k]) return; const [x,y,z]=add(path[k],scale(shift,weights[n])); path[k]=clip([x,y,z]); }); return true; } // Sort segment bounds once per pass so only nearby pairs need the // distance calculation. A small margin allows for motion during the pass. const search = gap + .10; for(let iteration=0;iteration<32;iteration++){ const bounds = path.slice(1).map((b,i)=>{ const a=path[i]; return {i, min:a.map((x,k)=>Math.min(x,b[k])),max:a.map((x,k)=>Math.max(x,b[k]))}; }).sort((a,b)=>a.min[0]-b.min[0]); let moved=false; for(let i=0;ib.max[1]+search || b.min[1]>a.max[1]+search || a.min[2]>b.max[2]+search || b.min[2]>a.max[2]+search) continue; const first=Math.min(a.i,b.i), second=Math.max(a.i,b.i); if(stations[second]-stations[first+1]>.30 && separate(first,second)) moved=true; } } if(!moved) break; } const curve = path; // Sweep one circular section in a parallel-transport frame. const radius = 0.050; const sides = 10; const vertices = []; const faces = [Array.from({length:sides},(_,j)=>sides-1-j)]; let normal=[0,1,0]; for(let i=0;iNumber(v.toFixed(5)))); if(i){ const a=(i-1)*sides+j, b=(i-1)*sides+(j+1)%sides; faces.push([a,b,b+sides,a+sides]); } } } const last=vertices.length-sides; faces.push(Array.from({length:sides},(_,j)=>last+j)); return { version:2, units:'metres', objects:[{type:'MESH',name:'One continuous tube',color:'#3954b5',vertices,faces}] }; }