Script workspace: the part handed to scripts and picked values

How the precision is kept

The part reaches a script as the display mesh, whose corner coordinates kernel.js keeps in a Float32Array; widening them to a Float64Array does not bring digits back. The picked point comes from a ray cast on the drawn surface, which cs-ui.js surfaceOf also stores as a Float32Array. Field values under the click are read from the field's own data array without interpolation.

Open item. Hand scripts the part's geometry from the 64-bit solid instead of the 32-bit display mesh, and state the picked point from the mesh's own node coordinates.

4 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.

/** The open part as a model value for the script's part() (its display mesh; only sent when the script names it). */
function partModel(host) {
  const m = host.regen && host.regen.mesh;
  if (!m || !m.positions || !m.indices) return null;
  return { t: 'model', source: 'part', ref: String(host.part.name || 'Part').slice(0, 120) /* i18n-ignore: a data reference */, mesh: { t: 'mesh', kind: 'tri', nodes: Float64Array.from(m.positions), elems: Int32Array.from(m.indices) } };
}

const rows = [[t('script.ws.pick.item'), `${it.name} (${it.kind})`], [t('script.ws.pick.point'), h.point.toArray().map((v) => fmtNum(+v.toFixed(4))).join(', ')]];
let node = -1;
if (idx) {
  const pos = h.object.geometry.attributes.position;
  let best = Infinity;
  for (const v of idx) { const d = Math.hypot(pos.getX(v) - h.point.x, pos.getY(v) - h.point.y, pos.getZ(v) - h.point.z); if (d < best) { best = d; node = s.vertNode[v]; } }
} else {
  const v0 = s.indices[3 * tri];
  node = s.vertNode[v0];
}

for (const f of S.shown.filter((x) => x.kind === 'field' && x.visible && x.mesh === it.mesh)) {
  const c = f.value.comps || 1, at = f.value.at === 'elem' ? elem : node;
  if (at < 0) continue;
  const vals = Array.from(f.value.data.subarray ? f.value.data.subarray(at * c, at * c + c) : f.value.data.slice(at * c, at * c + c), (x) => sig(x));
  rows.push([f.value.at === 'elem' ? t('script.ws.pick.at_element', { name: f.name }) : t('script.ws.pick.at_node', { name: f.name }), vals.join(', ') + (f.value.unit ? ' ' + f.value.unit : '')]);
}

if (it.deform) {
  if (it.scale === null) it.scale = C.autoScale(s.positions, it.deform.data, s.vertNode);
  pos = new Float32Array(s.positions.length);
  const u = it.deform.data;
  for (let v = 0; v < s.vertNode.length; v++) { const n = s.vertNode[v]; for (let c = 0; c < 3; c++) pos[3 * v + c] = s.positions[3 * v + c] + it.scale * u[3 * n + c]; }
}

In detail

Method

partModel copies the display mesh into the script's model value. pick casts a ray on the shown overlays, takes the nearest of the hit triangle's three corners as the node, and lists each visible field's value at that node or element.

Number types

Float32Array (display mesh and drawn surface), widened to Float64Array for the script; field data in the typed array the script produced; 64-bit arithmetic.

Limits

The picked point is printed to 4 decimals and field values to 4 significant figures (sim-ui.js sig).

Approach: 32-bit step, flagged

One step stores or exchanges 32-bit values that reach a number a person reads. It is listed here with its open item, and the step is either moved to 64-bit or the app will warn where the number is read.

Every policy that takes this approach