@realsee/dnalogel 3.81.11 → 3.81.12

package/libs/FireScenePlugin/smoke/managers/NormalSmokeManager.js

@@ -0,0 +1,136 @@
+var p = Object.defineProperty;
+var d = (c, e, t) => e in c ? p(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var n = (c, e, t) => (d(c, typeof e != "symbol" ? e + "" : e, t), t);
+import * as i from "three";
+import { Xe as h } from "../../../vendor/@realsee/five/vfx/index.js";
+import { disposeParticle as m } from "../../utils/particle.js";
+import { FADE_STEP_MS as l } from "../../constants.js";
+class v {
+  constructor(e, t, r) {
+    n(this, "scene");
+    n(this, "config");
+    n(this, "sources", /* @__PURE__ */ new Map());
+    n(this, "particleTexture");
+    n(this, "unsubscribeTexture");
+    this.scene = e, this.config = t, this.particleTexture = r, this.unsubscribeTexture = r.onChange((o) => {
+      this.sources.forEach((s) => {
+        s.particle.texture = o;
+      });
+    });
+  }
+  /**
+   * 添加烟雾源
+   */
+  addSource(e, t, r, o = 0) {
+    const s = this.createNormalSmoke(t, e, r), a = { id: e, particle: s };
+    this.sources.set(e, a), o > 0 && this.fadeInSource(a, r, o);
+  }
+  /** 渐显：在 durationMs 内把浓度从 0 涨到目标值 */
+  fadeInSource(e, t, r) {
+    const o = Math.max(1, Math.round(r / l));
+    let s = 0;
+    this.updateSourceIntensity(e.id, 0), e.fadeInTimer = setInterval(() => {
+      if (s += 1, s >= o) {
+        clearInterval(e.fadeInTimer), e.fadeInTimer = void 0, this.updateSourceIntensity(e.id, t);
+        return;
+      }
+      this.updateSourceIntensity(e.id, t * (s / o));
+    }, l);
+  }
+  /**
+   * 平移某个烟雾源的粒子
+   */
+  moveSource(e, t) {
+    var r;
+    (r = this.sources.get(e)) == null || r.particle.position.add(t);
+  }
+  /**
+   * 更新烟雾源强度
+   */
+  updateSourceIntensity(e, t) {
+    const r = this.sources.get(e);
+    r && this.updateNormalSmokeParams(r.particle, t);
+  }
+  /**
+   * 移除烟雾源
+   */
+  removeSource(e) {
+    const t = this.sources.get(e);
+    t && (t.fadeInTimer && clearInterval(t.fadeInTimer), m(t.particle), this.sources.delete(e));
+  }
+  /**
+   * 创建普通烟雾粒子
+   */
+  createNormalSmoke(e, t, r) {
+    const o = r * this.config.densityMultiplier, s = e.clone();
+    s.y += 0.3 + this.config.heightOffset * r;
+    const a = new h({
+      positionBase: new i.Vector3(0, 0.05, 0),
+      // 减少基础高度偏移，让烟雾更贴近火焰
+      positionCubeSpread: new i.Vector3(
+        0.5 * o * this.config.spreadMultiplier,
+        0.05 * o,
+        0.5 * o * this.config.spreadMultiplier
+      ),
+      velocityStyle: "CUBE",
+      velocityCubeBase: new i.Vector3(0, 0.4 * o * Math.max(Math.random(), 0.6), 0.05),
+      velocityCubeSpread: new i.Vector3(
+        0.8 * o * this.config.spreadMultiplier,
+        0.2 * o * this.config.spreadMultiplier * Math.max(Math.random(), 0.4),
+        0.8 * o * this.config.spreadMultiplier
+      ),
+      accelerationBase: new i.Vector3(0, 0.1, 0.02),
+      // 恢复向上加速度，让烟雾向上升腾
+      texture: this.particleTexture.current,
+      blending: i.NormalBlending,
+      // 使用正常混合模式，避免颜色异常
+      angleBase: 0,
+      angleSpread: 720 / 180 * Math.PI,
+      angleVelocityBase: 0,
+      angleVelocitySpread: 360 / 180 * Math.PI,
+      sizeTween: {
+        times: [0, 1, 2, 3, 4, 6],
+        // 尺寸随浓度等比缩放
+        values: [0.4, 1, 1.6, 2, 1.6, 0.8].map((u) => u * r)
+      },
+      opacityTween: {
+        times: [0, 1, 2, 3, 4, 6],
+        // 峰值透明度 0.45
+        values: [0.15, 0.3, 0.45, 0.3, 0.15, 0]
+      },
+      colorTween: {
+        // 黑色浓烟
+        times: [0.3, 1.5],
+        values: [new i.Vector3(0.2, 0.2, 0.2), new i.Vector3(0.05, 0.05, 0.05)]
+      },
+      // 速率与浓度等比，基准 30/秒（创建与更新同一基准）
+      particlesPerSecond: 30 * r,
+      particleDeathAge: 6
+    });
+    return a.name = t, a.position.copy(s), this.scene.add(a), a;
+  }
+  /**
+   * 更新普通烟雾参数
+   */
+  updateNormalSmokeParams(e, t) {
+    const r = t * this.config.densityMultiplier;
+    e.particlesPerSecond = Math.floor(30 * t), e.velocityCubeBase.y = Math.min(2, 0.6 * r);
+    const o = Math.min(3, r * this.config.spreadMultiplier);
+    e.velocityCubeSpread.x = 0.8 * o, e.velocityCubeSpread.z = 0.8 * o, e.positionCubeSpread.x = 0.3 * o, e.positionCubeSpread.z = 0.3 * o;
+  }
+  /**
+   * 清理所有烟雾
+   */
+  clearAll() {
+    Array.from(this.sources.keys()).forEach((t) => this.removeSource(t));
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clearAll(), this.unsubscribeTexture();
+  }
+}
+export {
+  v as NormalSmokeManager
+};

package/libs/FireScenePlugin/smoke/managers/SmokeManager.d.ts

@@ -0,0 +1,89 @@
+import * as THREE from 'three';
+import type { FireSpreadBounds } from '../../typing';
+import type { ParticleTexture } from '../../utils/particleTexture';
+/**
+ * 烟雾配置接口
+ */
+export interface SmokeConfig {
+    /** 密度倍数 */
+    densityMultiplier: number;
+    /** 高度偏移 */
+    heightOffset: number;
+    /** 扩散倍数 */
+    spreadMultiplier: number;
+}
+/**
+ * 烟雾扩散参数
+ */
+export interface SmokeSpreadOptions {
+    /** 扩散边界（世界坐标）：`[minX, minY, minZ, maxX, maxY, maxZ]` */
+    bounds: FireSpreadBounds;
+    /** 扩散半径上限 */
+    spreadRange: number;
+    /** 每次步进的强度增长，决定半径推进的快慢 */
+    growthRate: number;
+    /** 步进间隔（毫秒） */
+    interval: number;
+    /** 扩散源数量上限（不含主源） */
+    maxAdditional: number;
+    /** 扩散源的浓度 */
+    intensity: number;
+    /** 扩散源的渐显时长（毫秒） */
+    fadeInMs?: number;
+    /** 网格边长（米），不传按 1 米 */
+    cell?: number;
+}
+/**
+ * 烟雾管理器
+ *
+ * 维护「有哪些烟源」的记录，具体粒子交给 {@link NormalSmokeManager}。
+ */
+export declare class SmokeManager {
+    private sources;
+    /** 正在扩散的烟雾源，key = 主源 id */
+    private spreads;
+    private normalSmoke;
+    constructor(scene: THREE.Scene, config: SmokeConfig, particleTexture: ParticleTexture);
+    /**
+     * 添加烟雾源
+     */
+    addSource(id: string, position: THREE.Vector3, intensity?: number, fadeInMs?: number): void;
+    /**
+     * 让某个烟雾源在给定区域内扩散。
+     */
+    spreadSmoke(id: string, options: SmokeSpreadOptions): void;
+    /** 停止扩散（已经生成的扩散源保留） */
+    stopSmokeSpread(id: string): void;
+    /** 扩散产生的烟雾源 id */
+    getSpreadSourceIds(id: string): string[];
+    /** 走一步扩散：在区域内新铺开若干个烟雾源 */
+    private stepSpread;
+    /**
+     * 平移某个烟雾源。
+     */
+    moveSource(id: string, position: THREE.Vector3): void;
+    /**
+     * 更新烟雾源强度
+     */
+    updateSourceIntensity(id: string, intensity: number): void;
+    /**
+     * 移除烟雾源
+     */
+    removeSource(id: string): void;
+    /**
+     * 清理所有烟雾
+     */
+    clearAll(): void;
+    /**
+     * 销毁管理器
+     */
+    destroy(): void;
+    /**
+     * 获取某个烟雾源的当前浓度
+     */
+    getSourceIntensity(id: string): number;
+    /**
+     * 获取烟雾源数量
+     */
+    getSourceCount(): number;
+}

package/libs/FireScenePlugin/smoke/managers/SmokeManager.js

@@ -0,0 +1,137 @@
+var l = Object.defineProperty;
+var m = (c, e, s) => e in c ? l(c, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : c[e] = s;
+var d = (c, e, s) => (m(c, typeof e != "symbol" ? e + "" : e, s), s);
+import * as u from "three";
+import { RadialSpread as p } from "../../utils/radialSpread.js";
+import { SPREAD_COVERAGE_TARGET as S } from "../../constants.js";
+import { NormalSmokeManager as g } from "./NormalSmokeManager.js";
+import "../../../vendor/@realsee/five/vfx/index.js";
+import "../../utils/particle.js";
+class A {
+  constructor(e, s, r) {
+    d(this, "sources", /* @__PURE__ */ new Map());
+    /** 正在扩散的烟雾源，key = 主源 id */
+    d(this, "spreads", /* @__PURE__ */ new Map());
+    d(this, "normalSmoke");
+    this.normalSmoke = new g(e, s, r);
+  }
+  /**
+   * 添加烟雾源
+   */
+  addSource(e, s, r = 1, t = 0) {
+    const o = { id: e, position: s, intensity: r };
+    this.sources.set(e, o), this.normalSmoke.addSource(e, s, r, t);
+  }
+  /**
+   * 让某个烟雾源在给定区域内扩散。
+   */
+  spreadSmoke(e, s) {
+    var a;
+    const r = this.spreads.get(e);
+    this.stopSmokeSpread(e);
+    const t = this.sources.get(e);
+    if (!t)
+      return;
+    const o = new p({
+      bounds: s.bounds,
+      origin: t.position,
+      seed: e,
+      spreadRange: s.spreadRange,
+      growthRate: s.growthRate,
+      cell: s.cell
+    });
+    this.spreads.set(e, {
+      spread: o,
+      timer: setInterval(() => this.stepSpread(e), s.interval),
+      // 重复扩散时接着上次的编号，避免和已存在的扩散源撞 id
+      derivedIds: (a = r == null ? void 0 : r.derivedIds) != null ? a : [],
+      options: s,
+      growthLevel: 1
+    });
+  }
+  /** 停止扩散（已经生成的扩散源保留） */
+  stopSmokeSpread(e) {
+    const s = this.spreads.get(e);
+    s && clearInterval(s.timer);
+  }
+  /** 扩散产生的烟雾源 id */
+  getSpreadSourceIds(e) {
+    var s, r;
+    return (r = (s = this.spreads.get(e)) == null ? void 0 : s.derivedIds) != null ? r : [];
+  }
+  /** 走一步扩散：在区域内新铺开若干个烟雾源 */
+  stepSpread(e) {
+    var a;
+    const s = this.spreads.get(e);
+    if (!s)
+      return;
+    const { options: r } = s;
+    s.growthLevel += r.growthRate;
+    const { cells: t, coverage: o } = s.spread.step(s.growthLevel, r.maxAdditional);
+    for (const { position: n, scaleJitter: h } of t) {
+      if (s.derivedIds.length >= r.maxAdditional)
+        break;
+      const i = `${e}-spread-${s.derivedIds.length}`;
+      this.addSource(i, n, r.intensity * h, (a = r.fadeInMs) != null ? a : 0), s.derivedIds.push(i);
+    }
+    (s.derivedIds.length >= r.maxAdditional || o >= S) && this.stopSmokeSpread(e);
+  }
+  /**
+   * 平移某个烟雾源。
+   */
+  moveSource(e, s) {
+    var o;
+    const r = this.sources.get(e);
+    if (!r)
+      return;
+    const t = new u.Vector3().subVectors(s, r.position);
+    r.position.copy(s), this.normalSmoke.moveSource(e, t), (o = this.spreads.get(e)) == null || o.derivedIds.forEach((a) => {
+      const n = this.sources.get(a);
+      n && (n.position.add(t), this.normalSmoke.moveSource(a, t));
+    });
+  }
+  /**
+   * 更新烟雾源强度
+   */
+  updateSourceIntensity(e, s) {
+    const r = this.sources.get(e);
+    r && (r.intensity = s, this.normalSmoke.updateSourceIntensity(e, s));
+  }
+  /**
+   * 移除烟雾源
+   */
+  removeSource(e) {
+    if (!this.sources.get(e))
+      return;
+    const r = this.spreads.get(e);
+    r && (this.stopSmokeSpread(e), this.spreads.delete(e), r.derivedIds.forEach((t) => this.removeSource(t))), this.normalSmoke.removeSource(e), this.sources.delete(e);
+  }
+  /**
+   * 清理所有烟雾
+   */
+  clearAll() {
+    this.spreads.forEach((e) => clearInterval(e.timer)), this.spreads.clear(), this.normalSmoke.clearAll(), this.sources.clear();
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clearAll(), this.normalSmoke.destroy();
+  }
+  /**
+   * 获取某个烟雾源的当前浓度
+   */
+  getSourceIntensity(e) {
+    var s, r;
+    return (r = (s = this.sources.get(e)) == null ? void 0 : s.intensity) != null ? r : 0;
+  }
+  /**
+   * 获取烟雾源数量
+   */
+  getSourceCount() {
+    return this.sources.size;
+  }
+}
+export {
+  A as SmokeManager
+};

package/libs/FireScenePlugin/typing.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 消防演绎数据契约
+ */
+/** 模型类型 */
+export type FireModelType = 
+/** 火 */
+'fire'
+/** 烟 */
+ | 'smoke'
+/** 消防员 */
+ | 'firefighter';
+export type FireSequenceKind = 
+/** 起火过程 */
+'ignite'
+/** 灭火过程 */
+ | 'extinguish';
+export interface FireVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** 蔓延区域边界：`[minX, minY, minZ, maxX, maxY, maxZ]` */
+export type FireSpreadBounds = [number, number, number, number, number, number];
+/** 起火区域 */
+export interface FireArea {
+    id: string;
+    name: string;
+    matrix: number[];
+}
+/** 演绎中的一个模型 */
+export interface FireModel {
+    id: string;
+    name: string;
+    type: FireModelType;
+    area_id: string | null;
+    position: FireVector3;
+    rotation: FireVector3;
+    scale: number;
+}
+/** 时间轴上的一段动画 */
+export interface FireSequenceStep {
+    id: string;
+    model_id: string;
+    delay_ms: number;
+}
+/** 一个消防演绎的完整动画配置 */
+export interface FireSceneConfig {
+    /** 起火区域 */
+    areas: FireArea[];
+    models: FireModel[];
+    /** 起火过程时间轴 */
+    ignite_sequences: FireSequenceStep[];
+    /** 灭火过程时间轴 */
+    extinguish_sequences: FireSequenceStep[];
+}

package/libs/FireScenePlugin/typing.js

@@ -0,0 +1 @@
+

package/libs/FireScenePlugin/utils/areaBounds.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import type { FireArea, FireSceneConfig } from '../typing';
+/**
+ * 由起火区域的 matrix 求它的 8 个顶点。
+ */
+export declare function getAreaVertices(matrix: number[]): THREE.Vector3[];
+/**
+ * 由起火区域的 matrix 求它的轴对齐包围盒。
+ */
+export declare function getAreaBox3(matrix: number[]): THREE.Box3;
+/**
+ * 求进场时应该观察的起火区域。
+ */
+export declare function getEntryArea(config: FireSceneConfig | undefined | null): FireArea | undefined;

package/libs/FireScenePlugin/utils/areaBounds.js

@@ -0,0 +1,30 @@
+import * as n from "three";
+const m = [
+  [-0.5, -0.5, -0.5],
+  [0.5, -0.5, -0.5],
+  [0.5, -0.5, 0.5],
+  [-0.5, -0.5, 0.5],
+  [-0.5, 0.5, -0.5],
+  [0.5, 0.5, -0.5],
+  [0.5, 0.5, 0.5],
+  [-0.5, 0.5, 0.5]
+];
+function u(e) {
+  const t = new n.Matrix4().fromArray(e);
+  return m.map((r) => new n.Vector3(...r).applyMatrix4(t));
+}
+function p(e) {
+  return new n.Box3().setFromPoints(u(e));
+}
+function x(e) {
+  var i, o, s, d;
+  if (!e)
+    return;
+  const t = (i = e.ignite_sequences) == null ? void 0 : i[0], r = t && ((o = e.models) == null ? void 0 : o.find((a) => a.id === t.model_id));
+  return (r == null ? void 0 : r.area_id) && ((s = e.areas) == null ? void 0 : s.find((a) => a.id === r.area_id)) || ((d = e.areas) == null ? void 0 : d[0]);
+}
+export {
+  p as getAreaBox3,
+  u as getAreaVertices,
+  x as getEntryArea
+};

package/libs/FireScenePlugin/utils/particle.d.ts

@@ -0,0 +1,5 @@
+import type { Particle } from '@realsee/five/vfx';
+/**
+ * 释放粒子占用的显存。
+ */
+export declare const disposeParticle: (particle: Particle) => void;

package/libs/FireScenePlugin/utils/particle.js

@@ -0,0 +1,7 @@
+const s = (e) => {
+  var o;
+  (o = e.parent) == null || o.remove(e), e.geometry.dispose(), e.material.dispose();
+};
+export {
+  s as disposeParticle
+};

package/libs/FireScenePlugin/utils/particleTexture.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from 'three';
+type TextureListener = (texture: THREE.Texture | null) => void;
+/**
+ * 火焰、烟雾、喷水共用的粒子贴图。
+ */
+export declare class ParticleTexture {
+    private loader;
+    private url;
+    private texture;
+    private listeners;
+    /** 当前贴图。加载完成前为 null */
+    get current(): THREE.Texture | null;
+    setUrl(url: string): void;
+    /**
+     * 订阅贴图变化（含清空），返回取消订阅的函数。
+     */
+    onChange(listener: TextureListener): () => void;
+    dispose(): void;
+    private emit;
+}
+export {};

package/libs/FireScenePlugin/utils/particleTexture.js

@@ -0,0 +1,40 @@
+var s = Object.defineProperty;
+var h = (r, t, e) => t in r ? s(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var i = (r, t, e) => (h(r, typeof t != "symbol" ? t + "" : t, e), e);
+import { getTextureLoader as l } from "../../shared-utils/three/getTextureLoader.js";
+import "../../shared-utils/three/loadTexture.js";
+import "three";
+class d {
+  constructor() {
+    i(this, "loader", l());
+    i(this, "url", "");
+    i(this, "texture", null);
+    i(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  /** 当前贴图。加载完成前为 null */
+  get current() {
+    return this.texture;
+  }
+  setUrl(t) {
+    t !== this.url && (this.url = t, this.texture = null, this.emit(), t && this.loader.load(t).then((e) => {
+      t === this.url && (this.texture = e, this.emit());
+    }));
+  }
+  /**
+   * 订阅贴图变化（含清空），返回取消订阅的函数。
+   */
+  onChange(t) {
+    return this.listeners.add(t), () => {
+      this.listeners.delete(t);
+    };
+  }
+  dispose() {
+    this.listeners.clear(), this.texture = null, this.url = "", this.loader.dispose();
+  }
+  emit() {
+    this.listeners.forEach((t) => t(this.texture));
+  }
+}
+export {
+  d as ParticleTexture
+};

package/libs/FireScenePlugin/utils/radialSpread.d.ts

@@ -0,0 +1,54 @@
+import * as THREE from 'three';
+import type { FireSpreadBounds } from '../typing';
+export interface RadialSpreadOptions {
+    /** 区域包围盒（世界坐标）：[minX, minY, minZ, maxX, maxY, maxZ] */
+    bounds: FireSpreadBounds;
+    /** 扩散中心（世界坐标） */
+    origin: THREE.Vector3;
+    /** 噪声种子。同一个 seed 得到同一套布局，火焰用火焰 id，烟雾用烟雾源 id */
+    seed: string;
+    /** 扩散半径上限 */
+    spreadRange: number;
+    /** 增长率，影响每一步的半径推进距离 */
+    growthRate: number;
+    /** 网格边长（米），不传按 1 米 */
+    cell?: number;
+}
+export interface RadialSpreadCell {
+    /** 新铺开的位置，已做抖动，不会排成规则阵列 */
+    position: THREE.Vector3;
+    /** 尺寸抖动系数（0.9~1.1），调用方按需用在实体大小上 */
+    scaleJitter: number;
+}
+export interface RadialSpreadStepResult {
+    /** 这一步新铺开的位置 */
+    cells: RadialSpreadCell[];
+    /** 当前扩散半径 */
+    radius: number;
+    /** 当前覆盖率（0~1） */
+    coverage: number;
+}
+/**
+ * 径向扩散：以某个点为中心、按网格扫描包围盒，每一步只取当前半径环带内的格子。
+ */
+export declare class RadialSpread {
+    private readonly bounds;
+    private readonly origin;
+    private readonly seed;
+    private readonly cell;
+    private readonly spreadRange;
+    private readonly growthRate;
+    private readonly coveredCells;
+    private readonly totalCells;
+    private readonly nx;
+    private readonly nz;
+    private currentRadius;
+    private maxRing;
+    constructor(options: RadialSpreadOptions);
+    /** 当前扩散半径 */
+    get radius(): number;
+    /** 当前覆盖率（0~1） */
+    get coverage(): number;
+    step(growthLevel: number, maxNew: number): RadialSpreadStepResult;
+    private isCovered;
+}

package/libs/FireScenePlugin/utils/radialSpread.js

@@ -0,0 +1,75 @@
+var Z = Object.defineProperty;
+var $ = (n, t, e) => t in n ? Z(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var h = (n, t, e) => ($(n, typeof t != "symbol" ? t + "" : t, e), e);
+import * as j from "three";
+import { MAX_SPREAD_CELLS_PER_STEP as k } from "../constants.js";
+class D {
+  constructor(t) {
+    h(this, "bounds");
+    h(this, "origin");
+    h(this, "seed");
+    h(this, "cell");
+    h(this, "spreadRange");
+    h(this, "growthRate");
+    h(this, "coveredCells", /* @__PURE__ */ new Set());
+    h(this, "totalCells");
+    h(this, "nx");
+    h(this, "nz");
+    h(this, "currentRadius", 0);
+    h(this, "maxRing", 0);
+    var d;
+    this.bounds = t.bounds, this.origin = t.origin, this.seed = t.seed, this.spreadRange = t.spreadRange, this.growthRate = t.growthRate, this.cell = Math.max(0.08, (d = t.cell) != null ? d : 1);
+    const [e, , r, a, , g] = this.bounds;
+    this.nx = Math.max(1, Math.ceil((a - e) / this.cell)), this.nz = Math.max(1, Math.ceil((g - r) / this.cell)), this.totalCells = this.nx * this.nz;
+  }
+  /** 当前扩散半径 */
+  get radius() {
+    return this.currentRadius;
+  }
+  /** 当前覆盖率（0~1） */
+  get coverage() {
+    return Math.min(1, this.coveredCells.size / Math.max(1, this.totalCells));
+  }
+  step(t, e) {
+    const [r, , a, g, , d] = this.bounds, o = this.origin, b = Math.max(this.cell * 0.35, this.spreadRange / 28 * Math.max(0.2, this.growthRate));
+    this.currentRadius = Math.min(this.spreadRange, this.currentRadius + b);
+    const z = (o.x - r) / this.cell - 0.5, p = (o.z - a) / this.cell - 0.5, m = Math.max(0, Math.floor(this.currentRadius / this.cell)), u = Math.max(1, Math.min(k, e)), c = [];
+    for (let s = 0; s < this.nx; s++) {
+      for (let i = 0; i < this.nz && !(c.length >= u); i++) {
+        const x = r + s * this.cell + this.cell / 2, M = a + i * this.cell + this.cell / 2, R = `${s}_${i}`;
+        if (this.coveredCells.has(R))
+          continue;
+        const C = Math.max(Math.abs(s - Math.round(z)), Math.abs(i - Math.round(p)));
+        if (C > m || C < this.maxRing)
+          continue;
+        const w = Math.atan2(M - o.z, x - o.x), E = t * 0.3, f = 0.75 + 0.2 * Math.sin(w * 3 + E), S = l(s, i, this.seed), _ = this.isCovered(s - 1, i) || this.isCovered(s + 1, i) || this.isCovered(s, i - 1) || this.isCovered(s, i + 1) ? f : Math.max(0.55, f - 0.15);
+        if (S > _)
+          continue;
+        const v = this.cell * 0.35, X = (l(s + 13, i + 7, this.seed) - 0.5) * 2 * v, y = (l(s + 29, i + 3, this.seed) - 0.5) * 2 * v;
+        c.push({
+          position: new j.Vector3(x + X, o.y, M + y),
+          scaleJitter: 0.9 + 0.2 * l(s + 5, i + 11, this.seed)
+        }), this.coveredCells.add(R);
+      }
+      if (c.length >= u)
+        break;
+    }
+    return c.length < u * 0.25 && (this.maxRing = Math.min(m, this.maxRing + 1)), { cells: c, radius: this.currentRadius, coverage: this.coverage };
+  }
+  isCovered(t, e) {
+    return this.coveredCells.has(`${t}_${e}`);
+  }
+}
+function l(n, t, e) {
+  const r = A(e), a = Math.sin(n * 12.9898 + t * 78.233 + r * 1e-4) * 43758.5453;
+  return a - Math.floor(a);
+}
+function A(n) {
+  let t = 2166136261;
+  for (let e = 0; e < n.length; e++)
+    t ^= n.charCodeAt(e), t = Math.imul(t, 16777619);
+  return t >>> 0;
+}
+export {
+  D as RadialSpread
+};