@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-PRRB5TTA.js

@@ -0,0 +1,406 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/world/index.ts
+var world_exports = {};
+__export(world_exports, {
+  LODManager: () => LODManager,
+  OcclusionCulling: () => OcclusionCulling,
+  WorldStreamer: () => WorldStreamer
+});
+
+// src/world/LODManager.ts
+var DEFAULT_LOD_LEVELS = [
+  { level: 0, maxDistance: 50, meshDetail: 1 },
+  { level: 1, maxDistance: 150, meshDetail: 0.5 },
+  { level: 2, maxDistance: 400, meshDetail: 0.25 },
+  { level: 3, maxDistance: Infinity, meshDetail: 0.1 }
+];
+var DEFAULT_LOD_CONFIG = {
+  defaultLevels: DEFAULT_LOD_LEVELS,
+  hysteresis: 5,
+  transitionSpeed: 5,
+  maxObjects: 1e4
+};
+var LODManager = class {
+  config;
+  objects = /* @__PURE__ */ new Map();
+  viewerPosition = { x: 0, y: 0, z: 0 };
+  constructor(config) {
+    this.config = { ...DEFAULT_LOD_CONFIG, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Object Management
+  // ---------------------------------------------------------------------------
+  register(id, position, levels, bias = 1) {
+    const obj = {
+      id,
+      position: { ...position },
+      currentLevel: 0,
+      levels: levels ?? [...this.config.defaultLevels],
+      bias,
+      visible: true,
+      transitionAlpha: 1
+    };
+    this.objects.set(id, obj);
+    return obj;
+  }
+  unregister(id) {
+    return this.objects.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  setViewerPosition(x, y, z) {
+    this.viewerPosition = { x, y, z };
+  }
+  update(dt) {
+    for (const obj of this.objects.values()) {
+      const dx = obj.position[0] - this.viewerPosition[0];
+      const dy = obj.position[1] - this.viewerPosition[1];
+      const dz = obj.position[2] - this.viewerPosition[2];
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz) * obj.bias;
+      let targetLevel = obj.levels.length - 1;
+      for (let i = 0; i < obj.levels.length; i++) {
+        const threshold = obj.levels[i].maxDistance;
+        const hysteresisAdjust = i > obj.currentLevel ? this.config.hysteresis : -this.config.hysteresis;
+        if (dist < threshold + hysteresisAdjust) {
+          targetLevel = i;
+          break;
+        }
+      }
+      if (targetLevel !== obj.currentLevel) {
+        obj.currentLevel = targetLevel;
+        obj.transitionAlpha = 0;
+      }
+      if (obj.transitionAlpha < 1) {
+        obj.transitionAlpha = Math.min(1, obj.transitionAlpha + dt * this.config.transitionSpeed);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getObject(id) {
+    return this.objects.get(id);
+  }
+  getObjectCount() {
+    return this.objects.size;
+  }
+  getLevelDistribution() {
+    const dist = /* @__PURE__ */ new Map();
+    for (const obj of this.objects.values()) {
+      dist.set(obj.currentLevel, (dist.get(obj.currentLevel) ?? 0) + 1);
+    }
+    return dist;
+  }
+  getObjectsAtLevel(level) {
+    return [...this.objects.values()].filter((o) => o.currentLevel === level);
+  }
+  getAverageLOD() {
+    if (this.objects.size === 0) return 0;
+    let sum = 0;
+    for (const obj of this.objects.values()) sum += obj.currentLevel;
+    return sum / this.objects.size;
+  }
+};
+
+// src/world/OcclusionCulling.ts
+var OcclusionCulling = class {
+  objects = /* @__PURE__ */ new Map();
+  zones = /* @__PURE__ */ new Map();
+  portals = /* @__PURE__ */ new Map();
+  frustumPlanes = [];
+  currentFrame = 0;
+  visibleCount = 0;
+  culledCount = 0;
+  layerMask = 4294967295;
+  // ---------------------------------------------------------------------------
+  // Object Management
+  // ---------------------------------------------------------------------------
+  register(id, bounds, layer = 0) {
+    const obj = {
+      id,
+      bounds,
+      visible: true,
+      lastTestFrame: 0,
+      layer
+    };
+    this.objects.set(id, obj);
+    return obj;
+  }
+  unregister(id) {
+    return this.objects.delete(id);
+  }
+  updateBounds(id, bounds) {
+    const obj = this.objects.get(id);
+    if (obj) obj.bounds = bounds;
+  }
+  // ---------------------------------------------------------------------------
+  // Zones & Portals
+  // ---------------------------------------------------------------------------
+  addZone(id, bounds, objectIds = []) {
+    this.zones.set(id, { id, bounds, objects: objectIds });
+  }
+  addPortal(id, bounds, zone1, zone2) {
+    this.portals.set(id, { id, bounds, connectedZones: [zone1, zone2], open: true });
+  }
+  setPortalOpen(id, open) {
+    const portal = this.portals.get(id);
+    if (portal) portal.open = open;
+  }
+  // ---------------------------------------------------------------------------
+  // Frustum Setup
+  // ---------------------------------------------------------------------------
+  setFrustum(planes) {
+    this.frustumPlanes = planes;
+  }
+  setLayerMask(mask) {
+    this.layerMask = mask;
+  }
+  // ---------------------------------------------------------------------------
+  // Culling
+  // ---------------------------------------------------------------------------
+  performCulling() {
+    this.currentFrame++;
+    this.visibleCount = 0;
+    this.culledCount = 0;
+    for (const obj of this.objects.values()) {
+      if ((this.layerMask & 1 << obj.layer) === 0) {
+        obj.visible = false;
+        this.culledCount++;
+        continue;
+      }
+      obj.visible = this.isInFrustum(obj.bounds);
+      obj.lastTestFrame = this.currentFrame;
+      if (obj.visible) {
+        this.visibleCount++;
+      } else {
+        this.culledCount++;
+      }
+    }
+  }
+  isInFrustum(bounds) {
+    if (this.frustumPlanes.length === 0) return true;
+    for (const plane of this.frustumPlanes) {
+      const px = plane.normal.x >= 0 ? bounds.max.x : bounds.min.x;
+      const py = plane.normal.y >= 0 ? bounds.max.y : bounds.min.y;
+      const pz = plane.normal.z >= 0 ? bounds.max.z : bounds.min.z;
+      const dot = plane.normal.x * px + plane.normal.y * py + plane.normal.z * pz + plane.distance;
+      if (dot < 0) return false;
+    }
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // AABB Intersection
+  // ---------------------------------------------------------------------------
+  testAABBOverlap(a, b) {
+    return a.min.x <= b.max.x && a.max.x >= b.min.x && a.min.y <= b.max.y && a.max.y >= b.min.y && a.min.z <= b.max.z && a.max.z >= b.min.z;
+  }
+  queryRegion(region) {
+    const result = [];
+    for (const obj of this.objects.values()) {
+      if (this.testAABBOverlap(obj.bounds, region)) {
+        result.push(obj);
+      }
+    }
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Portal Visibility
+  // ---------------------------------------------------------------------------
+  getVisibleZones(startZone) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startZone];
+    visited.add(startZone);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const portal of this.portals.values()) {
+        if (!portal.open) continue;
+        const [z1, z2] = portal.connectedZones;
+        if (z1 === current && !visited.has(z2)) {
+          visited.add(z2);
+          queue.push(z2);
+        } else if (z2 === current && !visited.has(z1)) {
+          visited.add(z1);
+          queue.push(z1);
+        }
+      }
+    }
+    return [...visited];
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getVisibleObjects() {
+    return [...this.objects.values()].filter((o) => o.visible);
+  }
+  getVisibleCount() {
+    return this.visibleCount;
+  }
+  getCulledCount() {
+    return this.culledCount;
+  }
+  getTotalCount() {
+    return this.objects.size;
+  }
+  getCullRatio() {
+    return this.objects.size > 0 ? this.culledCount / this.objects.size : 0;
+  }
+  getCurrentFrame() {
+    return this.currentFrame;
+  }
+};
+
+// src/world/WorldStreamer.ts
+var DEFAULT_STREAMING = {
+  chunkSize: 64,
+  loadRadius: 3,
+  unloadRadius: 5,
+  maxConcurrentLoads: 4,
+  memoryBudget: 256 * 1024 * 1024
+  // 256MB
+};
+var WorldStreamer = class {
+  config;
+  chunks = /* @__PURE__ */ new Map();
+  viewerPosition = { x: 0, z: 0 };
+  totalMemory = 0;
+  loadQueue = [];
+  activeLoads = 0;
+  chunkGenerator = null;
+  constructor(config) {
+    this.config = { ...DEFAULT_STREAMING, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Chunk Generator
+  // ---------------------------------------------------------------------------
+  setChunkGenerator(gen) {
+    this.chunkGenerator = gen;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  setViewerPosition(x, z) {
+    this.viewerPosition = { x, z };
+  }
+  update() {
+    const cx = Math.floor(this.viewerPosition.x / this.config.chunkSize);
+    const cz = Math.floor(this.viewerPosition.z / this.config.chunkSize);
+    for (let dx = -this.config.loadRadius; dx <= this.config.loadRadius; dx++) {
+      for (let dz = -this.config.loadRadius; dz <= this.config.loadRadius; dz++) {
+        const chunkX = cx + dx;
+        const chunkZ = cz + dz;
+        const id = `${chunkX},${chunkZ}`;
+        if (!this.chunks.has(id)) {
+          const dist = Math.sqrt(dx * dx + dz * dz);
+          if (dist <= this.config.loadRadius) {
+            this.requestLoad(chunkX, chunkZ, this.config.loadRadius - dist);
+          }
+        }
+      }
+    }
+    this.processLoadQueue();
+    for (const [id, chunk] of this.chunks) {
+      if (chunk.state !== "loaded") continue;
+      const dx = chunk.x - cx;
+      const dz = chunk.z - cz;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+      if (dist > this.config.unloadRadius) {
+        this.unloadChunk(id);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Loading / Unloading
+  // ---------------------------------------------------------------------------
+  requestLoad(x, z, priority) {
+    const id = `${x},${z}`;
+    if (this.chunks.has(id)) return;
+    const chunk = {
+      id,
+      x,
+      z,
+      state: "loading",
+      data: null,
+      priority,
+      lastAccessTime: Date.now(),
+      size: 0
+    };
+    this.chunks.set(id, chunk);
+    this.loadQueue.push(id);
+    this.loadQueue.sort((a, b) => {
+      const ca = this.chunks.get(a), cb = this.chunks.get(b);
+      return cb.priority - ca.priority;
+    });
+  }
+  processLoadQueue() {
+    while (this.loadQueue.length > 0 && this.activeLoads < this.config.maxConcurrentLoads) {
+      const id = this.loadQueue.shift();
+      const chunk = this.chunks.get(id);
+      if (!chunk || chunk.state !== "loading") continue;
+      this.activeLoads++;
+      if (this.chunkGenerator) {
+        chunk.data = this.chunkGenerator(chunk.x, chunk.z);
+        const serialized = JSON.stringify(chunk.data);
+        chunk.size = serialized.length;
+        this.totalMemory += chunk.size;
+      } else {
+        chunk.data = { x: chunk.x, z: chunk.z };
+        chunk.size = 64;
+        this.totalMemory += 64;
+      }
+      chunk.state = "loaded";
+      chunk.lastAccessTime = Date.now();
+      this.activeLoads--;
+    }
+  }
+  unloadChunk(id) {
+    const chunk = this.chunks.get(id);
+    if (!chunk) return;
+    this.totalMemory -= chunk.size;
+    this.chunks.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Manual Load
+  // ---------------------------------------------------------------------------
+  loadChunk(x, z) {
+    const id = `${x},${z}`;
+    const existing = this.chunks.get(id);
+    if (existing) return existing;
+    this.requestLoad(x, z, 999);
+    this.processLoadQueue();
+    return this.chunks.get(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getChunk(x, z) {
+    return this.chunks.get(`${x},${z}`);
+  }
+  getLoadedChunks() {
+    return [...this.chunks.values()].filter((c) => c.state === "loaded");
+  }
+  getLoadedCount() {
+    let count = 0;
+    for (const c of this.chunks.values()) if (c.state === "loaded") count++;
+    return count;
+  }
+  getTotalMemory() {
+    return this.totalMemory;
+  }
+  isOverBudget() {
+    return this.totalMemory > this.config.memoryBudget;
+  }
+  getChunkSize() {
+    return this.config.chunkSize;
+  }
+};
+
+export {
+  LODManager,
+  OcclusionCulling,
+  WorldStreamer,
+  world_exports
+};