382 lines
14 KiB
TypeScript
382 lines
14 KiB
TypeScript
import {
|
|
Mesh,
|
|
MeshBuilder,
|
|
Plane,
|
|
Quaternion,
|
|
Scene,
|
|
Vector3,
|
|
VertexData,
|
|
} from '@babylonjs/core/Legacy/legacy';
|
|
import { stringify } from '@preserves/core';
|
|
|
|
import * as Cat from './cat.js';
|
|
import { earcut } from './earcut';
|
|
|
|
export class PenError extends Cat.RuntimeError {}
|
|
|
|
export class PenState {
|
|
templatePath: Vector3[] = [new Vector3()];
|
|
paths: Vector3[][] | null = null;
|
|
directions: Quaternion[] | null = null;
|
|
|
|
get isDown(): boolean {
|
|
return this.paths !== null;
|
|
}
|
|
|
|
clear() {
|
|
this.templatePath = [new Vector3()];
|
|
this.up();
|
|
}
|
|
|
|
set() {
|
|
if (!this.paths) throw new PenError("Cannot set pen with no paths");
|
|
this.templatePath = this.paths[0];
|
|
this.up();
|
|
}
|
|
|
|
down() {
|
|
this.paths = this.templatePath.map(_p => []);
|
|
this.directions = [];
|
|
}
|
|
|
|
up() {
|
|
this.paths = null;
|
|
this.directions = null;
|
|
}
|
|
|
|
push(pos: Vector3, q: Quaternion, miter: boolean) {
|
|
const directions = this.directions!;
|
|
const paths = this.paths!;
|
|
|
|
if (miter && directions.length > 0) {
|
|
const lastQ = directions[directions.length - 1];
|
|
const lastDir = new Vector3(0, 0, 1).applyRotationQuaternionInPlace(lastQ);
|
|
const thisDir = new Vector3(0, 0, 1).applyRotationQuaternionInPlace(q);
|
|
const miterDir = lastDir.add(thisDir).normalize();
|
|
const miterPlane = Plane.FromPositionAndNormal(pos, miterDir);
|
|
for (let pathIndex = 0; pathIndex < paths.length; pathIndex++) {
|
|
const steps = paths[pathIndex];
|
|
const p = steps[steps.length - 1];
|
|
const d = pointDistance(p, lastDir, miterPlane);
|
|
if (d !== null) steps[steps.length - 1] = p.add(lastDir.scale(d));
|
|
}
|
|
this.templatePath.forEach((p, i) => {
|
|
const r = p.applyRotationQuaternion(q).addInPlace(pos);
|
|
const d = pointDistance(r, thisDir, miterPlane);
|
|
if (d !== null) r.addInPlace(thisDir.scale(d));
|
|
paths[i].push(r);
|
|
});
|
|
} else {
|
|
this.templatePath.forEach((p, i) => {
|
|
const r = p.applyRotationQuaternion(q).addInPlace(pos);
|
|
paths[i].push(r);
|
|
});
|
|
}
|
|
|
|
directions.push(q);
|
|
}
|
|
};
|
|
|
|
// Adapted from Ray.intersectsPlane
|
|
function pointDistance(origin: Vector3, direction: Vector3, plane: Plane): number | null {
|
|
const result1 = Vector3.Dot(plane.normal, direction);
|
|
if (Math.abs(result1) < 1e-6) return null; // direction parallel to plane
|
|
const result2 = Vector3.Dot(plane.normal, origin);
|
|
return (-plane.d - result2) / result1;
|
|
}
|
|
|
|
export enum CapType {
|
|
NONE,
|
|
START,
|
|
END,
|
|
BOTH,
|
|
};
|
|
|
|
export class TurtleVM extends Cat.VM<TurtleVM> {
|
|
container: Mesh;
|
|
meshes: Mesh[] = [];
|
|
wireframe = false;
|
|
cap: CapType = CapType.BOTH;
|
|
|
|
counter = 0;
|
|
sideOrientation = Mesh.DEFAULTSIDE;
|
|
|
|
pen = new PenState();
|
|
pos = new Vector3();
|
|
q = new Quaternion();
|
|
smooth = false;
|
|
miter = false;
|
|
|
|
get euler(): Vector3 {
|
|
return this.q.toEulerAngles();
|
|
}
|
|
|
|
constructor(
|
|
name: string,
|
|
scene: Scene | null,
|
|
program: Cat.Input,
|
|
) {
|
|
super(program, TurtlePrimitives);
|
|
this.container = new Mesh(name, scene);
|
|
}
|
|
|
|
forwardBy(dist: number) {
|
|
const v = new Vector3(0, 0, dist).applyRotationQuaternionInPlace(this.q);
|
|
this.pos.addInPlace(v);
|
|
if (this.pen.isDown) this.pen.push(this.pos, this.q, dist === 0.0 && this.miter);
|
|
}
|
|
|
|
rotate(y: number, x: number, z: number) {
|
|
const e = this.euler;
|
|
e.addInPlaceFromFloats(x * Cat.D2R, y * Cat.D2R, z * Cat.D2R);
|
|
this.q = e.toQuaternion();
|
|
}
|
|
|
|
relativeRotate(y: number, x: number, z: number) {
|
|
this.q = this.q.multiply(Quaternion.FromEulerAngles(x * Cat.D2R, y * Cat.D2R, z * Cat.D2R));
|
|
}
|
|
|
|
penDown() {
|
|
this.pen.down();
|
|
this.pen.push(this.pos, this.q, false);
|
|
}
|
|
|
|
penUp(close: boolean) {
|
|
if (!this.pen.isDown) return;
|
|
|
|
if (close) {
|
|
throw new Error('todo');
|
|
}
|
|
|
|
if (this.wireframe) {
|
|
this.emitWireframe();
|
|
} else {
|
|
this.emitSolid();
|
|
}
|
|
|
|
this.pen.up();
|
|
}
|
|
|
|
emitWireframe() {
|
|
const lines: Vector3[][] = [];
|
|
const paths = this.pen.paths!;
|
|
const pathCount = paths.length;
|
|
const stepCount = paths[0].length;
|
|
|
|
if (this.cap === CapType.START || this.cap === CapType.BOTH) {
|
|
lines.push(paths.map(p => p[0]));
|
|
}
|
|
|
|
for (let pathIndex = 1; pathIndex < pathCount; pathIndex++) {
|
|
for (let stepIndex = 1; stepIndex < stepCount; stepIndex++) {
|
|
lines.push([paths[pathIndex - 1][stepIndex - 1],
|
|
paths[pathIndex - 1][stepIndex],
|
|
paths[pathIndex][stepIndex],
|
|
paths[pathIndex][stepIndex - 1]]);
|
|
}
|
|
}
|
|
|
|
if (this.cap === CapType.END || this.cap === CapType.BOTH) {
|
|
lines.push(paths.map(p => p[p.length - 1]));
|
|
}
|
|
|
|
const meshName = this.container.name + this.counter++;
|
|
const ls = MeshBuilder.CreateLineSystem(meshName, { lines }, null);
|
|
ls.parent = this.container;
|
|
this.meshes.push(ls);
|
|
}
|
|
|
|
emitSolid() {
|
|
const positions: number[] = [];
|
|
const indices: number[] = [];
|
|
const normals: number[] = [];
|
|
const uvs: number[] = [];
|
|
|
|
const paths = this.pen.paths!;
|
|
const pathCount = paths.length;
|
|
const stepCount = paths[0].length;
|
|
|
|
const us: number[][] = [];
|
|
const vs: number[][] = [];
|
|
const uTotal: number[] = [];
|
|
const vTotal: number[] = [];
|
|
|
|
for (let pathIndex = 0; pathIndex < pathCount; pathIndex++) {
|
|
uTotal.push(0);
|
|
us.push([]);
|
|
let prev = paths[pathIndex][0];
|
|
for (let stepIndex = 0; stepIndex < stepCount; stepIndex++) {
|
|
const curr = paths[pathIndex][stepIndex];
|
|
uTotal[pathIndex] += curr.subtract(prev).length();
|
|
us[pathIndex][stepIndex] = uTotal[pathIndex];
|
|
prev = curr;
|
|
}
|
|
}
|
|
|
|
for (let stepIndex = 0; stepIndex < stepCount; stepIndex++) {
|
|
vTotal.push(0);
|
|
vs.push([]);
|
|
let prev = paths[0][stepIndex];
|
|
for (let pathIndex = 0; pathIndex < pathCount; pathIndex++) {
|
|
const curr = paths[pathIndex][stepIndex];
|
|
vTotal[stepIndex] += curr.subtract(prev).length();
|
|
vs[stepIndex][pathIndex] = vTotal[stepIndex];
|
|
prev = curr;
|
|
}
|
|
}
|
|
|
|
function pushPoint(pathIndex: number, stepIndex: number): number {
|
|
const pointIndex = positions.length / 3;
|
|
const p = paths[pathIndex][stepIndex];
|
|
positions.push(... p.asArray());
|
|
uvs.push((p.x - p.z), (p.y));
|
|
// uvs.push((p.x - p.z) / 1.2, (p.y) / 0.9);
|
|
// uvs.push(us[pathIndex][stepIndex] / uTotal[pathIndex],
|
|
// vs[stepIndex][pathIndex] / vTotal[stepIndex]);
|
|
return pointIndex;
|
|
}
|
|
|
|
const cachedIndices: { [key: string]: number } = {};
|
|
function cachedPoint(pathIndex: number, stepIndex: number): number {
|
|
const v = paths[pathIndex][stepIndex].asArray().map(n => n.toFixed(3)).toString();
|
|
if (!(v in cachedIndices)) cachedIndices[v] = pushPoint(pathIndex, stepIndex);
|
|
return cachedIndices[v];
|
|
}
|
|
|
|
const computePointIndex = this.smooth ? cachedPoint : pushPoint;
|
|
|
|
const capIndices = this.cap === CapType.NONE
|
|
? []
|
|
: earcut(this.pen.templatePath.flatMap(p => [p.x, p.y]), void 0, 2);
|
|
|
|
function cap(stepIndex: number, a: number, b: number, c: number) {
|
|
for (let i = 0; i < capIndices.length; i += 3) {
|
|
indices.push(computePointIndex(capIndices[i+a], stepIndex),
|
|
computePointIndex(capIndices[i+b], stepIndex),
|
|
computePointIndex(capIndices[i+c], stepIndex));
|
|
}
|
|
}
|
|
|
|
if (this.cap === CapType.START || this.cap === CapType.BOTH) {
|
|
cap(0, 0, 1, 2);
|
|
}
|
|
|
|
for (let pathIndex = 1; pathIndex < pathCount; pathIndex++) {
|
|
for (let stepIndex = 1; stepIndex < stepCount; stepIndex++) {
|
|
indices.push(computePointIndex(pathIndex - 1, stepIndex - 1),
|
|
computePointIndex(pathIndex - 1, stepIndex),
|
|
computePointIndex(pathIndex, stepIndex - 1));
|
|
|
|
indices.push(computePointIndex(pathIndex - 1, stepIndex),
|
|
computePointIndex(pathIndex, stepIndex),
|
|
computePointIndex(pathIndex, stepIndex - 1));
|
|
}
|
|
}
|
|
|
|
if (this.cap === CapType.END || this.cap === CapType.BOTH) {
|
|
cap(stepCount - 1, 2, 1, 0);
|
|
}
|
|
|
|
VertexData.ComputeNormals(positions, indices, normals);
|
|
VertexData._ComputeSides(this.sideOrientation, positions, indices, normals, uvs);
|
|
|
|
const vertexData = new VertexData();
|
|
vertexData.positions = new Float32Array(positions);
|
|
vertexData.indices = new Int32Array(indices);
|
|
vertexData.normals = new Float32Array(normals);
|
|
vertexData.uvs = new Float32Array(uvs);
|
|
|
|
const m = new Mesh(this.container.name + this.counter++);
|
|
vertexData.applyToMesh(m);
|
|
m.parent = this.container;
|
|
this.meshes.push(m);
|
|
}
|
|
}
|
|
|
|
export const TurtlePrimitives: Cat.Environment<TurtleVM> = Object.assign(
|
|
{},
|
|
Cat.Primitives,
|
|
Cat.primitiveEnvironment({
|
|
'Home'() { this.pos = new Vector3(); this.q = new Quaternion(); return []; },
|
|
|
|
'GetPos'() { return [this.pos.asArray()]; },
|
|
'GetX'() { return [this.pos.x]; },
|
|
'GetY'() { return [this.pos.y]; },
|
|
'GetZ'() { return [this.pos.z]; },
|
|
'SetX'(v) { this.pos.x = v as number; return []; },
|
|
'SetY'(v) { this.pos.y = v as number; return []; },
|
|
'SetZ'(v) { this.pos.z = v as number; return []; },
|
|
'SetPos'(v) {
|
|
const [x, y, z] = v as number[];
|
|
this.pos.set(x as number, y as number, z as number);
|
|
return [];
|
|
},
|
|
|
|
'GetHeading'() { return [this.euler.asArray().map(v => v / Cat.D2R)]; },
|
|
'GetRX'() { return [this.euler.x / Cat.D2R]; },
|
|
'GetRY'() { return [this.euler.y / Cat.D2R]; },
|
|
'GetRZ'() { return [this.euler.z / Cat.D2R]; },
|
|
'SetRX'(v) { this.q.x = v as number * Cat.D2R; return []; },
|
|
'SetRY'(v) { this.q.y = v as number * Cat.D2R; return []; },
|
|
'SetRZ'(v) { this.q.z = v as number * Cat.D2R; return []; },
|
|
'SetHeading'(v) {
|
|
const [x, y, z] = v as number[];
|
|
this.q = Quaternion.FromEulerAngles(x as number * Cat.D2R, y as number * Cat.D2R, z as number * Cat.D2R);
|
|
return [];
|
|
},
|
|
|
|
'F'(dist) { this.forwardBy(dist as number); return []; },
|
|
'B'(dist) { this.forwardBy(-(dist as number)); return []; },
|
|
|
|
'RX'(degrees) { this.rotate(0, degrees as number, 0); return []; },
|
|
'RY'(degrees) { this.rotate(degrees as number, 0, 0); return []; },
|
|
'RZ'(degrees) { this.rotate(0, 0, degrees as number); return []; },
|
|
|
|
'U'(degrees) { this.relativeRotate(0, -(degrees as number), 0); return []; },
|
|
'D'(degrees) { this.relativeRotate(0, degrees as number, 0); return []; },
|
|
'L'(degrees) { this.relativeRotate(-(degrees as number), 0, 0); return []; },
|
|
'R'(degrees) { this.relativeRotate(degrees as number, 0, 0); return []; },
|
|
'CW'(degrees) { this.relativeRotate(0, 0, -(degrees as number)); return []; },
|
|
'CCW'(degrees) { this.relativeRotate(0, 0, degrees as number); return []; },
|
|
|
|
'ClearPen'() { this.pen.clear(); return []; },
|
|
'DefinePen'() { this.pen.set(); return []; },
|
|
'GetPen'() { return [this.pen.templatePath.map(v => v.asArray())]; },
|
|
'SetPen'(p0) {
|
|
const p = p0 as [number, number, number][];
|
|
if (this.pen.isDown && this.pen.templatePath.length !== p.length) {
|
|
throw new PenError("Cannot set pen with different number of points when pen is down");
|
|
}
|
|
this.pen.templatePath = p.map(v => Vector3.FromArray(v));
|
|
return [];
|
|
},
|
|
|
|
'PenDown'() { this.penDown(); return []; },
|
|
'PenUp'() { this.penUp(false); return []; },
|
|
'Close'() { this.penUp(true); return []; },
|
|
|
|
'SetCap'(t) {
|
|
const n = t as keyof typeof CapType;
|
|
if (typeof t === 'string' && n in CapType) {
|
|
this.cap = CapType[n];
|
|
} else {
|
|
throw new Cat.TypeError("Bad cap type: " + stringify(t));
|
|
}
|
|
return [];
|
|
},
|
|
'SetWireframe'(b) { this.wireframe = b as boolean; return []; },
|
|
'SetSmooth'(b) { this.smooth = b as boolean; return []; },
|
|
'SetMiter'(b) { this.miter = b as boolean; return []; },
|
|
'SetSideOrientation'(s) {
|
|
switch (s) {
|
|
case "DEFAULT": this.sideOrientation = Mesh.DEFAULTSIDE; break;
|
|
case "FRONT": this.sideOrientation = Mesh.FRONTSIDE; break;
|
|
case "BACK": this.sideOrientation = Mesh.BACKSIDE; break;
|
|
case "DOUBLE": this.sideOrientation = Mesh.DOUBLESIDE; break;
|
|
default: throw new TypeError("Invalid SideOrientation: " + stringify(s));
|
|
}
|
|
return [];
|
|
},
|
|
}) satisfies Cat.Environment<TurtleVM>,
|
|
);
|