@aethervtt/shard-scatter 0.0.0-stage → 0.2.0

package/dist/testing.js

@@ -0,0 +1,231 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { NoiseGraph } from "@aethervtt/shard-noise";
+import { procgenPlugin } from "@aethervtt/shard-procgen";
+import { ScenePlugin } from "@aethervtt/shard-scene";
+import { Biome, BiomeSet, Planet } from "@aethervtt/shard-terrain";
+import { planetApp } from "@aethervtt/shard-terrain/testing";
+import { Transform } from "@aethervtt/shard-transform";
+import { Prop, propIdentity } from "./components.js";
+import { scatterPlugin } from "./plugin.js";
+import { Scatter } from "./runtime.js";
+import { ScatterSet } from "./set.js";
+const TEST_RADIUS = 2e4;
+const TEST_HEIGHT = {
+  output: "h",
+  nodes: {
+    hills: { fbm: { source: "simplex", octaves: 5, frequency: 4e-4, seed: 21 } },
+    ridges: { ridged: { source: "simplex", octaves: 4, frequency: 15e-5, seed: 22 } },
+    h: { add: ["hills", { multiply: ["ridges", 0.6] }] }
+  }
+};
+const TEST_CLIMATE = {
+  output: "temperature",
+  nodes: {
+    temperature: { add: [{ fbm: { octaves: 2, frequency: 1e-4, seed: 23 } }, 0.6] },
+    moisture: { fbm: { octaves: 3, frequency: 12e-4, seed: 24 } }
+  }
+};
+const GRASSLAND_SET = {
+  rules: [
+    {
+      name: "boulders",
+      items: [{ generator: "shard/Rock", params: { radius: 0.9, detail: 3 }, variants: 4 }],
+      density: 3e-3,
+      spacing: 6,
+      align: 0.7,
+      scale: [0.6, 1.5],
+      sink: 0.15,
+      collider: "convex",
+      range: 300
+    },
+    {
+      name: "bushes",
+      items: [{ generator: "shard/Bush", variants: 4 }],
+      density: 0.02,
+      spacing: 2.5,
+      masks: { slope: [0, 22] },
+      scale: [0.7, 1.3],
+      avoid: ["boulders"],
+      range: 150
+    },
+    {
+      name: "grass",
+      kind: "foliage",
+      items: [{ generator: "shard/GrassClump", variants: 4 }],
+      density: 5,
+      masks: { slope: [0, 25] },
+      align: 0.4,
+      scale: [0.7, 1.4],
+      avoid: ["boulders"],
+      range: 50
+    }
+  ]
+};
+const FOREST_SET = {
+  rules: [
+    {
+      name: "trees",
+      items: [{ generator: "shard/Tree", variants: 6 }],
+      density: 0.02,
+      spacing: 4,
+      masks: { slope: [0, 25] },
+      scale: [0.7, 1.3],
+      sink: 0.02,
+      collider: "ball",
+      range: 400
+    },
+    {
+      name: "bushes",
+      items: [{ generator: "shard/Bush", params: { radius: 0.6 }, variants: 3 }],
+      density: 0.05,
+      spacing: 1.5,
+      avoid: ["trees"],
+      range: 120
+    },
+    {
+      name: "grass",
+      kind: "foliage",
+      items: [{ generator: "shard/GrassClump", params: { height: 0.4 }, variants: 3 }],
+      density: 2,
+      avoid: ["trees"],
+      range: 40
+    }
+  ]
+};
+const ROCK_SET = {
+  rules: [
+    {
+      name: "boulders",
+      items: [{ generator: "shard/Rock", params: { radius: 1.5, roughness: 0.6 }, variants: 6 }],
+      density: 0.012,
+      spacing: 5,
+      align: 1,
+      scale: [0.5, 2],
+      sink: 0.25,
+      collider: "convex",
+      range: 400
+    },
+    {
+      name: "crystals",
+      items: [{ generator: "shard/Crystal", variants: 4 }],
+      density: 4e-3,
+      spacing: 6,
+      align: 0.5,
+      avoid: ["boulders"],
+      range: 250
+    }
+  ]
+};
+async function scatterPlanet(gpu, platform, options = {}) {
+  const p = await planetApp(gpu, {
+    radius: TEST_RADIUS,
+    heightScale: 250,
+    height: await NoiseGraph.create(TEST_HEIGHT),
+    climate: await NoiseGraph.create(TEST_CLIMATE),
+    seed: 3,
+    width: options.width ?? 160,
+    heightPx: options.height ?? 100,
+    msaa: options.msaa,
+    renderScale: options.renderScale,
+    physics: false,
+    clearColor: [0.45, 0.6, 0.85, 1],
+    extra: [
+      ScenePlugin,
+      procgenPlugin(),
+      scatterPlugin({ workers: options.workers ? platform.workers : void 0 }),
+      ...options.extra ?? []
+    ]
+  });
+  const w = p.world;
+  await assetServer(w).configure({ platform }).scan();
+  const sets = w.initResource(ScatterSet.store);
+  const grassland = sets.add(ScatterSet.deserialize(GRASSLAND_SET), "grassland.scatter");
+  const forest = sets.add(ScatterSet.deserialize(FOREST_SET), "forest.scatter");
+  const rocks = sets.add(ScatterSet.deserialize(ROCK_SET), "rocks.scatter");
+  const biomes = w.initResource(Biome.store);
+  const json = (ref) => ({ guid: ref.guid, path: ref.path });
+  const biome = (value) => json(biomes.add(Biome.deserialize(value)));
+  const set = w.initResource(BiomeSet.store).add(
+    BiomeSet.deserialize({
+      biomes: [
+        biome({
+          moisture: [-2, 0.15],
+          slope: [0, 24],
+          tint: [0.32, 0.5, 0.18, 1],
+          scatter: json(grassland)
+        }),
+        biome({
+          moisture: [0.15, 2],
+          slope: [0, 24],
+          tint: [0.12, 0.3, 0.1, 1],
+          scatter: json(forest)
+        }),
+        biome({ slope: [24, 90], tint: [0.42, 0.4, 0.37, 1], scatter: json(rocks) })
+      ],
+      latitudeBias: 0
+    })
+  );
+  const everywhere = options.planetSet ? sets.add(
+    ScatterSet.deserialize(options.planetSet),
+    "planet.scatter"
+  ) : null;
+  w.set(p.planet, Planet, { biomes: set, scatter: everywhere });
+  return { ...p, sets: [grassland, forest, rocks] };
+}
+async function settleScatter(p, maxFrames = 600) {
+  let quiet = 0;
+  for (let f = 0; f < maxFrames; f++) {
+    p.app.update(1 / 60);
+    await new Promise((r) => setTimeout(r, 1));
+    const state = p.world.resource(Scatter);
+    let busy = state.surfaces.size === 0;
+    for (const ss of state.surfaces.values()) {
+      if (ss.problem) throw ss.problem;
+      if (!ss.ready) busy = true;
+      for (const c of ss.chunks.values()) {
+        if (c.job) busy = true;
+        const spawning = c.root < 0 || c.placements !== void 0 && c.next < c.placements.count;
+        if (c.wanted === state.frame && spawning) busy = true;
+      }
+      for (const fr of ss.foliage.values())
+        for (const c of fr.chunks.values()) if (c.job || c.slot < 0) busy = true;
+    }
+    quiet = busy ? 0 : quiet + 1;
+    if (quiet >= 3) return f;
+  }
+  return maxFrames;
+}
+function placementChecksum(world) {
+  const rows = [];
+  const f = new Float32Array(10);
+  const u = new Uint32Array(f.buffer);
+  for (const table of world.query({ with: [Prop, Transform] }).tables) {
+    for (let row = 0; row < table.count; row++) {
+      const e = table.entities[row];
+      const p = propIdentity(world, e);
+      const t = world.get(e, Transform);
+      f.set(t.translation, 0);
+      f.set(t.rotation, 3);
+      f.set(t.scale, 7);
+      rows.push(`${p.rule}|${p.chunk}|${p.index}|${Array.from(u).join(",")}`);
+    }
+  }
+  rows.sort();
+  let h = 2166136261;
+  for (const r of rows) {
+    for (let i = 0; i < r.length; i++) h = Math.imul(h ^ r.charCodeAt(i), 16777619);
+    h = Math.imul(h ^ 10, 16777619);
+  }
+  return { checksum: (h >>> 0).toString(16).padStart(8, "0"), props: rows.length };
+}
+export {
+  FOREST_SET,
+  GRASSLAND_SET,
+  ROCK_SET,
+  TEST_CLIMATE,
+  TEST_HEIGHT,
+  TEST_RADIUS,
+  placementChecksum,
+  scatterPlanet,
+  settleScatter
+};

package/dist/viewers.d.ts

@@ -0,0 +1,9 @@
+import type { Query, World } from '@aethervtt/shard-core';
+/** The query `cameraPositions` reads: every 3D camera with a world transform. */
+export declare function cameraQuery(world: World): Query;
+/**
+ * Calls `visit` with each active camera's world position (origin-relative, as GlobalTransform
+ * holds it) and its index; returns how many. Headless runs have cameras too (scenes spawn them),
+ * so scatter ranges work the same with or without a GPU.
+ */
+export declare function cameraPositions(_world: World, cameras: Query, visit: (x: number, y: number, z: number, index: number) => void): number;

package/dist/viewers.js

@@ -0,0 +1,22 @@
+import { Camera3d } from "@aethervtt/shard-render";
+import { GlobalTransform } from "@aethervtt/shard-transform";
+function cameraQuery(world) {
+  return world.query({ with: [Camera3d, GlobalTransform] });
+}
+function cameraPositions(_world, cameras, visit) {
+  let n = 0;
+  for (const table of cameras.tables) {
+    const active = table.column(Camera3d, "active");
+    const m = table.column(GlobalTransform, "matrix");
+    for (let row = 0; row < table.count; row++) {
+      if (!active[row]) continue;
+      visit(m[row * 12 + 3], m[row * 12 + 7], m[row * 12 + 11], n);
+      n++;
+    }
+  }
+  return n;
+}
+export {
+  cameraPositions,
+  cameraQuery
+};

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@aethervtt/shard-scatter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-assets": "0.2.0",
+    "@aethervtt/shard-core": "0.2.0",
+    "@aethervtt/shard-mesh": "0.2.0",
+    "@aethervtt/shard-noise": "0.2.0",
+    "@aethervtt/shard-physics": "0.2.0",
+    "@aethervtt/shard-platform": "0.2.0",
+    "@aethervtt/shard-procgen": "0.2.0",
+    "@aethervtt/shard-protocol": "0.2.0",
+    "@aethervtt/shard-render": "0.2.0",
+    "@aethervtt/shard-runtime": "0.2.0",
+    "@aethervtt/shard-scene": "0.2.0",
+    "@aethervtt/shard-shader": "0.2.0",
+    "@aethervtt/shard-terrain": "0.2.0",
+    "@aethervtt/shard-texture": "0.2.0",
+    "@aethervtt/shard-transform": "0.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/scatter"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
+  }
+}