diamon-engine 0.1.0

package/README.md

@@ -0,0 +1,119 @@
+# Diamon
+
+Diamon 是一个以 3D 为主的 Web 游戏引擎原型。当前阶段只做 3D 引擎和编辑器本身，聚焦运行时架构、资源管理、保存加载、性能诊断和压力测试，不做任何用 Diamon 制作出来的游戏，也不保留 2D 引擎代码。
+
+## 当前能力
+
+### 3D 引擎
+
+- `Engine3D`：WebGL 渲染、主循环、窗口自适应、渲染统计、自适应画质、阴影开关和像素比例控制
+- `Scene3D`：Three.js 场景封装、透视相机、3D 实体管理、逐帧更新调度
+- `Entity3D`：位置、旋转、缩放、标签、组件挂载
+- `Component3D`：生命周期、逐帧更新、销毁清理
+- `MeshPrimitive3D`：盒子、球、圆柱、圆锥、圆环、平面、基础几何体和材质复用
+- `Light3D`：环境光、方向光、点光源
+- `Input3D`：键盘、鼠标拖动、滚轮缩放
+- `OrbitCameraController`：可拖动旋转、滚轮远近调整的 3D 相机
+
+### 引擎编辑器
+
+- 默认加载 3D 编辑器场景
+- 支持添加基础对象：立方体、球体、圆柱、圆锥、圆环
+- 支持场景树、属性面板、资源面板、预制体面板
+- 支持对象选择、复制、粘贴、删除、批量选择、分组、图层
+- 支持关键编辑操作的撤销和重做
+- 支持场景 JSON 保存、加载、下载和本地缓存
+- 支持模型、贴图、材质、音频资源导入记录，GLB/glTF 模型可导入场景
+- 支持基础预制体保存和复用
+- 显示对象数量、可见对象、Draw Calls、三角面、FPS、帧耗时、几何体、贴图、内存和慢系统提示
+- 支持 10000 实例化对象、5000 普通对象、500 万增量压力、50 亿目标和 100 亿目标压力测试
+- FPS 面板会按引擎帧耗时判断 60 FPS 目标承受能力，避免测试浏览器刷新调度把结果压低
+- 静态对象默认不进入逐帧更新队列，性能面板降频刷新，降低编辑器自身开销
+- 大型压力测试时场景树会限制一次渲染的行数，避免编辑器列表本身造成卡顿
+- 500 万、50 亿和 100 亿压力测试会合并到单一超大压力层，并使用代表点 LOD；50 亿以上目标会切换到更轻的 8000 代表点，验证引擎在极端数量下的调度、资源和渲染承受能力
+- 保留网格、世界坐标轴、环境光、方向光和编辑相机
+
+## 运行
+
+```bash
+npm install
+npm run dev
+```
+
+## 验证
+
+```bash
+npm run check
+npm run build
+npm run pack:dry
+```
+
+## 作为包给其他游戏使用
+
+Diamon 现在可以作为 `diamon-engine` 包被其他游戏引用。当前包导出三个入口：
+
+- `diamon-engine`：默认 3D 运行时入口
+- `diamon-engine/engine3d`：明确的 3D 运行时入口
+- `diamon-engine/workbench`：编辑器工作台入口
+
+本地开发中的游戏可以先用本地路径安装：
+
+```bash
+npm install ../yuyu自制引擎
+```
+
+游戏项目里直接引用：
+
+```ts
+import { Engine3D, Entity3D, MeshPrimitive3D, Scene3D } from "diamon-engine";
+```
+
+需要编辑器样式时再引入：
+
+```ts
+import "diamon-engine/styles.css";
+```
+
+发布包前先构建并做干跑检查：
+
+```bash
+npm run build
+npm run pack:dry
+```
+
+## 3D 最小用法
+
+```ts
+import { Engine3D, Entity3D, MeshPrimitive3D, Scene3D } from "diamon-engine";
+
+const engine = new Engine3D({ canvas: document.querySelector("canvas")! });
+const scene = new Scene3D("Demo");
+
+const box = new Entity3D("Box");
+box.addComponent(
+  new MeshPrimitive3D({
+    kind: "box",
+    width: 1,
+    height: 1,
+    depth: 1,
+    color: "#1ec7a6"
+  })
+);
+
+scene.add(box);
+engine.setScene(scene);
+engine.start();
+```
+
+## 目标文档
+
+- [3D 引擎性能目标](./docs/3D_ENGINE_PERFORMANCE_GOALS.md)
+
+## 下一步适合做的引擎能力
+
+1. 大量对象优化继续增强：实例化、合批、资源复用
+2. 区块加载结构和大场景流式加载
+3. 资源压缩、贴图质量档位和显存统计
+4. 更完整的 GLB/glTF 材质和动画支持
+5. 碰撞体、触发器和后续刚体物理
+6. 插件式导入器和编辑器扩展流程

package/dist/package/OrbitCameraController-COklTntj.js

@@ -0,0 +1,400 @@
+import * as i from "three";
+class a {
+  entity;
+  enabled = !0;
+  updatesEveryFrame = !0;
+  started = !1;
+  get scene() {
+    return this.entity.scene;
+  }
+  get engine() {
+    return this.scene?.engine;
+  }
+  startInternal() {
+    this.started || (this.started = !0, this.onStart());
+  }
+  updateInternal(t) {
+    this.enabled && this.updatesEveryFrame && this.onUpdate(t);
+  }
+  destroyInternal() {
+    this.started && (this.onDestroy(), this.started = !1);
+  }
+  onStart() {
+  }
+  onUpdate(t) {
+  }
+  onDestroy() {
+  }
+}
+let d = 1;
+class l {
+  constructor(t = "Entity3D") {
+    this.name = t, this.object.name = t;
+  }
+  name;
+  id = d++;
+  object = new i.Group();
+  components = [];
+  frameUpdateComponents = [];
+  scene;
+  tag = "";
+  enabled = !0;
+  destroyed = !1;
+  get position() {
+    return this.object.position;
+  }
+  get rotation() {
+    return this.object.rotation;
+  }
+  get scale() {
+    return this.object.scale;
+  }
+  addComponent(t) {
+    if (t.entity && t.entity !== this)
+      throw new Error("3D component already belongs to another entity.");
+    return t.entity = this, this.components.push(t), t.updatesEveryFrame && this.frameUpdateComponents.push(t), this.scene?.isStarted && t.startInternal(), this.scene?.refreshEntityScheduling(this), t;
+  }
+  getComponent(t) {
+    return this.components.find(
+      (e) => e instanceof t
+    );
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.scene?.markEntityDestroyed(this));
+  }
+  get needsFrameUpdate() {
+    return this.frameUpdateComponents.length > 0;
+  }
+  startInternal() {
+    for (const t of this.components)
+      t.startInternal();
+  }
+  updateInternal(t) {
+    if (!(!this.enabled || this.destroyed || this.frameUpdateComponents.length === 0))
+      for (const e of this.frameUpdateComponents)
+        e.updateInternal(t);
+  }
+  destroyInternal() {
+    for (const t of this.components)
+      t.destroyInternal();
+    this.components.length = 0, this.frameUpdateComponents.length = 0, this.object.removeFromParent(), this.scene = void 0;
+  }
+}
+class m {
+  constructor(t = "Scene3D") {
+    this.name = t, this.threeScene.name = t, this.camera.position.set(6, 5, 8), this.camera.lookAt(0, 0, 0);
+  }
+  name;
+  threeScene = new i.Scene();
+  camera = new i.PerspectiveCamera(55, 1, 0.1, 1e3);
+  entities = [];
+  frameUpdateEntities = /* @__PURE__ */ new Set();
+  destroyedEntityCount = 0;
+  engine;
+  isStarted = !1;
+  add(t) {
+    if (t.scene && t.scene !== this)
+      throw new Error(`3D entity "${t.name}" already belongs to another scene.`);
+    return t.scene = this, this.entities.push(t), this.threeScene.add(t.object), this.refreshEntityScheduling(t), this.isStarted && t.startInternal(), t;
+  }
+  remove(t) {
+    const e = this.entities.indexOf(t);
+    e >= 0 && this.entities.splice(e, 1), this.frameUpdateEntities.delete(t), t.scene === this && t.destroyInternal();
+  }
+  findByTag(t) {
+    return this.entities.filter((e) => e.tag === t && !e.destroyed);
+  }
+  get updatableEntityCount() {
+    return this.frameUpdateEntities.size;
+  }
+  refreshEntityScheduling(t) {
+    if (t.scene !== this || t.destroyed || !t.needsFrameUpdate) {
+      this.frameUpdateEntities.delete(t);
+      return;
+    }
+    this.frameUpdateEntities.add(t);
+  }
+  markEntityDestroyed(t) {
+    t.scene === this && (this.destroyedEntityCount += 1, this.frameUpdateEntities.delete(t));
+  }
+  startInternal(t) {
+    if (this.engine = t, !this.isStarted) {
+      this.isStarted = !0, this.onStart();
+      for (const e of this.entities)
+        e.startInternal();
+    }
+  }
+  updateInternal(t) {
+    this.onUpdate(t);
+    for (const e of this.frameUpdateEntities)
+      e.updateInternal(t);
+    this.destroyedEntityCount > 0 && this.removeDestroyedEntities();
+  }
+  stopInternal() {
+    this.onStop();
+    for (const t of this.entities)
+      t.destroyInternal();
+    this.entities.length = 0, this.frameUpdateEntities.clear(), this.destroyedEntityCount = 0, this.threeScene.clear(), this.isStarted = !1, this.engine = void 0;
+  }
+  onStart() {
+  }
+  onUpdate(t) {
+  }
+  onStop() {
+  }
+  removeDestroyedEntities() {
+    for (let t = this.entities.length - 1; t >= 0; t -= 1) {
+      const e = this.entities[t];
+      e.destroyed && (e.destroyInternal(), this.entities.splice(t, 1));
+    }
+    this.destroyedEntityCount = 0;
+  }
+}
+class p extends a {
+  constructor(t) {
+    super(), this.options = t;
+  }
+  options;
+  updatesEveryFrame = !1;
+  light;
+  onStart() {
+    const t = this.options.color ?? "#ffffff", e = this.options.intensity ?? 1;
+    if (this.options.kind === "ambient")
+      this.light = new i.AmbientLight(t, e);
+    else if (this.options.kind === "directional") {
+      const s = new i.DirectionalLight(t, e);
+      s.castShadow = this.options.castShadow ?? !1, s.shadow.mapSize.set(1024, 1024), s.shadow.camera.near = 0.5, s.shadow.camera.far = 40, this.light = s;
+    } else {
+      const s = new i.PointLight(t, e, 24, 1.8);
+      s.castShadow = this.options.castShadow ?? !1, this.light = s;
+    }
+    this.entity.object.add(this.light);
+  }
+  onDestroy() {
+    this.light?.removeFromParent(), this.light = void 0;
+  }
+}
+const o = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+class u extends a {
+  constructor(t) {
+    super(), this.options = t;
+  }
+  options;
+  updatesEveryFrame = !1;
+  mesh;
+  geometry;
+  material;
+  geometryCacheKey = "";
+  materialCacheKey = "";
+  onStart() {
+    this.geometry = this.acquireGeometry(), this.material = this.acquireMaterial(), this.mesh = new i.Mesh(this.geometry, this.material), this.mesh.castShadow = this.options.castShadow ?? !1, this.mesh.receiveShadow = this.options.receiveShadow ?? !1, this.entity.object.add(this.mesh);
+  }
+  onDestroy() {
+    this.mesh?.removeFromParent(), this.releaseGeometry(), this.releaseMaterial(), this.mesh = void 0, this.geometry = void 0, this.material = void 0;
+  }
+  setColor(t) {
+    if (this.options.color = t, !!this.material) {
+      if (!this.usesSharedResources()) {
+        this.material.color.set(t);
+        return;
+      }
+      this.releaseMaterial(), this.material = this.acquireMaterial(), this.mesh && (this.mesh.material = this.material);
+    }
+  }
+  getColor() {
+    return this.material ? `#${this.material.color.getHexString()}` : this.options.color ?? "#1ec7a6";
+  }
+  createGeometry() {
+    const t = this.options.segments ?? 32;
+    switch (this.options.kind) {
+      case "sphere":
+        return new i.SphereGeometry(this.options.radius ?? 0.7, t, 18);
+      case "cylinder":
+        return new i.CylinderGeometry(
+          this.options.radiusTop ?? this.options.radius ?? 0.5,
+          this.options.radiusBottom ?? this.options.radius ?? 0.5,
+          this.options.height ?? 1.4,
+          t
+        );
+      case "cone":
+        return new i.ConeGeometry(
+          this.options.radius ?? 0.6,
+          this.options.height ?? 1.4,
+          t
+        );
+      case "torus":
+        return new i.TorusGeometry(
+          this.options.radius ?? 0.65,
+          this.options.tube ?? 0.18,
+          14,
+          t
+        );
+      case "plane":
+        return new i.PlaneGeometry(this.options.width ?? 12, this.options.depth ?? 12);
+      default:
+        return new i.BoxGeometry(
+          this.options.width ?? 1,
+          this.options.height ?? 1,
+          this.options.depth ?? 1
+        );
+    }
+  }
+  acquireGeometry() {
+    if (!this.usesSharedResources())
+      return this.createGeometry();
+    const t = this.getGeometryKey(), e = o.get(t);
+    if (e)
+      return e.refs += 1, this.geometryCacheKey = t, e.value;
+    const s = this.createGeometry();
+    return o.set(t, { value: s, refs: 1 }), this.geometryCacheKey = t, s;
+  }
+  acquireMaterial() {
+    if (!this.usesSharedResources())
+      return this.createMaterial();
+    const t = this.getMaterialKey(), e = n.get(t);
+    if (e)
+      return e.refs += 1, this.materialCacheKey = t, e.value;
+    const s = this.createMaterial();
+    return n.set(t, { value: s, refs: 1 }), this.materialCacheKey = t, s;
+  }
+  releaseGeometry() {
+    if (!this.geometry)
+      return;
+    if (!this.geometryCacheKey) {
+      this.geometry.dispose();
+      return;
+    }
+    const t = o.get(this.geometryCacheKey);
+    t && (t.refs -= 1, t.refs <= 0 && (t.value.dispose(), o.delete(this.geometryCacheKey))), this.geometryCacheKey = "";
+  }
+  releaseMaterial() {
+    if (!this.material)
+      return;
+    if (!this.materialCacheKey) {
+      this.material.dispose();
+      return;
+    }
+    const t = n.get(this.materialCacheKey);
+    t && (t.refs -= 1, t.refs <= 0 && (t.value.dispose(), n.delete(this.materialCacheKey))), this.materialCacheKey = "";
+  }
+  createMaterial() {
+    return new i.MeshStandardMaterial({
+      color: this.options.color ?? "#1ec7a6",
+      metalness: this.options.metalness ?? 0.12,
+      roughness: this.options.roughness ?? 0.52
+    });
+  }
+  getGeometryKey() {
+    const t = this.options.segments ?? 32;
+    switch (this.options.kind) {
+      case "sphere":
+        return ["sphere", this.options.radius ?? 0.7, t, 18].join("|");
+      case "cylinder":
+        return [
+          "cylinder",
+          this.options.radiusTop ?? this.options.radius ?? 0.5,
+          this.options.radiusBottom ?? this.options.radius ?? 0.5,
+          this.options.height ?? 1.4,
+          t
+        ].join("|");
+      case "cone":
+        return ["cone", this.options.radius ?? 0.6, this.options.height ?? 1.4, t].join("|");
+      case "torus":
+        return [
+          "torus",
+          this.options.radius ?? 0.65,
+          this.options.tube ?? 0.18,
+          14,
+          t
+        ].join("|");
+      case "plane":
+        return ["plane", this.options.width ?? 12, this.options.depth ?? 12].join("|");
+      default:
+        return [
+          "box",
+          this.options.width ?? 1,
+          this.options.height ?? 1,
+          this.options.depth ?? 1
+        ].join("|");
+    }
+  }
+  getMaterialKey() {
+    return [
+      this.options.color ?? "#1ec7a6",
+      this.options.metalness ?? 0.12,
+      this.options.roughness ?? 0.52
+    ].join("|");
+  }
+  usesSharedResources() {
+    return this.options.sharedResources ?? !0;
+  }
+}
+class y extends a {
+  constructor(t, e = {}) {
+    super(), this.object = t, this.options = e;
+  }
+  object;
+  options;
+  updatesEveryFrame = !1;
+  onStart() {
+    this.entity.object.add(this.object);
+  }
+  onDestroy() {
+    this.object.removeFromParent(), this.options.disposeOnDestroy && h(this.object);
+  }
+  replaceObject(t) {
+    this.object.removeFromParent(), this.options.disposeOnDestroy && h(this.object), this.object = t, this.entity.object.add(this.object);
+  }
+}
+function h(r) {
+  r.traverse((t) => {
+    const e = t;
+    e.geometry?.dispose();
+    const s = e.material;
+    if (Array.isArray(s))
+      for (const c of s)
+        c.dispose();
+    else
+      s?.dispose();
+  });
+}
+class f extends a {
+  target = new i.Vector3();
+  distance;
+  minDistance;
+  maxDistance;
+  azimuth;
+  polar;
+  constructor(t = {}) {
+    super(), this.target.copy(t.target ?? new i.Vector3()), this.distance = t.distance ?? 9, this.minDistance = t.minDistance ?? 4, this.maxDistance = t.maxDistance ?? 18, this.azimuth = t.azimuth ?? Math.PI * 0.25, this.polar = t.polar ?? Math.PI * 0.32;
+  }
+  onUpdate() {
+    const t = this.scene, e = this.engine?.input;
+    if (!t || !e)
+      return;
+    e.isMouseDown(0) && (this.azimuth -= e.pointerDelta.x * 6e-3, this.polar = i.MathUtils.clamp(
+      this.polar - e.pointerDelta.y * 6e-3,
+      0.18,
+      Math.PI * 0.48
+    )), e.wheelDelta !== 0 && (this.distance = i.MathUtils.clamp(
+      this.distance + e.wheelDelta * 0.01,
+      this.minDistance,
+      this.maxDistance
+    ));
+    const s = Math.sin(this.polar) * this.distance;
+    t.camera.position.set(
+      this.target.x + Math.cos(this.azimuth) * s,
+      this.target.y + Math.cos(this.polar) * this.distance,
+      this.target.z + Math.sin(this.azimuth) * s
+    ), t.camera.lookAt(this.target);
+  }
+}
+export {
+  a as C,
+  l as E,
+  p as L,
+  u as M,
+  y as O,
+  m as S,
+  f as a
+};

package/dist/package/Spin3D-BW0UYD9X.js

@@ -0,0 +1,193 @@
+import * as a from "three";
+import { C as f } from "./OrbitCameraController-COklTntj.js";
+class y {
+  constructor(e) {
+    this.canvas = e, window.addEventListener("keydown", this.handleKeyDown), window.addEventListener("keyup", this.handleKeyUp), e.addEventListener("pointermove", this.handlePointerMove), e.addEventListener("pointerdown", this.handlePointerDown), e.addEventListener("pointerup", this.handlePointerUp), e.addEventListener("pointercancel", this.handlePointerUp), e.addEventListener("wheel", this.handleWheel, { passive: !1 });
+  }
+  canvas;
+  pointer = new a.Vector2();
+  pointerDelta = new a.Vector2();
+  wheelDelta = 0;
+  downKeys = /* @__PURE__ */ new Set();
+  pressedKeys = /* @__PURE__ */ new Set();
+  releasedKeys = /* @__PURE__ */ new Set();
+  downButtons = /* @__PURE__ */ new Set();
+  pressedButtons = /* @__PURE__ */ new Set();
+  releasedButtons = /* @__PURE__ */ new Set();
+  isKeyDown(e) {
+    return this.downKeys.has(this.normalizeKey(e));
+  }
+  wasKeyPressed(e) {
+    return this.pressedKeys.has(this.normalizeKey(e));
+  }
+  isAnyKeyDown(e) {
+    return e.some((t) => this.isKeyDown(t));
+  }
+  isMouseDown(e = 0) {
+    return this.downButtons.has(e);
+  }
+  wasMousePressed(e = 0) {
+    return this.pressedButtons.has(e);
+  }
+  endFrame() {
+    this.pointerDelta.set(0, 0), this.wheelDelta = 0, this.pressedKeys.clear(), this.releasedKeys.clear(), this.pressedButtons.clear(), this.releasedButtons.clear();
+  }
+  handleKeyDown = (e) => {
+    const t = this.getKeyAliases(e), s = t.some((i) => this.downKeys.has(i));
+    for (const i of t)
+      this.downKeys.add(i), s || this.pressedKeys.add(i);
+  };
+  handleKeyUp = (e) => {
+    for (const t of this.getKeyAliases(e))
+      this.downKeys.delete(t), this.releasedKeys.add(t);
+  };
+  handlePointerMove = (e) => {
+    const t = this.pointerToCanvas(e);
+    this.pointerDelta.set(t.x - this.pointer.x, t.y - this.pointer.y), this.pointer.copy(t);
+  };
+  handlePointerDown = (e) => {
+    this.canvas.focus(), this.canvas.setPointerCapture(e.pointerId), this.pointer.copy(this.pointerToCanvas(e)), this.downButtons.add(e.button), this.pressedButtons.add(e.button);
+  };
+  handlePointerUp = (e) => {
+    this.pointer.copy(this.pointerToCanvas(e)), this.downButtons.delete(e.button), this.releasedButtons.add(e.button);
+  };
+  handleWheel = (e) => {
+    e.preventDefault(), this.wheelDelta += e.deltaY;
+  };
+  pointerToCanvas(e) {
+    const t = this.canvas.getBoundingClientRect();
+    return new a.Vector2(e.clientX - t.left, e.clientY - t.top);
+  }
+  getKeyAliases(e) {
+    return [e.code, e.key].filter(Boolean).map((t) => this.normalizeKey(t));
+  }
+  normalizeKey(e) {
+    return e.length === 1 ? e.toLowerCase() : e;
+  }
+}
+class S {
+  constructor(e) {
+    this.options = e, this.options.canvas.tabIndex = 0, this.input = new y(this.options.canvas), this.renderer = new a.WebGLRenderer({
+      canvas: this.options.canvas,
+      antialias: !0,
+      alpha: !1,
+      preserveDrawingBuffer: this.options.preserveDrawingBuffer ?? !1,
+      powerPreference: "high-performance"
+    }), this.renderer.setClearColor(new a.Color(e.background ?? "#07100f"), 1), this.configureShadows(e.shadowQuality ?? "off"), this.renderer.outputColorSpace = a.SRGBColorSpace;
+  }
+  options;
+  renderer;
+  input;
+  stats = {
+    fps: 0,
+    frameTimeMs: 0,
+    frameTimeAverageMs: 0,
+    width: 0,
+    height: 0,
+    entities: 0,
+    updatableEntities: 0,
+    drawCalls: 0,
+    triangles: 0,
+    geometries: 0,
+    textures: 0,
+    pixelRatio: 1,
+    qualityScale: 1
+  };
+  activeScene;
+  running = !1;
+  animationFrame = 0;
+  lastTimestamp = 0;
+  fpsElapsed = 0;
+  fpsFrames = 0;
+  qualityScale = 1;
+  frameTimeAverageMs = 0;
+  lastResizeWidth = 0;
+  lastResizeHeight = 0;
+  lastPixelRatio = 0;
+  resizeDirty = !0;
+  slowQualitySamples = 0;
+  fastQualitySamples = 0;
+  setScene(e) {
+    this.activeScene?.stopInternal(), this.activeScene = e, e.startInternal(this), this.resize(), this.renderOnce();
+  }
+  start() {
+    this.running || (this.running = !0, this.lastTimestamp = performance.now(), this.animationFrame = requestAnimationFrame(this.tick));
+  }
+  stop() {
+    this.running = !1, cancelAnimationFrame(this.animationFrame);
+  }
+  renderOnce() {
+    this.resize(), this.activeScene && (this.renderer.render(this.activeScene.threeScene, this.activeScene.camera), this.updateRenderStats());
+  }
+  sampleFrame() {
+    this.renderOnce();
+    const e = this.renderer.getContext(), t = e.drawingBufferWidth, s = e.drawingBufferHeight, i = Math.max(1, Math.min(t, 96)), h = Math.max(1, Math.min(s, 64)), n = Math.floor((t - i) / 2), u = Math.floor((s - h) / 2), r = new Uint8Array(i * h * 4);
+    e.readPixels(n, u, i, h, e.RGBA, e.UNSIGNED_BYTE, r);
+    let m = 0;
+    for (let o = 0; o < r.length; o += 4) {
+      const l = r[o], d = r[o + 1], c = r[o + 2];
+      (Math.max(l, d, c) - Math.min(l, d, c) > 12 || l + d + c > 60) && (m += 1);
+    }
+    return {
+      width: t,
+      height: s,
+      coloredRatio: m / (r.length / 4)
+    };
+  }
+  tick = (e) => {
+    if (!this.running)
+      return;
+    const t = Math.min((e - this.lastTimestamp) / 1e3, 0.05);
+    this.lastTimestamp = e, this.resize();
+    const s = performance.now();
+    this.activeScene?.updateInternal(t), this.activeScene && this.renderer.render(this.activeScene.threeScene, this.activeScene.camera);
+    const i = performance.now() - s;
+    this.stats.frameTimeMs = Math.round(i * 10) / 10, this.updateFrameTimeAverage(i), this.updateFps(t), this.updateRenderStats(), this.input.endFrame(), this.animationFrame = requestAnimationFrame(this.tick);
+  };
+  resize() {
+    const e = this.options.canvas.getBoundingClientRect(), t = Math.max(1, Math.floor(e.width)), s = Math.max(1, Math.floor(e.height)), i = this.options.maxPixelRatio ?? 2, h = this.options.minPixelRatio ?? 0.6, n = Math.round(
+      Math.max(h, Math.min(window.devicePixelRatio || 1, i) * this.qualityScale) * 100
+    ) / 100;
+    this.stats.width = t, this.stats.height = s, this.stats.pixelRatio = n, this.stats.qualityScale = Math.round(this.qualityScale * 100) / 100, !(!this.resizeDirty && t === this.lastResizeWidth && s === this.lastResizeHeight && n === this.lastPixelRatio) && (this.resizeDirty = !1, this.lastResizeWidth = t, this.lastResizeHeight = s, this.lastPixelRatio = n, this.renderer.setPixelRatio(n), this.renderer.setSize(t, s, !1), this.activeScene && (this.activeScene.camera.aspect = t / s, this.activeScene.camera.updateProjectionMatrix()));
+  }
+  updateFrameTimeAverage(e) {
+    this.frameTimeAverageMs = this.frameTimeAverageMs === 0 ? e : this.frameTimeAverageMs * 0.88 + e * 0.12, this.stats.frameTimeAverageMs = Math.round(this.frameTimeAverageMs * 10) / 10;
+  }
+  updateFps(e) {
+    if (this.fpsElapsed += e, this.fpsFrames += 1, this.fpsElapsed >= 0.5) {
+      const t = Math.round(this.fpsFrames / this.fpsElapsed), s = this.options.targetFps ?? 60, i = 1e3 / s;
+      this.stats.fps = this.frameTimeAverageMs <= i ? s : t, this.adjustQualityScale(), this.fpsElapsed = 0, this.fpsFrames = 0;
+    }
+  }
+  updateRenderStats() {
+    const e = this.renderer.info.render, t = this.renderer.info.memory;
+    this.stats.entities = this.activeScene?.entities.length ?? 0, this.stats.updatableEntities = this.activeScene?.updatableEntityCount ?? 0, this.stats.drawCalls = e.calls, this.stats.triangles = e.triangles, this.stats.geometries = t.geometries, this.stats.textures = t.textures;
+  }
+  adjustQualityScale() {
+    const e = 1e3 / (this.options.targetFps ?? 60), t = this.stats.fps > 0 && (this.stats.fps < 40 || this.frameTimeAverageMs > e * 1.45), s = this.stats.fps >= 56 && this.frameTimeAverageMs < e * 1.08;
+    if (t ? (this.slowQualitySamples += 1, this.fastQualitySamples = 0) : s ? (this.fastQualitySamples += 1, this.slowQualitySamples = 0) : (this.slowQualitySamples = 0, this.fastQualitySamples = 0), this.slowQualitySamples >= 2) {
+      this.qualityScale = Math.max(0.55, this.qualityScale - 0.08), this.resizeDirty = !0, this.slowQualitySamples = 0;
+      return;
+    }
+    this.fastQualitySamples >= 4 && this.qualityScale < 1 && (this.qualityScale = Math.min(1, this.qualityScale + 0.04), this.resizeDirty = !0, this.fastQualitySamples = 0);
+  }
+  configureShadows(e) {
+    this.renderer.shadowMap.enabled = e !== "off", this.renderer.shadowMap.enabled && (this.renderer.shadowMap.type = e === "high" ? a.PCFSoftShadowMap : a.PCFShadowMap);
+  }
+}
+class g extends f {
+  constructor(e = 0, t = 1, s = 0) {
+    super(), this.x = e, this.y = t, this.z = s;
+  }
+  x;
+  y;
+  z;
+  onUpdate(e) {
+    this.entity.rotation.x += this.x * e, this.entity.rotation.y += this.y * e, this.entity.rotation.z += this.z * e;
+  }
+}
+export {
+  S as E,
+  y as I,
+  g as S
+};