evomeme 0.1.9 → 0.1.10-beta.13

package/dist/stage-public/scene-runtime.js

@@ -0,0 +1,212 @@
+/** Scene loading/rendering without DOM, controls or game rules. */
+import * as THREE from "three";
+import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
+import { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
+import { rebuildContractLights } from "./sceneContractRuntime.js";
+import { applyThreeAppearance } from "./three-appearance.js";
+function applySceneCamera(camera, value) {
+  camera.position.fromArray(value.position);
+  camera.quaternion.fromArray(value.quaternion || value.quaternion_xyzw);
+  camera.fov = value.fov || value.vertical_fov_rad * 180 / Math.PI;
+  camera.near = value.near;
+  camera.far = value.far;
+  camera.aspect = value.aspect || value.aspect_ratio;
+  camera.updateProjectionMatrix();
+  camera.updateMatrixWorld(true);
+}
+async function loadCanonicalScene({ renderer, world, parent = world, assetBase, asset, contract = null, files, presentation, profile = null, appearanceEnabled = true, onProgress = () => {
+} }) {
+  if (!renderer?.isWebGLRenderer || !world?.isScene || !parent?.isObject3D) throw new Error("A Three.js WebGLRenderer, Scene, and parent scene node are required.");
+  for (let node = parent; node; node = node.parent) if (node.userData.canonical_alignment_root) throw new Error("A canonical scene cannot be nested under an aligned root node.");
+  const base = new URL(assetBase, globalThis.location?.href || import.meta.url);
+  if (!base.pathname.endsWith("/")) throw new Error("The asset directory URL must end with /.");
+  const read = async (file) => {
+    const url = new URL(file, base);
+    if (!url.href.startsWith(base.href) || /(^|\/)\.\.(\/|$)/.test(file)) throw new Error("An asset dependency is outside the package directory.");
+    const response = await fetch(url);
+    if (!response.ok) throw new Error("Failed to read asset: " + file);
+    const bytes = await response.arrayBuffer();
+    if (files?.[file]) {
+      const hash = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((v) => v.toString(16).padStart(2, "0")).join("");
+      if (hash !== files[file].sha256 || bytes.byteLength !== files[file].bytes) throw new Error("Asset version mismatch: " + file);
+    }
+    return bytes;
+  };
+  const json = async (file) => JSON.parse(new TextDecoder().decode(await read(file)));
+  const mode = contract?.files?.["runtime/bake-scene/bake.contract.json"] ? "baked" : contract ? "contract" : "standard";
+  if (presentation && (presentation.mode !== mode || presentation.three_revision !== THREE.REVISION)) throw new Error("Delivery renderer version mismatch.");
+  if (appearanceEnabled && world.userData.canonicalAppearanceOwner) throw new Error("The scene already has a canonical environment. Disable appearanceEnabled when loading props.");
+  const root = new THREE.Group();
+  root.name = `${asset.asset_id}_AlignmentRoot`;
+  root.userData.canonical_alignment_root = true;
+  root.userData.canonical_asset_id = asset.asset_id;
+  root.userData.canonical_alignment_key = asset.alignment?.revisions?.alignment_key;
+  const previous = { background: world.background, environment: world.environment, fog: world.fog, tone: renderer.toneMapping, exposure: renderer.toneMappingExposure, output: renderer.outputColorSpace, shadows: renderer.shadowMap.enabled };
+  let appearance, pipeline, baked, pmrem, environment, override, gltf, disposed = false;
+  const materials = /* @__PURE__ */ new Set(), textures = /* @__PURE__ */ new Set(), helpers = new THREE.Group(), visibility = /* @__PURE__ */ new Map(), inventory = [], ownedURLs = [];
+  if (appearanceEnabled) world.userData.canonicalAppearanceOwner = root.uuid;
+  try {
+    let render = function(camera, delta = 0) {
+      if (disposed) return;
+      appearance?.update(delta, camera);
+      camera.updateMatrixWorld(true);
+      if (pipeline && !override) {
+        baked.update(camera);
+        pipeline.render(world, camera);
+      } else renderer.render(world, camera);
+    };
+    onProgress("读取模型与显示依赖…");
+    const bytes = await read("model.glb");
+    const manager = new THREE.LoadingManager(), resources = /* @__PURE__ */ new Map();
+    const header = new DataView(bytes), binary = bytes.byteLength >= 20 && header.getUint32(0, true) === 1179937895;
+    const sourceJson = JSON.parse(new TextDecoder().decode(binary ? bytes.slice(20, 20 + header.getUint32(12, true)) : bytes));
+    for (const ref of [...sourceJson.buffers || [], ...sourceJson.images || []]) {
+      if (!ref.uri || ref.uri.startsWith("data:")) continue;
+      const file = decodeURIComponent(ref.uri);
+      if (!files?.[file]) throw new Error("External model dependency is missing from the manifest: " + file);
+      const url = URL.createObjectURL(new Blob([await read(file)]));
+      ownedURLs.push(url);
+      resources.set(new URL(ref.uri, base).href, url);
+    }
+    manager.setURLModifier((url) => resources.get(url) || url);
+    gltf = await new GLTFLoader(manager).parseAsync(bytes, base.href);
+    root.add(gltf.scene);
+    parent.add(root);
+    gltf.scene.traverse((o) => {
+      if (!o.isMesh) return;
+      inventory.push({ name: o.name || "未命名对象", object: o });
+      for (const m of Array.isArray(o.material) ? o.material : [o.material]) {
+        materials.add(m);
+        for (const v of Object.values(m)) if (v?.isTexture) textures.add(v);
+      }
+    });
+    const recipe = presentation?.recipe || (asset.alignment?.recipe?.source_revision === asset.alignment?.source?.sha256 ? asset.alignment?.recipe : null);
+    if (recipe) {
+      root.position.fromArray(recipe.translation_metres);
+      root.quaternion.fromArray(recipe.rotation_quaternion_xyzw);
+      root.scale.fromArray(recipe.scale_xyz);
+    } else if (asset.up_axis !== "+y" || asset.forward_axis !== "-z" || asset.pivot !== "origin" || asset.yaw_offset_degrees || asset.pitch_offset_degrees || asset.roll_offset_degrees || asset.scale_hint_metres) {
+      if (asset.up_axis !== "+y") throw new Error("Confirm the asset axes first.");
+      const box = new THREE.Box3().setFromObject(root), center = box.getCenter(new THREE.Vector3());
+      if (asset.pivot !== "origin") root.position.set(-center.x, asset.pivot === "bounds_center" ? -center.y : -box.min.y, -center.z);
+      const yaw = { "+z": Math.PI, "-z": 0, "+x": Math.PI / 2, "-x": -Math.PI / 2 }[asset.forward_axis] || 0;
+      root.rotation.set(THREE.MathUtils.degToRad(asset.pitch_offset_degrees || 0), yaw + THREE.MathUtils.degToRad(asset.yaw_offset_degrees || 0), THREE.MathUtils.degToRad(asset.roll_offset_degrees || 0), "YXZ");
+      if (asset.scale_hint_metres) {
+        const h = new THREE.Box3().setFromObject(root).getSize(new THREE.Vector3()).y;
+        if (h > 0) root.scale.setScalar(asset.scale_hint_metres / h);
+        if (asset.pivot === "ground_center") root.position.y -= new THREE.Box3().setFromObject(root).min.y;
+      }
+    }
+    root.updateMatrixWorld(true);
+    const bounds = new THREE.Box3().setFromObject(root, true), size = bounds.getSize(new THREE.Vector3());
+    if (appearanceEnabled) {
+      world.userData.canonicalAppearanceOwner = root.uuid;
+      if (mode === "baked") {
+        const [{ createAppearance }, { annotateSourceNames }, { loadBakedScene, createBakedPipeline }] = await Promise.all([import("./baked/sceneAppearance.js"), import("./baked/bakePilot.js"), import("./baked/bakedScene.js")]);
+        const legacy = await json("runtime/three.profile.json");
+        if (legacy.three_revision !== THREE.REVISION) throw new Error("Baked renderer version mismatch.");
+        const manifest = await json("runtime/bake-scene/bake.contract.json");
+        annotateSourceNames(gltf);
+        appearance = createAppearance(world, gltf.scene, renderer, contract, legacy);
+        baked = await loadBakedScene(manifest, read, renderer);
+        root.add(baked.root);
+        world.add(baked.sky);
+        const names = new Set(manifest.groups.flatMap((g) => g.source_gltf_nodes));
+        gltf.scene.traverse((o) => {
+          if (o.isMesh) {
+            for (let p = o; p; p = p.parent) if (names.has(p.userData.canonicalSourceName)) {
+              o.visible = false;
+              break;
+            }
+          }
+        });
+        appearance.setAuthoredSky(true);
+        world.fog = null;
+        renderer.toneMapping = THREE.NoToneMapping;
+        renderer.shadowMap.enabled = false;
+        pipeline = createBakedPipeline(renderer, baked, manifest);
+      } else if (profile) appearance = applyThreeAppearance(world, gltf.scene, renderer, profile);
+      else if (contract) {
+        rebuildContractLights(helpers, contract);
+        world.add(helpers);
+        helpers.add(new THREE.HemisphereLight(13493473, 4217156, 0.8));
+        world.background = new THREE.Color("#1a2428");
+      } else {
+        world.background = new THREE.Color("#1a2428");
+        pmrem = new THREE.PMREMGenerator(renderer);
+        const room = new RoomEnvironment();
+        environment = pmrem.fromScene(room).texture;
+        room.dispose();
+        world.environment = environment;
+        const key = new THREE.DirectionalLight(16773860, 2.5);
+        key.position.set(4, 8, 5);
+        helpers.add(key, new THREE.HemisphereLight(13034991, 4936e3, 0.8));
+        world.add(helpers);
+      }
+    }
+    gltf.scene.traverse((o) => {
+      if (o.isMesh) visibility.set(o, o.visible);
+    });
+    const stats = { meshes: gltf.parser.json.meshes?.length || 0, nodes: gltf.parser.json.nodes?.length || 0, materials: gltf.parser.json.materials?.length || 0, cameras: gltf.parser.json.cameras?.length || 0, skins: gltf.parser.json.skins?.length || 0, objects: inventory.length, animations: gltf.animations.length, size: size.toArray(), bounds: { min: bounds.min.toArray(), max: bounds.max.toArray() } };
+    return {
+      root,
+      world,
+      renderer,
+      mode,
+      stats,
+      inventory,
+      animations: gltf.animations,
+      render,
+      diagnostic(kind) {
+        override?.dispose();
+        override = kind === "normal" ? new THREE.MeshNormalMaterial() : kind === "wire" ? new THREE.MeshBasicMaterial({ color: 10870473, wireframe: true }) : null;
+        world.overrideMaterial = override;
+        if (baked) {
+          baked.root.visible = !override;
+          baked.sky.visible = !override;
+          visibility.forEach((visible, o) => {
+            o.visible = override ? true : visible;
+          });
+        }
+      },
+      get diagnosticActive() {
+        return !!override;
+      },
+      dispose
+    };
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    appearance?.dispose();
+    pipeline?.dispose();
+    baked?.dispose();
+    helpers.removeFromParent();
+    root.removeFromParent();
+    root.traverse((o) => o.geometry?.dispose());
+    materials.forEach((m) => m.dispose());
+    textures.forEach((t) => t.dispose());
+    override?.dispose();
+    if (world.overrideMaterial === override) world.overrideMaterial = null;
+    environment?.dispose();
+    pmrem?.dispose();
+    ownedURLs.forEach((url) => URL.revokeObjectURL(url));
+    if (appearanceEnabled && world.userData.canonicalAppearanceOwner === root.uuid) {
+      delete world.userData.canonicalAppearanceOwner;
+      world.background = previous.background;
+      world.environment = previous.environment;
+      world.fog = previous.fog;
+      renderer.toneMapping = previous.tone;
+      renderer.toneMappingExposure = previous.exposure;
+      renderer.outputColorSpace = previous.output;
+      renderer.shadowMap.enabled = previous.shadows;
+    }
+  }
+}
+export {
+  applySceneCamera,
+  loadCanonicalScene
+};

package/dist/stage-public/sceneContractRuntime.js

@@ -0,0 +1,235 @@
+/**
+ * Three.js helpers for windworn_sanctuary.scene_contract.v1 (and compatible packs).
+ * Geometry stays at identity root; cameras/lights come from the supplement contract.
+ */
+import * as THREE from 'three';
+
+/** Blender (X right, Y forward, Z up) → glTF/three (X right, Y up, Z back). */
+export function blenderPosToGltf(v) {
+  return new THREE.Vector3(v[0], v[2], -v[1]);
+}
+
+export function blenderDirToGltf(v) {
+  return new THREE.Vector3(v.x, v.z, -v.y);
+}
+
+/**
+ * Blender lights point along local -Z. Convert Euler XYZ (Blender) to a glTF direction.
+ */
+export function blenderLightDirectionGltf(rotationXyzRad) {
+  // Blender XYZ is Rz * Ry * Rx, equivalent to Three intrinsic ZYX.
+  const euler = new THREE.Euler(rotationXyzRad[0], rotationXyzRad[1], rotationXyzRad[2], 'ZYX');
+  const dirBlender = new THREE.Vector3(0, 0, -1).applyEuler(euler);
+  return blenderDirToGltf(dirBlender).normalize();
+}
+
+export function clearGroup(group) {
+  while (group.children.length) {
+    const child = group.children[group.children.length - 1];
+    group.remove(child);
+    child.traverse?.((obj) => {
+      obj.geometry?.dispose?.();
+      const mats = Array.isArray(obj.material) ? obj.material : [obj.material];
+      for (const mat of mats) mat?.dispose?.();
+    });
+  }
+}
+
+/**
+ * Rebuild contract lights under `lightRoot`. Returns { sun, fill }.
+ */
+export function rebuildContractLights(lightRoot, contract) {
+  clearGroup(lightRoot);
+  const entries = contract.blender_lights || [];
+  let sun = null;
+  let fill = null;
+
+  for (const entry of entries) {
+    const color = new THREE.Color().fromArray(entry.color_linear || [1, 1, 1]);
+    if (entry.type === 'SUN') {
+      // Blender sun energy ~4.5 is harsh under three.js ACES; keep softer.
+      const light = new THREE.DirectionalLight(color, Math.min((entry.energy || 1) * 0.28, 1.6));
+      const dir = blenderLightDirectionGltf(entry.rotation_xyz_rad || [0, 0, 0]);
+      light.target.position.set(0, 8, -10);
+      light.position.copy(light.target.position).addScaledVector(dir, -120);
+      lightRoot.add(light);
+      lightRoot.add(light.target);
+      sun = light;
+    } else if (entry.type === 'AREA') {
+      const light = new THREE.DirectionalLight(color, Math.min((entry.energy || 100) / 2200, 0.7));
+      const pos = blenderPosToGltf(entry.position || [0, 0, 20]);
+      light.position.copy(pos);
+      light.target.position.set(0, 4, -12);
+      lightRoot.add(light);
+      lightRoot.add(light.target);
+      fill = light;
+    }
+  }
+
+  const hemi = new THREE.HemisphereLight(0xb9cfe0, 0x7f9478, 0.42);
+  lightRoot.add(hemi);
+  const ambient = new THREE.AmbientLight(0xd7e0e6, 0.22);
+  lightRoot.add(ambient);
+  return { sun, fill, hemi, ambient };
+}
+
+export function findCamera(contract, cameraId = 'reference') {
+  const list = contract.cameras || [];
+  return list.find((c) => c.id === cameraId) || list[0] || null;
+}
+
+/**
+ * Apply a contract camera to THREE.PerspectiveCamera + OrbitControls target.
+ * Preserves vertical FOV; caller letterboxes to aspect_ratio.
+ */
+export function applyContractCamera(camera, controls, camDef) {
+  if (!camDef) return;
+  camera.fov = camDef.vertical_fov_degrees;
+  camera.near = camDef.near || 0.1;
+  camera.far = camDef.far || 500;
+  camera.aspect = camDef.aspect_ratio || 1.88;
+  camera.position.fromArray(camDef.position);
+  const q = camDef.quaternion_xyzw;
+  if (q) {
+    camera.quaternion.set(q[0], q[1], q[2], q[3]);
+  } else if (camDef.look_at) {
+    camera.up.fromArray(camDef.up || [0, 1, 0]);
+    camera.lookAt(camDef.look_at[0], camDef.look_at[1], camDef.look_at[2]);
+  }
+  camera.updateProjectionMatrix();
+  // Keep OrbitControls target aligned, but do not call controls.update()
+  // (it would overwrite the contract quaternion).
+  if (controls && camDef.look_at) {
+    controls.target.fromArray(camDef.look_at);
+  }
+}
+
+/**
+ * Fit a DOM viewport into a parent with letterboxing for the contract aspect.
+ */
+export function letterboxElement(el, parent, aspect = 1.88) {
+  const pw = parent.clientWidth;
+  const ph = parent.clientHeight;
+  if (pw < 1 || ph < 1) return { width: pw, height: ph };
+  let width = pw;
+  let height = width / aspect;
+  if (height > ph) {
+    height = ph;
+    width = height * aspect;
+  }
+  el.style.width = `${Math.floor(width)}px`;
+  el.style.height = `${Math.floor(height)}px`;
+  return { width: Math.floor(width), height: Math.floor(height) };
+}
+
+export function makeTurquoiseSkyTexture() {
+  const size = 512;
+  const canvas = document.createElement('canvas');
+  canvas.width = size;
+  canvas.height = size;
+  const ctx = canvas.getContext('2d');
+  const grad = ctx.createLinearGradient(0, 0, 0, size);
+  // Soft turquoise / storm-bank sky, low saturation.
+  grad.addColorStop(0, '#7ea0b5');
+  grad.addColorStop(0.35, '#9bb7c6');
+  grad.addColorStop(0.62, '#b7c9d4');
+  grad.addColorStop(0.82, '#c9d5dc');
+  grad.addColorStop(1, '#d5dde2');
+  ctx.fillStyle = grad;
+  ctx.fillRect(0, 0, size, size);
+
+  const blobs = [
+    [90, 120, 95],
+    [200, 100, 110],
+    [330, 140, 100],
+    [430, 110, 80],
+    [140, 190, 70],
+    [280, 210, 90],
+    [50, 240, 60],
+    [400, 230, 75],
+  ];
+  for (const [x, y, r] of blobs) {
+    const g = ctx.createRadialGradient(x, y, r * 0.12, x, y, r);
+    g.addColorStop(0, 'rgba(248,250,252,0.5)');
+    g.addColorStop(0.4, 'rgba(220,230,236,0.22)');
+    g.addColorStop(1, 'rgba(158,183,198,0)');
+    ctx.fillStyle = g;
+    ctx.beginPath();
+    ctx.arc(x, y, r, 0, Math.PI * 2);
+    ctx.fill();
+  }
+
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+/**
+ * Soft valley haze + a few vertical light shafts (non-volumetric approximation).
+ */
+export function rebuildAtmosphere(fxRoot, contract) {
+  clearGroup(fxRoot);
+  const bounds = contract.coordinates?.bounds_gltf_metres;
+  const size = bounds?.size || [200, 60, 140];
+  const center = bounds?.center || [0, 20, -40];
+
+  // Valley fog plane (very soft).
+  const fogPlane = new THREE.Mesh(
+    new THREE.PlaneGeometry(size[0] * 1.2, size[2] * 1.2),
+    new THREE.MeshBasicMaterial({
+      color: 0xc5d4de,
+      transparent: true,
+      opacity: 0.08,
+      depthWrite: false,
+      side: THREE.DoubleSide,
+    })
+  );
+  fogPlane.rotation.x = -Math.PI / 2;
+  fogPlane.position.set(center[0], 1.2, center[2]);
+  fxRoot.add(fogPlane);
+
+  // Relic light shafts near plaza (approximate).
+  const shaftMat = new THREE.MeshBasicMaterial({
+    color: 0xe8f0f4,
+    transparent: true,
+    opacity: 0.08,
+    depthWrite: false,
+    side: THREE.DoubleSide,
+  });
+  const shaftSpots = [
+    [2, 0, -6],
+    [-4, 0, -14],
+    [10, 0, -2],
+    [-8, 0, 4],
+  ];
+  for (const [x, , z] of shaftSpots) {
+    const shaft = new THREE.Mesh(new THREE.CylinderGeometry(0.35, 1.4, 28, 8, 1, true), shaftMat);
+    shaft.position.set(x, 14, z);
+    fxRoot.add(shaft);
+  }
+
+  // Floating mote particles.
+  const count = 180;
+  const positions = new Float32Array(count * 3);
+  for (let i = 0; i < count; i++) {
+    positions[i * 3] = center[0] + (Math.random() - 0.5) * size[0] * 0.35;
+    positions[i * 3 + 1] = 2 + Math.random() * 22;
+    positions[i * 3 + 2] = center[2] + (Math.random() - 0.5) * size[2] * 0.35;
+  }
+  const geo = new THREE.BufferGeometry();
+  geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+  const points = new THREE.Points(
+    geo,
+    new THREE.PointsMaterial({
+      color: 0xf2f6f8,
+      size: 0.35,
+      transparent: true,
+      opacity: 0.45,
+      depthWrite: false,
+      sizeAttenuation: true,
+    })
+  );
+  fxRoot.add(points);
+  return { points };
+}