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[word[0].a,...word.map(symbol=>symbol.b)]; if(trace) frames.push(points()); for(let iteration=0;iteration{ const tangent=unit(sub(b,a)), size=length(sub(b,a)); const axis=Math.abs(tangent[2])>.92 ? [0,1,0] : [0,0,1]; const lateral=unit(cross(axis,tangent)); const up=cross(tangent,lateral); const knots=[a]; for(const [t,reach,turn] of [[.21,.34,.24],[.46,.56,1.33],[.73,.43,2.76]]){ const angle=roll+turn; const offset=add(scale(lateral,Math.sin(angle)),scale(up,Math.cos(angle))); const raw=add(lerp(a,b,t),scale(offset,size*reach)); const reflect=(v,limit)=>Math.abs(v)<=limit ? v : Math.sign(v)*(2*limit-Math.abs(v)); const [x,y,z]=raw; knots.push(clip([reflect(x,3),reflect(y,3),z<.14?.28-z:z])); } knots.push(b); return knots.slice(0,-1).map((a,k)=>({a,b:knots[k+1],roll:roll+[.36,-1.22,1.65,-.58][k]})) .filter(({a,b})=>length(sub(b,a))>.021); }); if(trace) frames.push(points()); } const route=points(); if(trace) trace.push({route,frames}); append(round(route,.31,3)); } // 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; } for(let iteration=0;iteration<32;iteration++){ let moved=false; for(let i=0;i.30 && separate(i,j)) 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}] }; }