castle-web-cli 0.4.204 → 0.4.205

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (125) hide show
  1. package/dist/agent-failures.d.ts +3 -1
  2. package/dist/agent-failures.js +19 -0
  3. package/dist/agent-prompts.js +2 -1
  4. package/dist/agent.d.ts +3 -2
  5. package/dist/agent.js +19 -10
  6. package/dist/castle-host/host.d.ts +17 -0
  7. package/dist/castle-host/host.js +551 -4
  8. package/dist/devSessionStorage.js +65 -4
  9. package/dist/effortSupport.d.ts +7 -0
  10. package/dist/effortSupport.js +31 -0
  11. package/dist/init.js +13 -3
  12. package/dist/platformDoc.js +6 -1
  13. package/dist/serve.js +35 -2
  14. package/dist/shell/assets/{index-DHzA0-Sj.js → index-hWQTC8q6.js} +5 -5
  15. package/dist/shell/index.html +1 -1
  16. package/dist/vitePlugins.js +19 -1
  17. package/kits/base/CLAUDE.md +2 -0
  18. package/kits/base/castle.json +1 -1
  19. package/kits/base/sdk/README.md +131 -0
  20. package/kits/base/sdk/agent.d.ts +6 -0
  21. package/kits/base/sdk/agent.js +70 -0
  22. package/kits/base/sdk/castle.d.ts +4 -0
  23. package/kits/base/sdk/castle.js +2 -0
  24. package/kits/base/sdk/commands.d.ts +106 -0
  25. package/kits/base/sdk/commands.js +21 -0
  26. package/kits/base/sdk/decks.d.ts +7 -0
  27. package/kits/base/sdk/decks.js +31 -0
  28. package/kits/base/sdk/runtime.d.ts +4 -2
  29. package/kits/base/sdk/runtime.js +51 -40
  30. package/kits/base/sdk/server/storage.d.ts +44 -0
  31. package/kits/base/sdk/server/storage.js +54 -0
  32. package/kits/base/sdk/transport.d.ts +5 -1
  33. package/kits/base/sdk/transport.js +106 -23
  34. package/kits/multiplayer-2d/castle.json +4 -4
  35. package/kits/multiplayer-2d/code/client/poses.js +7 -0
  36. package/kits/multiplayer-2d/code/server/limits.js +3 -0
  37. package/kits/multiplayer-2d/code/server/ownership.js +36 -8
  38. package/kits/multiplayer-2d/code/systems/multiplayer.js +23 -2
  39. package/kits/multiplayer-3d/CLAUDE.md +12 -1
  40. package/kits/multiplayer-3d/castle.json +4 -4
  41. package/kits/multiplayer-3d/code/client/avatars.js +7 -1
  42. package/kits/multiplayer-3d/code/client/poses.js +61 -1
  43. package/kits/multiplayer-3d/code/client/steer.js +383 -0
  44. package/kits/multiplayer-3d/code/server/limits.js +3 -0
  45. package/kits/multiplayer-3d/code/server/ownership.js +114 -18
  46. package/kits/multiplayer-3d/code/server/world.js +12 -4
  47. package/kits/multiplayer-3d/code/systems/multiplayer.js +315 -34
  48. package/kits/physics-3d/CLAUDE.md +65 -7
  49. package/kits/physics-3d/castle.json +3 -3
  50. package/kits/physics-3d/docs/pxmodel-format.md +916 -15
  51. package/kits/physics-3d/engine3d/PxModelEditor.jsx +2 -2
  52. package/kits/physics-3d/engine3d/artobjects.js +218 -0
  53. package/kits/physics-3d/engine3d/blob.js +1058 -0
  54. package/kits/physics-3d/engine3d/branches.js +300 -0
  55. package/kits/physics-3d/engine3d/cage.js +496 -0
  56. package/kits/physics-3d/engine3d/cageops.js +516 -0
  57. package/kits/physics-3d/engine3d/frame.js +669 -0
  58. package/kits/physics-3d/engine3d/look.js +675 -0
  59. package/kits/physics-3d/engine3d/materialpresets.js +486 -0
  60. package/kits/physics-3d/engine3d/modelEditorWorld.js +3 -2
  61. package/kits/physics-3d/engine3d/modelrefs.js +120 -0
  62. package/kits/physics-3d/engine3d/motion.js +560 -0
  63. package/kits/physics-3d/engine3d/objtext.js +37 -0
  64. package/kits/physics-3d/engine3d/optimize.js +1083 -0
  65. package/kits/physics-3d/engine3d/paint.js +674 -0
  66. package/kits/physics-3d/engine3d/partgeometry.js +467 -0
  67. package/kits/physics-3d/engine3d/paths.js +324 -0
  68. package/kits/physics-3d/engine3d/pxmodel.js +429 -26
  69. package/kits/physics-3d/engine3d/scatter.js +102 -0
  70. package/kits/physics-3d/engine3d/sculpt.js +1148 -0
  71. package/kits/physics-3d/engine3d/surfacedetail.js +267 -0
  72. package/kits/physics-3d/engine3d/sweep.js +480 -0
  73. package/kits/physics-3d/engine3d/thumbnails.js +6 -4
  74. package/kits/physics-3d/engine3d/world3d.js +119 -17
  75. package/kits/physics-3d/eslint.config.js +13 -0
  76. package/kits/physics-3d/models/parts/axe.pxmodel +40 -0
  77. package/kits/physics-3d/models/parts/backpack.pxmodel +47 -0
  78. package/kits/physics-3d/models/parts/barrel.pxmodel +22 -0
  79. package/kits/physics-3d/models/parts/bedroll.pxmodel +28 -0
  80. package/kits/physics-3d/models/parts/belt-pouch.pxmodel +22 -0
  81. package/kits/physics-3d/models/parts/bolt.pxmodel +10 -0
  82. package/kits/physics-3d/models/parts/bracer.pxmodel +26 -0
  83. package/kits/physics-3d/models/parts/chain-span.pxmodel +12 -0
  84. package/kits/physics-3d/models/parts/chimney.pxmodel +11 -0
  85. package/kits/physics-3d/models/parts/crate.pxmodel +44 -0
  86. package/kits/physics-3d/models/parts/crystal.pxmodel +22 -0
  87. package/kits/physics-3d/models/parts/door-arched.pxmodel +12 -0
  88. package/kits/physics-3d/models/parts/engine-block.pxmodel +39 -0
  89. package/kits/physics-3d/models/parts/exhaust-pipe.pxmodel +30 -0
  90. package/kits/physics-3d/models/parts/fence-span.pxmodel +10 -0
  91. package/kits/physics-3d/models/parts/fender.pxmodel +19 -0
  92. package/kits/physics-3d/models/parts/headlight.pxmodel +24 -0
  93. package/kits/physics-3d/models/parts/hood.pxmodel +17 -0
  94. package/kits/physics-3d/models/parts/horned-helmet.pxmodel +37 -0
  95. package/kits/physics-3d/models/parts/jerry-can.pxmodel +26 -0
  96. package/kits/physics-3d/models/parts/ladder.pxmodel +10 -0
  97. package/kits/physics-3d/models/parts/lamp.pxmodel +20 -0
  98. package/kits/physics-3d/models/parts/lantern.pxmodel +30 -0
  99. package/kits/physics-3d/models/parts/leaf-cluster.pxmodel +21 -0
  100. package/kits/physics-3d/models/parts/offroad-tire.pxmodel +48 -0
  101. package/kits/physics-3d/models/parts/pauldron.pxmodel +26 -0
  102. package/kits/physics-3d/models/parts/rivet.pxmodel +8 -0
  103. package/kits/physics-3d/models/parts/rock.pxmodel +21 -0
  104. package/kits/physics-3d/models/parts/roll-bar-light.pxmodel +26 -0
  105. package/kits/physics-3d/models/parts/round-shield.pxmodel +31 -0
  106. package/kits/physics-3d/models/parts/saddlebag.pxmodel +30 -0
  107. package/kits/physics-3d/models/parts/spoked-wheel.pxmodel +39 -0
  108. package/kits/physics-3d/models/parts/staff.pxmodel +33 -0
  109. package/kits/physics-3d/models/parts/stepping-stones.pxmodel +8 -0
  110. package/kits/physics-3d/models/parts/stone-base.pxmodel +10 -0
  111. package/kits/physics-3d/models/parts/sword.pxmodel +33 -0
  112. package/kits/physics-3d/models/parts/window-lit.pxmodel +13 -0
  113. package/kits/physics-3d/models/parts/wizard-hat.pxmodel +28 -0
  114. package/kits/physics-3d/models/templates/biped-stout.pxmodel +59 -0
  115. package/kits/physics-3d/models/templates/biped-tall.pxmodel +63 -0
  116. package/kits/physics-3d/models/templates/quadruped.pxmodel +52 -0
  117. package/kits/physics-3d/scripts/render/filmstrip.js +217 -0
  118. package/kits/physics-3d/scripts/render/index.html +20 -0
  119. package/kits/physics-3d/scripts/render/sheet.js +411 -0
  120. package/kits/physics-3d/scripts/render.mjs +646 -0
  121. package/kits/real-time/castle.json +2 -2
  122. package/kits/real-time/code/client/ownership.js +14 -4
  123. package/kits/real-time/code/client/smooth.js +2 -2
  124. package/kits/real-time/code/server/session.js +20 -4
  125. package/package.json +2 -2
@@ -0,0 +1,674 @@
1
+ // Paint: patterns layered over a part's color -- stripes, checker, spots,
2
+ // grime, cavity and edges. See docs/pxmodel-format.md for the fields.
3
+ //
4
+ // Paint is written as vertex colors, so it needs no UVs and works on every
5
+ // kind. The mesh becomes a list of triangles that is split where a pattern
6
+ // needs it: long edges are split for the soft patterns, stripes and checker cut
7
+ // every triangle along their borders so each piece is one color, and edges
8
+ // that a spot's border crosses are split until they are short. Every triangle
9
+ // keeps its own three corner colors, so a border between two pieces is sharp.
10
+ //
11
+ // Patterns are measured in the part's own space, from its pivot, so they move
12
+ // and turn with the part.
13
+
14
+ import * as THREE from 'three';
15
+ import { valueNoise } from './partgeometry';
16
+
17
+ // Splitting for the soft patterns stops near this many triangles, and
18
+ // splitting along spot borders may add as many again. Stripe and checker cuts
19
+ // are always made.
20
+ const MAX_TRIANGLES = 10000;
21
+
22
+ const AXES = { x: 0, y: 1, z: 2 };
23
+
24
+ const PATTERNS = new Set(['stripes', 'checker', 'spots', 'grime', 'cracks', 'cavity', 'edges']);
25
+
26
+ // Distance from a mask's `above` or `below` line over which a layer fades.
27
+ const MASK_FADE = 0.05;
28
+
29
+ export function hasPaint(part) {
30
+ return paintLayers(part).length > 0;
31
+ }
32
+
33
+ function paintLayers(part) {
34
+ if (!Array.isArray(part.paint)) {
35
+ return [];
36
+ }
37
+ return part.paint.filter((layer) => layer && PATTERNS.has(layer.pattern));
38
+ }
39
+
40
+ // Replaces the mesh's geometry with a split copy that carries the paint as
41
+ // vertex colors. Edges shorter than `detail.edge` meters (optimize.js) are
42
+ // not split.
43
+ export function applyPaint(mesh, part, detail = null) {
44
+ const layers = paintLayers(part).map(prepareLayer);
45
+ const space = partSpace(part);
46
+ const materials = [mesh.material].flat();
47
+ const soup = toTriangles(mesh.geometry, materials);
48
+
49
+ cutBands(soup, layers, space, detail?.finest ?? 0);
50
+ const shortest = detail?.edge ?? 0;
51
+ refineForLayers(soup, layers, space, shortest);
52
+ for (const layer of layers) {
53
+ if (layer.pattern === 'spots') {
54
+ splitSpotBorders(soup, layer, space, shortest);
55
+ }
56
+ }
57
+ paintTriangles(soup, layers, space);
58
+
59
+ const geometry = fromTriangles(soup, mesh.geometry);
60
+ if (mesh.userData.triFaces) {
61
+ mesh.userData.triFaces = soup.triangles.map(
62
+ (triangle) => mesh.userData.triFaces[triangle.source]
63
+ );
64
+ }
65
+ mesh.geometry.dispose();
66
+ mesh.geometry = geometry;
67
+ for (const material of materials) {
68
+ if (!material.map) {
69
+ material.color.set('#ffffff');
70
+ }
71
+ material.vertexColors = true;
72
+ material.needsUpdate = true;
73
+ }
74
+ }
75
+
76
+ //
77
+ // Layers
78
+ //
79
+
80
+ // Stripes and checker cut every triangle along their borders. Bands and
81
+ // cells narrower than `finest` would be under a pixel or two in the game;
82
+ // they are blended into one color instead of cut.
83
+ function cutBands(soup, layers, space, finest) {
84
+ for (const layer of layers) {
85
+ if (layer.pattern === 'stripes' || layer.pattern === 'checker') {
86
+ layer.blended = layer.spacing < finest;
87
+ for (const direction of layer.blended ? [] : layer.directions) {
88
+ cutAlong(soup, direction, layer.spacing, space);
89
+ }
90
+ }
91
+ }
92
+ }
93
+
94
+ // A layer with its defaults filled in, colors parsed, and the directions its
95
+ // stripes or checker cells are measured along.
96
+ function prepareLayer(raw) {
97
+ const layer = { ...raw, seed: Number.isFinite(raw.seed) ? raw.seed : 1 };
98
+ const number = (value, fallback) => (Number.isFinite(value) && value > 0 ? value : fallback);
99
+ layer.amount = Number.isFinite(raw.amount) ? Math.max(0, Math.min(1, raw.amount)) : 0.5;
100
+ layer.color = typeof raw.color === 'string' ? new THREE.Color(raw.color) : null;
101
+ if (layer.pattern === 'stripes') {
102
+ layer.colors = colorList(raw.colors, ['#f2b705', '#1c1c1c']);
103
+ layer.spacing = number(raw.width, 0.1);
104
+ layer.directions = [stripeDirection(raw.axis, raw.angle)];
105
+ } else if (layer.pattern === 'checker') {
106
+ layer.colors = colorList(raw.colors, ['#f2f2f2', '#1c1c1c']);
107
+ layer.spacing = number(raw.size, 0.1);
108
+ layer.directions = [0, 1, 2]
109
+ .filter((axis) => axis !== AXES[raw.axis])
110
+ .map((axis) => new THREE.Vector3().setComponent(axis, 1));
111
+ } else if (layer.pattern === 'spots') {
112
+ layer.color ??= new THREE.Color('#f4efe6');
113
+ layer.size = number(raw.size, 0.05);
114
+ layer.density = Number.isFinite(raw.density) ? Math.max(0, Math.min(1, raw.density)) : 0.5;
115
+ layer.distances = new Map();
116
+ } else if (['grime', 'cracks'].includes(layer.pattern)) {
117
+ layer.color ??= new THREE.Color('#3d3226');
118
+ layer.scale = number(raw.scale, 3);
119
+ } else {
120
+ layer.width = number(raw.width, layer.pattern === 'edges' ? 0.03 : 0.08);
121
+ }
122
+ return layer;
123
+ }
124
+
125
+ // One color alone alternates with the color underneath, written as null.
126
+ function colorList(value, fallback) {
127
+ const colors = (Array.isArray(value) ? value : fallback).filter((c) => typeof c === 'string');
128
+ const list = colors.length > 0 ? colors : fallback;
129
+ return (list.length === 1 ? [list[0], null] : list).map((c) => (c ? new THREE.Color(c) : null));
130
+ }
131
+
132
+ // Stripes run across `axis` (default z, facing the front). At angle 0 they are
133
+ // level bands stacked up y, or stacked along z for axis y; `angle` turns them
134
+ // by that many degrees about the axis.
135
+ function stripeDirection(axisName, angle) {
136
+ const axis = new THREE.Vector3().setComponent(AXES[axisName] ?? 2, 1);
137
+ const across = axisName === 'y' ? new THREE.Vector3(0, 0, 1) : new THREE.Vector3(0, 1, 0);
138
+ return across.applyAxisAngle(axis, ((Number.isFinite(angle) ? angle : 0) * Math.PI) / 180);
139
+ }
140
+
141
+ // How the mesh's own positions and normals map into the part's space: the
142
+ // mesh sits at `offset` from the pivot and is stretched by `scale`.
143
+ function partSpace(part) {
144
+ const offset = new THREE.Vector3(...part.offset);
145
+ const scale = new THREE.Vector3(...part.scale.map((s) => s || 1));
146
+ return {
147
+ point: (corner) =>
148
+ new THREE.Vector3(corner[0], corner[1], corner[2]).multiply(scale).add(offset),
149
+ distance: (a, b) =>
150
+ Math.hypot((a[0] - b[0]) * scale.x, (a[1] - b[1]) * scale.y, (a[2] - b[2]) * scale.z),
151
+ normal: (corner, at) =>
152
+ new THREE.Vector3(corner[at], corner[at + 1], corner[at + 2]).divide(scale).normalize(),
153
+ };
154
+ }
155
+
156
+ //
157
+ // Triangles
158
+ //
159
+
160
+ // The geometry as a list of triangles. A corner is one flat array holding
161
+ // every attribute, laid out as `layout` says, with position first. Each
162
+ // triangle keeps its material group and the index of the triangle it came
163
+ // from. A color attribute is added when there is none, from each group's
164
+ // material color, or white under art.
165
+ function toTriangles(geometry, materials) {
166
+ const flat = geometry.index ? geometry.toNonIndexed() : geometry;
167
+ if (!flat.attributes.normal) {
168
+ flat.computeVertexNormals();
169
+ }
170
+ const names = ['position', ...Object.keys(flat.attributes).filter((n) => n !== 'position')];
171
+ const layout = [];
172
+ let width = 0;
173
+ for (const name of names) {
174
+ layout.push({ name, itemSize: flat.attributes[name].itemSize, at: width });
175
+ width += flat.attributes[name].itemSize;
176
+ }
177
+ const hasColor = names.includes('color');
178
+ if (!hasColor) {
179
+ layout.push({ name: 'color', itemSize: 3, at: width });
180
+ width += 3;
181
+ }
182
+ const count = flat.attributes.position.count / 3;
183
+ const groupOf = new Array(count).fill(0);
184
+ for (const group of flat.groups) {
185
+ for (let t = group.start / 3; t < Math.min(count, (group.start + group.count) / 3); t++) {
186
+ groupOf[t] = group.materialIndex ?? 0;
187
+ }
188
+ }
189
+ const readCorner = (index, group) => {
190
+ const corner = new Array(width);
191
+ for (const { name, itemSize, at } of layout) {
192
+ if (name === 'color' && !hasColor) {
193
+ const material = materials[group] ?? materials[0];
194
+ const base = material.map ? new THREE.Color(1, 1, 1) : material.color;
195
+ corner.splice(at, 3, base.r, base.g, base.b);
196
+ continue;
197
+ }
198
+ for (let k = 0; k < itemSize; k++) {
199
+ corner[at + k] = flat.attributes[name].getComponent(index, k);
200
+ }
201
+ }
202
+ return corner;
203
+ };
204
+ const triangles = [];
205
+ for (let t = 0; t < count; t++) {
206
+ const group = groupOf[t];
207
+ const corners = [0, 1, 2].map((k) => readCorner(t * 3 + k, group));
208
+ triangles.push({ corners, group, source: t });
209
+ }
210
+ const at = (name) => layout.find((entry) => entry.name === name)?.at ?? -1;
211
+ return { layout, triangles, normalAt: at('normal'), colorAt: at('color') };
212
+ }
213
+
214
+ function fromTriangles(soup, original) {
215
+ const geometry = new THREE.BufferGeometry();
216
+ const corners = soup.triangles.flatMap((triangle) => triangle.corners);
217
+ for (const { name, itemSize, at } of soup.layout) {
218
+ const values = new Float32Array(corners.length * itemSize);
219
+ corners.forEach((corner, i) => {
220
+ for (let k = 0; k < itemSize; k++) {
221
+ values[i * itemSize + k] = corner[at + k];
222
+ }
223
+ });
224
+ geometry.setAttribute(name, new THREE.BufferAttribute(values, itemSize));
225
+ }
226
+ if (original.groups.length > 0) {
227
+ let start = 0;
228
+ for (let t = 1; t <= soup.triangles.length; t++) {
229
+ const group = soup.triangles[start].group;
230
+ if (t === soup.triangles.length || soup.triangles[t].group !== group) {
231
+ geometry.addGroup(start * 3, (t - start) * 3, group);
232
+ start = t;
233
+ }
234
+ }
235
+ }
236
+ return geometry;
237
+ }
238
+
239
+ function blend(a, b, t) {
240
+ return a.map((value, k) => value + (b[k] - value) * t);
241
+ }
242
+
243
+ function area(soup, space) {
244
+ let total = 0;
245
+ for (const { corners } of soup.triangles) {
246
+ const [a, b, c] = corners.map(space.point);
247
+ total += b.sub(a).cross(c.sub(a)).length() / 2;
248
+ }
249
+ return total;
250
+ }
251
+
252
+ //
253
+ // Splitting
254
+ //
255
+
256
+ // Splits every edge that `shouldSplit(a, b)` picks at its middle. The rule
257
+ // sees only the edge's two corners, so the two triangles that share an edge
258
+ // split it alike and no cracks open. A triangle with one split edge becomes
259
+ // two, with two becomes three, with three becomes four. Returns whether any
260
+ // edge was split.
261
+ function splitEdges(soup, shouldSplit) {
262
+ const out = [];
263
+ let changed = false;
264
+ for (const triangle of soup.triangles) {
265
+ const q = triangle.corners;
266
+ const split = [0, 1, 2].map((e) => shouldSplit(q[e], q[(e + 1) % 3]));
267
+ const count = split.filter(Boolean).length;
268
+ if (count === 0) {
269
+ out.push(triangle);
270
+ continue;
271
+ }
272
+ changed = true;
273
+ const middle = [0, 1, 2].map((e) => blend(q[e], q[(e + 1) % 3], 0.5));
274
+ const emit = (...corners) => out.push({ ...triangle, corners });
275
+ if (count === 3) {
276
+ emit(q[0], middle[0], middle[2]);
277
+ emit(middle[0], q[1], middle[1]);
278
+ emit(middle[2], middle[1], q[2]);
279
+ emit(middle[0], middle[1], middle[2]);
280
+ } else if (count === 1) {
281
+ const e = split.indexOf(true);
282
+ emit(q[e], middle[e], q[(e + 2) % 3]);
283
+ emit(middle[e], q[(e + 1) % 3], q[(e + 2) % 3]);
284
+ } else {
285
+ // Edge e stays whole; the two after it are split.
286
+ const e = split.indexOf(false);
287
+ const [p0, p1, p2] = [q[e], q[(e + 1) % 3], q[(e + 2) % 3]];
288
+ const [m1, m2] = [middle[(e + 1) % 3], middle[(e + 2) % 3]];
289
+ emit(m1, p2, m2);
290
+ emit(p0, p1, m1);
291
+ emit(p0, m1, m2);
292
+ }
293
+ }
294
+ soup.triangles = out;
295
+ return changed;
296
+ }
297
+
298
+ // The soft patterns need edges shorter than their smallest feature. The
299
+ // target is raised when the part is too big to reach it under the triangle
300
+ // limit.
301
+ function refineForLayers(soup, layers, space, shortest) {
302
+ const needs = layers.map((layer) => {
303
+ if (layer.pattern === 'grime') {
304
+ return 1 / (layer.scale * 6);
305
+ }
306
+ if (layer.pattern === 'cracks') {
307
+ return 1 / (layer.scale * 12);
308
+ }
309
+ if (layer.pattern === 'spots') {
310
+ return layer.size / 2;
311
+ }
312
+ if (layer.pattern === 'cavity' || layer.pattern === 'edges') {
313
+ return layer.width / 2;
314
+ }
315
+ return Infinity;
316
+ });
317
+ let target = Math.min(...needs);
318
+ if (!Number.isFinite(target)) {
319
+ return;
320
+ }
321
+ target = Math.max(target, shortest, Math.sqrt(area(soup, space) / (0.1 * MAX_TRIANGLES)));
322
+ for (let pass = 0; pass < 12 && soup.triangles.length < MAX_TRIANGLES; pass++) {
323
+ if (!splitEdges(soup, (a, b) => space.distance(a, b) > target)) {
324
+ break;
325
+ }
326
+ }
327
+ }
328
+
329
+ // Edges near a spot's border are split until they are short, so a spot on a
330
+ // coarse mesh still has a clean round edge. An edge that a border crosses has
331
+ // an end no further from the border than the edge is long, so every spot that
332
+ // touches an edge is found.
333
+ function splitSpotBorders(soup, layer, space, smallest) {
334
+ const shortest = Math.max(layer.size / 8, smallest / 2);
335
+ const limit = soup.triangles.length + MAX_TRIANGLES;
336
+ const near = (a, b) => {
337
+ const length = space.distance(a, b);
338
+ const border = Math.min(Math.abs(spotAt(a, layer, space)), Math.abs(spotAt(b, layer, space)));
339
+ return length > shortest && border < length;
340
+ };
341
+ for (let pass = 0; pass < 5 && soup.triangles.length < limit; pass++) {
342
+ if (!splitEdges(soup, near)) {
343
+ break;
344
+ }
345
+ }
346
+ }
347
+
348
+ // Cuts every triangle along the planes where `direction . point` is a whole
349
+ // multiple of `spacing`, so each piece lies between two neighbouring planes.
350
+ function cutAlong(soup, direction, spacing, space) {
351
+ const out = [];
352
+ for (const triangle of soup.triangles) {
353
+ let polygon = triangle.corners.map((corner) => ({
354
+ corner,
355
+ value: space.point(corner).dot(direction) / spacing,
356
+ }));
357
+ const values = polygon.map((entry) => entry.value);
358
+ const first = Math.floor(Math.min(...values)) + 1;
359
+ const last = Math.ceil(Math.max(...values)) - 1;
360
+ for (let level = first; level <= last; level++) {
361
+ const [below, above] = splitPolygon(polygon, level);
362
+ fan(below, triangle, out);
363
+ polygon = above;
364
+ }
365
+ fan(polygon, triangle, out);
366
+ }
367
+ soup.triangles = out;
368
+ }
369
+
370
+ // The part of a convex polygon below `level` and the part above it. A point
371
+ // on a crossed edge is found from the edge's lower end, so both triangles
372
+ // sharing the edge find the same point.
373
+ function splitPolygon(polygon, level) {
374
+ const below = [];
375
+ const above = [];
376
+ polygon.forEach((entry, i) => {
377
+ const next = polygon[(i + 1) % polygon.length];
378
+ (entry.value < level ? below : above).push(entry);
379
+ if (entry.value < level !== next.value < level) {
380
+ const [low, high] = entry.value < next.value ? [entry, next] : [next, entry];
381
+ const t = (level - low.value) / (high.value - low.value);
382
+ const point = { corner: blend(low.corner, high.corner, t), value: level };
383
+ below.push(point);
384
+ above.push(point);
385
+ }
386
+ });
387
+ return [below, above];
388
+ }
389
+
390
+ function fan(polygon, triangle, out) {
391
+ for (let i = 1; i + 1 < polygon.length; i++) {
392
+ const corners = [polygon[0], polygon[i], polygon[i + 1]].map((entry) => entry.corner);
393
+ out.push({ ...triangle, corners });
394
+ }
395
+ }
396
+
397
+ //
398
+ // Coloring
399
+ //
400
+
401
+ // Each corner starts from its own color and each layer is laid over it in
402
+ // order. Stripes and checker pick a color by the triangle's middle, which
403
+ // lies in one band or cell.
404
+ function paintTriangles(soup, layers, space) {
405
+ const bends = layers.some((layer) => layer.pattern === 'cavity' || layer.pattern === 'edges')
406
+ ? bendMap(soup, space, Math.max(...layers.map((layer) => layer.width ?? 0)))
407
+ : null;
408
+ for (const triangle of soup.triangles) {
409
+ const points = triangle.corners.map(space.point);
410
+ const middle = points[0].clone().add(points[1]).add(points[2]).divideScalar(3);
411
+ const size = Math.max(
412
+ points[0].distanceTo(points[1]),
413
+ points[1].distanceTo(points[2]),
414
+ points[2].distanceTo(points[0])
415
+ );
416
+ triangle.corners = triangle.corners.map((corner, k) => {
417
+ const color = new THREE.Color().fromArray(corner, soup.colorAt);
418
+ const where = { point: points[k], middle, size, corner, soup, space, bends };
419
+ for (const layer of layers) {
420
+ paintLayer(color, layer, where);
421
+ }
422
+ const painted = corner.slice();
423
+ color.toArray(painted, soup.colorAt);
424
+ return painted;
425
+ });
426
+ }
427
+ }
428
+
429
+ function paintLayer(color, layer, where) {
430
+ const weight = maskWeight(layer, where.point);
431
+ if (weight <= 0) {
432
+ return;
433
+ }
434
+ if (layer.blended) {
435
+ const mixed = new THREE.Color(0, 0, 0);
436
+ for (const choice of layer.colors) {
437
+ mixed.add(choice ?? color);
438
+ }
439
+ color.lerp(mixed.multiplyScalar(1 / layer.colors.length), weight);
440
+ return;
441
+ }
442
+ if (layer.pattern === 'stripes' || layer.pattern === 'checker') {
443
+ const cell = layer.directions.reduce(
444
+ (sum, direction) => sum + Math.floor(where.middle.dot(direction) / layer.spacing),
445
+ 0
446
+ );
447
+ const count = layer.colors.length;
448
+ const chosen = layer.colors[((cell % count) + count) % count];
449
+ if (chosen) {
450
+ color.lerp(chosen, weight);
451
+ }
452
+ return;
453
+ }
454
+ const [amount, target] = softLayer(color, layer, where);
455
+ color.lerp(target, Math.max(0, Math.min(1, amount * weight)));
456
+ }
457
+
458
+ // How much of a soft layer shows at a point, and its color there.
459
+ function softLayer(color, layer, where) {
460
+ const { point } = where;
461
+ if (layer.pattern === 'spots') {
462
+ return [spotValue(spotAt(where.corner, layer, where.space), layer), layer.color];
463
+ }
464
+ if (layer.pattern === 'grime') {
465
+ const edge = 1 - layer.amount;
466
+ return [
467
+ smoothstep(edge - 0.1, edge + 0.3, noiseLevel(point, layer.scale, layer.seed)),
468
+ layer.color,
469
+ ];
470
+ }
471
+ if (layer.pattern === 'cracks') {
472
+ return [crackLevel(point, layer), layer.color];
473
+ }
474
+ const bend = where.bends(where.corner, layer.width);
475
+
476
+ // On a triangle much wider than the band, a corner's color spreads across
477
+ // the whole triangle, so the band is thinned to what it covers of it.
478
+ const covered = Math.min(1, (4 * layer.width) / Math.max(where.size, 1e-6));
479
+ if (layer.pattern === 'cavity') {
480
+ const amount = smoothstep(0.05, 0.4, -bend) * Math.min(1, layer.amount * 1.6) * covered;
481
+ return [amount, layer.color ?? color.clone().multiplyScalar(0.25)];
482
+ }
483
+
484
+ // Worn edges are broken up by noise, so they read as chips.
485
+ // A higher `amount` lowers the bar, so more of each edge wears through.
486
+ const chips = noiseLevel(point, 1.5 / layer.width, layer.seed);
487
+ const wear = smoothstep(0.05, 0.4, bend) * (0.3 + chips);
488
+ const bar = 1.1 - layer.amount * 0.7;
489
+ const amount = smoothstep(bar - 0.08, bar + 0.08, wear) * covered;
490
+ return [amount, layer.color ?? color.clone().lerp(new THREE.Color(1, 1, 1), 0.6)];
491
+ }
492
+
493
+ // Cracks are the places where the noise crosses its middle, which join up into
494
+ // a network of thin lines. A higher `amount` makes the lines wider.
495
+ function crackLevel(point, layer) {
496
+ const width = 0.015 + layer.amount * 0.06;
497
+ return smoothstep(width, width * 0.3, Math.abs(fractalNoise(point, layer.scale, layer.seed)));
498
+ }
499
+
500
+ // `above` and `below` limit a layer to part of the part, measured up its y
501
+ // axis from the pivot, with a short fade across the line.
502
+ function maskWeight(layer, point) {
503
+ let weight = 1;
504
+ if (Number.isFinite(layer.below)) {
505
+ weight *= smoothstep(layer.below + MASK_FADE, layer.below - MASK_FADE, point.y);
506
+ }
507
+ if (Number.isFinite(layer.above)) {
508
+ weight *= smoothstep(layer.above - MASK_FADE, layer.above + MASK_FADE, point.y);
509
+ }
510
+ return weight;
511
+ }
512
+
513
+ function smoothstep(low, high, value) {
514
+ const t = Math.max(0, Math.min(1, (value - low) / (high - low)));
515
+ return t * t * (3 - 2 * t);
516
+ }
517
+
518
+ // Three octaves of value noise, -1 to 1, with `scale` bumps per unit.
519
+ function fractalNoise(point, scale, seed) {
520
+ const [x, y, z] = [point.x * scale, point.y * scale, point.z * scale];
521
+ return (
522
+ valueNoise(x, y, z, seed) * 0.6 +
523
+ valueNoise(x * 2.3, y * 2.3, z * 2.3, seed + 11) * 0.3 +
524
+ valueNoise(x * 5.1, y * 5.1, z * 5.1, seed + 23) * 0.1
525
+ );
526
+ }
527
+
528
+ // Fractal noise as a level from 0 to 1. The noise mostly stays near its
529
+ // middle, so it is stretched to reach both ends.
530
+ function noiseLevel(point, scale, seed) {
531
+ return Math.max(0, Math.min(1, 0.5 + fractalNoise(point, scale, seed) * 1.5));
532
+ }
533
+
534
+ //
535
+ // Spots
536
+ //
537
+
538
+ // A number from 0 to 1 for a grid cell, the seed and a slot `k`.
539
+ function cellRandom(x, y, z, seed, k) {
540
+ let h = Math.imul(x, 374761393) ^ Math.imul(y, 668265263) ^ Math.imul(z, 1274126177);
541
+ h ^= Math.imul(seed * 97 + k, 2246822519);
542
+ h = Math.imul(h ^ (h >>> 13), 3266489917);
543
+ h ^= h >>> 16;
544
+ return (h >>> 0) / 4294967296;
545
+ }
546
+
547
+ // The distance from a corner to the nearest spot's border, below 0 inside a
548
+ // spot, measured once per place.
549
+ function spotAt(corner, layer, space) {
550
+ const key = placeKey(corner);
551
+ if (!layer.distances.has(key)) {
552
+ layer.distances.set(key, spotDistance(space.point(corner), layer));
553
+ }
554
+ return layer.distances.get(key);
555
+ }
556
+
557
+ // 1 inside a spot and 0 outside, with a thin soft rim.
558
+ function spotValue(distance, layer) {
559
+ return smoothstep(layer.size * 0.06, 0, distance);
560
+ }
561
+
562
+ // Space is cut into cubes 2.5 spot sizes wide; each holds a spot with chance
563
+ // `density`, a ball at a random place with a radius of half to all of `size`.
564
+ // A surface cuts the balls in round spots of many sizes. The point's own cube
565
+ // and the 26 around it are searched, so the distance is right up to about two
566
+ // spot sizes away, and is at least that beyond.
567
+ function spotDistance(point, layer) {
568
+ const cell = layer.size * 2.5;
569
+ const [cx, cy, cz] = [point.x, point.y, point.z].map((v) => Math.floor(v / cell));
570
+ const wobble = valueNoise(point.x / layer.size, point.y / layer.size, point.z / layer.size, 5);
571
+ const center = new THREE.Vector3();
572
+ let nearest = cell;
573
+ for (let n = 0; n < 27; n++) {
574
+ const [x, y, z] = [
575
+ cx + (n % 3) - 1,
576
+ cy + (Math.floor(n / 3) % 3) - 1,
577
+ cz + Math.floor(n / 9) - 1,
578
+ ];
579
+ if (cellRandom(x, y, z, layer.seed, 0) > layer.density) {
580
+ continue;
581
+ }
582
+ center.set(
583
+ (x + cellRandom(x, y, z, layer.seed, 1)) * cell,
584
+ (y + cellRandom(x, y, z, layer.seed, 2)) * cell,
585
+ (z + cellRandom(x, y, z, layer.seed, 3)) * cell
586
+ );
587
+ const radius = layer.size * (0.5 + 0.5 * cellRandom(x, y, z, layer.seed, 4));
588
+ nearest = Math.min(nearest, point.distanceTo(center) - radius);
589
+ }
590
+ return nearest + wobble * layer.size * 0.12;
591
+ }
592
+
593
+ //
594
+ // Bends
595
+ //
596
+
597
+ // How the surface bends around a corner: above 0 where it curves away (a
598
+ // convex edge), below 0 where it curves in (a crease), near 1 at a right-angle
599
+ // edge. On a convex surface the normals spread apart going outward from a
600
+ // point, and on a concave one they close in; the bend is the average of that
601
+ // spread over the nearby surface points, nearer ones counting more. Normals
602
+ // are used, not positions, so a smooth-shaded part made of flat facets reads
603
+ // as smooth. Points facing the other way, such as the back of a thin plate,
604
+ // are left out. Returns a function of a corner and a radius; each corner is
605
+ // measured once.
606
+ function bendMap(soup, space, largest) {
607
+ const places = new Map();
608
+ for (const { corners } of soup.triangles) {
609
+ for (const corner of corners) {
610
+ const key = placeKey(corner);
611
+ if (!places.has(key)) {
612
+ places.set(key, { point: space.point(corner), facing: new THREE.Vector3() });
613
+ }
614
+ places.get(key).facing.add(space.normal(corner, soup.normalAt));
615
+ }
616
+ }
617
+ const list = [...places.values()];
618
+ list.forEach((place) => place.facing.normalize());
619
+ const grid = new Map();
620
+ const cell = largest || 1;
621
+ const cellKey = (x, y, z) => `${x},${y},${z}`;
622
+ for (const place of list) {
623
+ const key = cellKey(...place.point.toArray().map((v) => Math.floor(v / cell)));
624
+ if (!grid.has(key)) {
625
+ grid.set(key, []);
626
+ }
627
+ grid.get(key).push(place);
628
+ }
629
+ const cache = new Map();
630
+ return (corner, radius) => {
631
+ const normal = space.normal(corner, soup.normalAt);
632
+ const key = `${placeKey(corner)}|${normal.toArray().map((v) => v.toFixed(2))}|${radius}`;
633
+ if (!cache.has(key)) {
634
+ const point = places.get(placeKey(corner)).point;
635
+ const cells = point.toArray().map((v) => Math.floor(v / cell));
636
+ cache.set(
637
+ key,
638
+ bendAt(point, normal, radius, (dx, dy, dz) => {
639
+ return grid.get(cellKey(cells[0] + dx, cells[1] + dy, cells[2] + dz)) ?? [];
640
+ })
641
+ );
642
+ }
643
+ return cache.get(key);
644
+ };
645
+ }
646
+
647
+ function placeKey(corner) {
648
+ return `${Math.round(corner[0] * 1e4)},${Math.round(corner[1] * 1e4)},${Math.round(corner[2] * 1e4)}`;
649
+ }
650
+
651
+ function bendAt(point, normal, radius, near) {
652
+ const offset = new THREE.Vector3();
653
+ const spread = new THREE.Vector3();
654
+ let sum = 0;
655
+ let total = 0;
656
+ for (let dx = -1; dx <= 1; dx++) {
657
+ for (let dy = -1; dy <= 1; dy++) {
658
+ for (let dz = -1; dz <= 1; dz++) {
659
+ for (const place of near(dx, dy, dz)) {
660
+ offset.subVectors(place.point, point);
661
+ const distance = offset.length();
662
+ if (distance === 0 || distance > radius || place.facing.dot(normal) < -0.2) {
663
+ continue;
664
+ }
665
+ const weight = 1 - distance / radius;
666
+ spread.subVectors(place.facing, normal);
667
+ sum += (weight * spread.dot(offset)) / distance;
668
+ total += weight;
669
+ }
670
+ }
671
+ }
672
+ }
673
+ return total > 0 ? sum / total : 0;
674
+ }