@aethervtt/shard-scenes 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-scenes
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { PARITY_LAYERS, PARITY_TILES, type ParityAngle, type ParityOptions, type ParityScene, type ParityView, parityPlugins, poseParityCamera, showParityView, spawnParity, } from './parity.js';

package/dist/index.js

@@ -0,0 +1,16 @@
+import {
+  PARITY_LAYERS,
+  PARITY_TILES,
+  parityPlugins,
+  poseParityCamera,
+  showParityView,
+  spawnParity
+} from "./parity.js";
+export {
+  PARITY_LAYERS,
+  PARITY_TILES,
+  parityPlugins,
+  poseParityCamera,
+  showParityView,
+  spawnParity
+};

package/dist/parity.d.ts

@@ -0,0 +1,40 @@
+import { type AssetRef, type Entity, type Owner, type World } from '@aethervtt/shard-core';
+import type { Plugin } from '@aethervtt/shard-runtime';
+/** Render layers: 1 is shared; each view adds its own visuals' layer. */
+export declare const PARITY_LAYERS: {
+    readonly shared: 1;
+    readonly map: 2;
+    readonly tabletop: 4;
+};
+/** What the fixture adds beyond the renderer (`renderPlugin`, `forwardPlugin`, `TransformPlugin`). */
+export declare function parityPlugins(): Plugin[];
+/**
+ * The tile map (0059), one row per line: its first row lies beyond the north wall, and the cells
+ * the tests probe are stone. Its top-left corner is at world (x −2, z −9.5); tiles are 1 m.
+ */
+export declare const PARITY_TILES: {
+    origin: readonly [-2, -9.5];
+    rows: string[];
+};
+export interface ParityScene {
+    /** The orthographic Map camera: shared layer plus flat token discs. */
+    map: Entity;
+    /** The perspective Tabletop camera: shared layer plus standees. */
+    tabletop: Entity;
+    /** Token roots, each with a disc (Map) and a standee (Tabletop). */
+    tokens: Entity[];
+}
+export type ParityView = 'map' | 'tabletop';
+export type ParityAngle = 'top' | 30 | 55;
+export interface ParityOptions {
+    /** Where the cameras render. Omit for the window (a canvas). */
+    target?: AssetRef<'RenderTarget'>;
+    /** Who owns everything spawned (0061): releasing it removes the whole table. */
+    owner?: Owner;
+}
+/** Spawns the fixture into `world`. Both cameras start inactive: `showParityView` picks one. */
+export declare function spawnParity(world: World, options?: ParityOptions): ParityScene;
+/** Makes one view's camera the active one. */
+export declare function showParityView(world: World, scene: ParityScene, view: ParityView): void;
+/** Points a view's camera at the table's center from `angle` degrees above it (or straight down). */
+export declare function poseParityCamera(world: World, scene: ParityScene, view: ParityView, angle: ParityAngle): void;

package/dist/parity.js

@@ -0,0 +1,356 @@
+import {
+  ChildOf
+} from "@aethervtt/shard-core";
+import { FogLayer, FogRegionsStore, fogPlugin } from "@aethervtt/shard-fog";
+import { Grid, gridPlugin } from "@aethervtt/shard-grid";
+import { box, cylinder } from "@aethervtt/shard-mesh";
+import {
+  AmbientLight,
+  Camera3d,
+  DirectionalLight,
+  Exposure,
+  GroundLayer,
+  MaterialAsset,
+  Materials,
+  Mesh3d,
+  Meshes,
+  MeshMaterial,
+  NotShadowCaster,
+  PointLight,
+  RenderLayers,
+  Tonemapping
+} from "@aethervtt/shard-render";
+import {
+  spritePlugin,
+  TextureAtlas,
+  TextureAtlases,
+  Tilemap,
+  TilemapData,
+  TilemapDatas,
+  tilemapOnGround
+} from "@aethervtt/shard-sprite";
+import { Floor, Opening, structurePlugin, Wall } from "@aethervtt/shard-structure";
+import { Texture, Textures } from "@aethervtt/shard-texture";
+import { lookAt, Transform } from "@aethervtt/shard-transform";
+import { VectorShape, vectorPlugin } from "@aethervtt/shard-vector";
+const PARITY_LAYERS = { shared: 1, map: 2, tabletop: 4 };
+function parityPlugins() {
+  return [structurePlugin, gridPlugin, vectorPlugin, fogPlugin, spritePlugin];
+}
+const PARITY_TILES = {
+  origin: [-2, -9.5],
+  rows: [
+    "moss moss dirt moss moss moss dirt moss moss",
+    "stone stone stone stone crack stone stone stone stone",
+    "stone moss stone stone stone stone stone stone dirt",
+    "stone stone crack stone stone moss stone stone stone",
+    "dirt stone stone stone stone stone stone crack stone",
+    "stone stone stone moss stone stone dirt stone stone",
+    "stone crack stone stone stone stone stone stone moss",
+    "stone stone stone stone dirt stone stone stone stone"
+  ]
+};
+function tileAtlas(world) {
+  const names = ["stone", "crack", "moss", "dirt"];
+  const base = [
+    [150, 144, 132],
+    [150, 144, 132],
+    [78, 112, 60],
+    [124, 94, 66]
+  ];
+  const pixels = new Uint8Array(32 * 8 * 4);
+  for (let r = 0; r < 4; r++)
+    for (let y = 0; y < 8; y++)
+      for (let x = 0; x < 8; x++) {
+        const n = (x * 73 + y * 151 + r * 37) % 17 - 8;
+        const edge = x === 0 || y === 0 ? 0.7 : 1;
+        const crack = r === 1 && (x === y || x === y + 1) ? 0.55 : 1;
+        const [cr, cg, cb] = base[r];
+        const f = edge * crack;
+        pixels.set(
+          [
+            Math.max(0, Math.min(255, cr * f + n)),
+            Math.max(0, Math.min(255, cg * f + n)),
+            Math.max(0, Math.min(255, cb * f + n)),
+            255
+          ],
+          (y * 32 + r * 8 + x) * 4
+        );
+      }
+  const texture = world.resource(Textures).add(Texture.create({ width: 32, height: 8, mips: [pixels] }));
+  return world.resource(TextureAtlases).add(
+    new TextureAtlas(
+      texture,
+      names.map((name, i) => ({ name, rect: [i * 8, 0, 8, 8] }))
+    )
+  );
+}
+function spawnParity(world, options = {}) {
+  const owner = options.owner;
+  const plain = world.spawn.bind(world);
+  const spawn = (...inits) => owner ? world.owners.spawn(owner, ...inits) : plain(...inits);
+  const meshes = world.resource(Meshes);
+  const materials = world.resource(Materials);
+  const mat = (baseColor, roughness = 0.8) => materials.add(new MaterialAsset({ baseColor, roughness }));
+  world.resource(AmbientLight).brightness = 1500;
+  spawn(
+    [DirectionalLight, { illuminance: 2e4, shadows: true, shadowUpdate: "on-change" }],
+    [Transform, { rotation: lookAt([-4, 10, 3], [0, 0, 0]) }]
+  );
+  spawn([
+    Floor,
+    {
+      points: [
+        [-10, -8],
+        [10, -8],
+        [10, 8],
+        [-10, 8]
+      ],
+      material: mat([0.22, 0.21, 0.2, 1])
+    }
+  ]);
+  const stone = mat([0.7, 0.68, 0.64, 1]);
+  const walls = [
+    [
+      [-10, -8],
+      [10, -8]
+    ],
+    [
+      [10, -8],
+      [10, 8]
+    ],
+    [
+      [-10, 8],
+      [-10, -8]
+    ],
+    [
+      [-3, -8],
+      [-3, 2]
+    ]
+  ];
+  const wallEntities = walls.map(
+    ([a, b]) => spawn([Wall, { a: [...a], b: [...b], height: 2.5, thickness: 0.25, material: stone }])
+  );
+  spawn([Opening, { wall: wallEntities[3], kind: "door", offset: 5, width: 1.2, state: "open" }]);
+  spawn([
+    Opening,
+    { wall: wallEntities[1], kind: "window", offset: 6, width: 2, sill: 1, height: 1 }
+  ]);
+  const data = TilemapData.create(9, PARITY_TILES.rows.length, ["floor"], []);
+  PARITY_TILES.rows.forEach((row, y) => {
+    row.split(" ").forEach((name, x) => {
+      data.layers[0].set(x, y, data.tileId(name));
+    });
+  });
+  const ground = tilemapOnGround();
+  spawn(
+    [
+      Tilemap,
+      {
+        atlas: tileAtlas(world),
+        data: world.resource(TilemapDatas).add(data),
+        lit: "3d"
+      }
+    ],
+    [GroundLayer, { band: 10 }],
+    [
+      Transform,
+      {
+        translation: [PARITY_TILES.origin[0], 0, PARITY_TILES.origin[1]],
+        rotation: ground.rotation
+      }
+    ]
+  );
+  spawn(
+    [
+      PointLight,
+      {
+        color: [1, 0.8, 0.55, 1],
+        intensity: 6e5,
+        range: 3.5,
+        bright: 1.5,
+        falloff: "tabletop"
+      }
+    ],
+    [Transform, { translation: [5.5, 1.2, -7] }]
+  );
+  spawn(
+    [Grid, { size: 1.5, color: [1, 1, 1, 1], opacity: 0.35, lineWidth: 1, extent: [20, 16] }],
+    Transform
+  );
+  spawn(
+    [
+      VectorShape,
+      {
+        geometry: {
+          kind: "polygon",
+          outer: [
+            [0, 0],
+            [4, 0],
+            [5, 3],
+            [1, 4]
+          ]
+        },
+        fill: [0.1, 0.3, 1, 1],
+        fillOpacity: 0.7,
+        stroke: [0.1, 0.3, 1, 1],
+        strokeWidth: 2,
+        strokeUnits: "css-px"
+      }
+    ],
+    [Transform, { translation: [2, 0, -6] }]
+  );
+  const pen = [];
+  for (let i = 0; i <= 40; i++) pen.push([i * 0.25, Math.sin(i * 0.4) * 1.2]);
+  spawn(
+    [
+      VectorShape,
+      {
+        geometry: { kind: "pen", points: pen },
+        stroke: [1, 0.15, 0.1, 1],
+        strokeWidth: 3,
+        strokeUnits: "css-px"
+      }
+    ],
+    [Transform, { translation: [-1, 0, 3] }]
+  );
+  spawn(
+    [
+      VectorShape,
+      {
+        geometry: { kind: "ellipse", rx: 2, ry: 1.2 },
+        stroke: [1, 0.9, 0.1, 1],
+        strokeWidth: 0.12
+      }
+    ],
+    [Transform, { translation: [6, 0, 3] }]
+  );
+  const disc = meshes.add(cylinder({ radius: 0.5, height: 0.02 }));
+  const standee = meshes.add(box({ x: 0.15, y: 1.6, z: 0.9 }));
+  const tokenMat = mat([0.9, 0.35, 0.1, 1], 0.5);
+  const tokens = [];
+  for (const [x, z] of [
+    [3.5, -4.5],
+    [-1.5, 3],
+    [6, 2],
+    [-6, -2]
+  ]) {
+    const root = spawn([Transform, { translation: [x, 0, z] }]);
+    spawn(
+      [Mesh3d, { mesh: disc }],
+      [MeshMaterial, { material: tokenMat }],
+      [RenderLayers, { mask: PARITY_LAYERS.map }],
+      [GroundLayer, { band: 40 }],
+      NotShadowCaster,
+      Transform,
+      [ChildOf, { parent: root }]
+    );
+    spawn(
+      [Mesh3d, { mesh: standee }],
+      [MeshMaterial, { material: tokenMat }],
+      [RenderLayers, { mask: PARITY_LAYERS.tabletop }],
+      [Transform, { translation: [0, 0.8, 0] }],
+      [ChildOf, { parent: root }]
+    );
+    tokens.push(root);
+  }
+  const fog = world.resource(FogRegionsStore).add({
+    rev: 1,
+    regions: [
+      {
+        op: "hide",
+        strength: 0.75,
+        feather: 0.3,
+        shape: {
+          kind: "polygon",
+          outer: [
+            [5.5, -3],
+            [9.5, -3],
+            [9.5, 3],
+            [5.5, 3]
+          ],
+          holes: [
+            [
+              [6.5, -1],
+              [8.5, -1],
+              [8.5, 1],
+              [6.5, 1]
+            ]
+          ]
+        }
+      },
+      {
+        op: "hide",
+        strength: 0.75,
+        feather: 0.3,
+        shape: { kind: "rect", x: 7.5, y: 5.5, w: 2.2, h: 2 }
+      },
+      // Over the tiles' west end.
+      {
+        op: "hide",
+        strength: 0.75,
+        feather: 0.3,
+        shape: { kind: "rect", x: -2, y: -8, w: 2, h: 1.8 }
+      }
+    ]
+  });
+  spawn([
+    FogLayer,
+    { base: "revealed", extent: { min: [-10, -8], max: [10, 8] }, texelSize: 0.05, regions: fog }
+  ]);
+  const propMat = mat([0.3, 0.5, 0.35, 1]);
+  for (const [x, z, s] of [
+    [-7, -5, 1],
+    [-6, 5, 0.8],
+    [8.5, 6.5, 1.2]
+  ])
+    spawn(
+      [Mesh3d, { mesh: meshes.add(box({ x: s, y: s, z: s })) }],
+      [MeshMaterial, { material: propMat }],
+      [Transform, { translation: [x, s / 2, z] }]
+    );
+  spawn(
+    [Mesh3d, { mesh: meshes.add(cylinder({ radius: 0.3, height: 2.5 })) }],
+    [MeshMaterial, { material: propMat }],
+    [Transform, { translation: [1, 1.25, -6.6] }]
+  );
+  const camera = (layers, orthographic) => spawn(
+    [
+      Camera3d,
+      {
+        ...options.target ? { target: options.target } : {},
+        fovY: 45,
+        layers,
+        active: false,
+        clearColor: [0.02, 0.02, 0.03, 1],
+        ...orthographic ? { projection: "orthographic", orthoHeight: 18, far: 200 } : {}
+      }
+    ],
+    [Exposure, { ev100: 12.5 }],
+    [Tonemapping, { dither: false }],
+    Transform
+  );
+  const map = camera(PARITY_LAYERS.shared | PARITY_LAYERS.map, true);
+  const tabletop = camera(PARITY_LAYERS.shared | PARITY_LAYERS.tabletop, false);
+  return { map, tabletop, tokens };
+}
+function showParityView(world, scene, view) {
+  world.set(scene.map, Camera3d, { active: view === "map" });
+  world.set(scene.tabletop, Camera3d, { active: view === "tabletop" });
+}
+function poseParityCamera(world, scene, view, angle) {
+  const cam = view === "map" ? scene.map : scene.tabletop;
+  const distance = view === "map" ? 30 : 22;
+  const pitch = angle === "top" ? 89.99 : angle;
+  const a = pitch * Math.PI / 180;
+  const eye = [0, Math.sin(a) * distance, Math.cos(a) * distance];
+  world.set(cam, Transform, { translation: eye, rotation: lookAt(eye, [0, 0, 0]) });
+}
+export {
+  PARITY_LAYERS,
+  PARITY_TILES,
+  parityPlugins,
+  poseParityCamera,
+  showParityView,
+  spawnParity
+};

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@aethervtt/shard-scenes",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.1.0",
+    "@aethervtt/shard-fog": "0.1.0",
+    "@aethervtt/shard-grid": "0.1.0",
+    "@aethervtt/shard-mesh": "0.1.0",
+    "@aethervtt/shard-render": "0.1.0",
+    "@aethervtt/shard-runtime": "0.1.0",
+    "@aethervtt/shard-sprite": "0.1.0",
+    "@aethervtt/shard-structure": "0.1.0",
+    "@aethervtt/shard-texture": "0.1.0",
+    "@aethervtt/shard-transform": "0.1.0",
+    "@aethervtt/shard-vector": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/scenes"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+  }
+}