Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
import { test } from "node:test";
import assert from "node:assert/strict";
import { Vector3, Matrix4 } from "three";
import {
TelosCamera,
TelosPick,
materialFromAppearance,
fromDisplayMesh,
} from "../dist/index.js";
import type { TelosScene } from "../dist/index.js";
test("orbit crosses both world poles without a guard, singularity or lost pan basis", () => {
const camera = new TelosCamera();
camera.position.set(0, -10, 0); camera.target.set(0, 0, 0); camera.up.set(0, 0, 1); camera.update();
for (let quarter = 0; quarter < 4; quarter++) {
for (let step = 0; step < 90; step++) camera.orbit(0, Math.PI / 180);
assert(Math.abs(camera.position.length() - 10) < 1e-10);
assert(camera.viewProjection.elements.every(Number.isFinite));
assert(new Vector3().setFromMatrixColumn(camera.inverseView, 0).length() > .999);
if (quarter % 2 === 0) assert(Math.abs(camera.position.z) > 9.999);
}
assert(camera.position.distanceTo(new Vector3(0, -10, 0)) < 1e-10);
for (const [direction, up] of [[[0,0,1],[0,1,0]], [[0,0,-1],[0,-1,0]]]) {
camera.orient(direction, up);
assert(Math.abs(camera.position.z) > 9.999);
assert.deepEqual(camera.project([0,0,0]).slice(0,2), [.5,.5]);
camera.fit([-5, -3, 0], [5, 3, 2]);
assert(camera.position.clone().sub(camera.target).normalize().distanceTo(new Vector3(...direction)) < 1e-10);
camera.orbit(.1, .1);
assert(camera.view.elements.every(Number.isFinite));
}
});
test("resolved occurrence materials retain shared geometry and camera metadata uses Telos authority", () => {
const definition = {
id: "shared",
positions: [0, 0, 0],
normals: [0, 0, 1],
indices: [],
};
const material = {
baseColor: [0.7, 0.2, 0.1],
roughness: 0.3,
metallic: 0.1,
opacity: 0.18,
};
const scene = fromDisplayMesh({
definitions: [definition],
occurrences: [
{
id: "glass",
definitionId: "shared",
semanticEntityId: "pane",
transform: new Matrix4().elements,
material,
},
{
id: "default",
definitionId: "shared",
semanticEntityId: "body",
transform: new Matrix4().elements,
},
],
});
assert.equal(scene.meshes[0].material, material);
assert.equal(scene.meshes[0].definition, scene.meshes[1].definition);
assert.equal(scene.meshes[1].material.opacity, 1);
const camera = new TelosCamera();
camera.applyDisplayCamera({
transform: new Matrix4().makeTranslation(100, 200, 300).elements,
lookAtMm: [0, 0, 0],
fovDegrees: 67,
});
assert.deepEqual(camera.position.toArray(), [100, 200, 300]);
assert.deepEqual(camera.target.toArray(), [0, 0, 0]);
assert.equal(camera.fov, 67);
});
test("fit contains every bounds corner in narrow and wide product panes", () => {
for (const mode of ["perspective", "orthographic"] as const)
for (const [width, height] of [
[320, 900],
[1600, 500],
])
for (const scale of [1e-5, 1, 1e6]) {
const camera = new TelosCamera();
camera.mode = mode;
camera.up.set(0, 0, 1);
camera.resize(width, height);
camera.fit([-scale, -scale, -scale], [scale, scale, scale]);
assert.ok(camera.position.z > camera.target.z);
for (const x of [-scale, scale])
for (const y of [-scale, scale])
for (const z of [-scale, scale]) {
const [px, py, depth] = camera.project([x, y, z]);
assert.ok(px > 0 && px < width && py > 0 && py < height);
assert.ok(depth > 0 && depth < 1);
}
}
});
for (const mode of ["perspective", "orthographic"] as const)
test(`${mode}: project, unproject, ray, aspect and scale`, () => {
const camera = new TelosCamera();
camera.mode = mode;
camera.resize(800, 600);
for (const scale of [1e-5, 1, 1e6]) {
camera.fit([-scale, -scale, -scale], [scale, scale, scale]);
const world = new Vector3(scale * 0.2, scale * 0.3, scale * 0.1),
pixel = camera.project(world.toArray());
const restored = camera.unproject([pixel[0], pixel[1]], pixel[2]);
assert.ok(restored.distanceTo(world) < scale * 1e-6);
const ray = camera.worldRay([pixel[0], pixel[1]]);
assert.ok(ray.direction.length() > 0.999999);
assert.ok(
ray.direction
.clone()
.cross(world.clone().sub(ray.origin).normalize())
.length() < 1e-8,
);
const before = camera.projection.elements[0];
camera.resize(1600, 600);
assert.ok(camera.projection.elements[0] < before);
camera.resize(800, 600);
}
const adapter = camera.toThree();
adapter.position.set(100, 200, 300);
assert.notEqual(camera.position.x, 100);
});
test("stable identity, occurrence transforms and nearest surface picking", () => {
const camera = new TelosCamera();
camera.position.set(0, 0, 5);
camera.target.set(0, 0, 0);
camera.resize(200, 200);
camera.update();
const definition = {
id: "shared",
positions: [-1, -1, 0, 1, -1, 0, 0, 1, 0],
normals: [0, 0, 1, 0, 0, 1, 0, 0, 1],
indices: [0, 1, 2],
ranges: [
{ startTriangle: 0, triangleCount: 1, faceId: "construction-face" },
],
};
const material = materialFromAppearance();
const scene: TelosScene = {
meshes: [
{
definition,
material,
identity: { occurrenceId: "back", bodyId: "body" },
},
{
definition,
material,
transform: new Matrix4().makeTranslation(0, 0, 1).elements,
identity: { occurrenceId: "front", bodyId: "body" },
},
],
lines: [],
fields: [],
};
const picker = new TelosPick(camera);
picker.setScene(scene);
const hit = picker.pick([100, 100]);
assert.equal(hit?.occurrenceId, "front");
assert.equal(hit?.faceId, "construction-face");
assert.equal(hit?.triangleIndex, 0);
assert.equal(hit?.worldPosition[2], 1);
picker.dispose();
assert.equal(picker.proxies.length, 0);
});
test("SDK adapter preserves shared geometry and kernel edge identity", () => {
const definition = {
id: "definition",
positions: [0, 0, 0],
normals: [0, 0, 1],
indices: [0],
edges: [
{
edgeId: "brep-edge",
points: [
[0, 0, 0],
[1, 0, 0],
],
closed: false,
},
],
};
const scene = fromDisplayMesh({
definitions: [definition],
occurrences: ["left", "right"].map((id) => ({
id,
definitionId: definition.id,
semanticEntityId: "body",
transform: new Matrix4().elements,
})),
});
assert.equal(scene.meshes[0].definition, scene.meshes[1].definition);
assert.equal(scene.lines[1].identity.edgeId, "brep-edge");
assert.equal(scene.lines[1].identity.occurrenceId, "right");
assert.notEqual(scene.lines[0].id, scene.lines[1].id);
});
test("Auto field projection retains picking/fallback geometry and diagnoses missing transport", () => {
const definition = {
id: "qualified",
positions: [0, 0, 0],
normals: [0, 0, 1],
indices: [0],
cir: {
qualification: "cir-qualified",
structuralIdentity: "semantic",
minimumMm: [0, 0, 0],
maximumMm: [1, 1, 1],
},
};
const material = {
baseColor: [0.1, 0.2, 0.3],
roughness: 0.4,
metallic: 0.7,
opacity: 0.8,
};
const packet = {
definitions: [definition],
occurrences: [
{
id: "instance",
definitionId: "qualified",
semanticEntityId: "body",
transform: new Matrix4().elements,
material,
},
],
};
const missing = fromDisplayMesh(packet);
assert.equal(missing.meshes.length, 1);
assert.equal(
missing.projectionDiagnostics?.[0].status,
"shader-artifact-transport-missing",
);
const artifact = {
shaderId: "compiled",
sourceIdentity: "semantic",
wgsl: "compiler-test-output",
vertexEntryPoint: "vertex",
fragmentEntryPoint: "fragment",
bindings: [],
capabilities: [],
};
const bound = fromDisplayMesh({
...packet,
definitions: [
{ ...definition, shader: { status: "shader-artifact-bound", artifact } },
],
});
assert.equal(bound.meshes.length, 0);
assert.equal(bound.fields.length, 1);
assert.equal(bound.fields[0].proxy, bound.fields[0].fallback?.definition);
assert.equal(bound.fields[0].material, material);
assert.equal(bound.fields[0].identity.definitionId, "qualified");
const stale = fromDisplayMesh({
...packet,
definitions: [
{
...definition,
shader: {
status: "shader-artifact-bound",
artifact: { ...artifact, sourceIdentity: "stale" },
},
},
],
});
assert.equal(stale.fields.length, 0);
assert.equal(stale.meshes.length, 1);
assert.equal(
stale.projectionDiagnostics?.[0].status,
"shader-artifact-transport-missing",
);
});