@relu-interactives/spatial-ecs 0.2.2

package/dist/chunk-XWIEEJ7Z.js

@@ -0,0 +1,1315 @@
+import { resolveDracoDecoderPath, createTransform, applyTransform } from './chunk-AYEF3X2P.js';
+import { AnimationComponent, AudioComponent, Object3DRef, CameraComponent, PhysicsComponent, Environment, EntityType, ImageComponent, ImageTargetAnchor, ImageTarget, LightComponent, MaterialComponent, MeshComponent, MeshGeometryComponent, ModelComponent, Name, ParentId, Postprocessing, ScriptComponent, Selectable, SelectionTransformState, SpriteComponent, TransformComponent, VideoComponent } from './chunk-MAWBTMCG.js';
+import { __name } from './chunk-OY7ZODZP.js';
+import * as THREE20 from 'three';
+import { RectAreaLightHelper } from 'three/examples/jsm/helpers/RectAreaLightHelper.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+
+// core/factories/components/AnimationFactory.ts
+function createAnimationComponent(world, entityId, ...args) {
+  const component = new AnimationComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createAnimationComponent, "createAnimationComponent");
+function normalizeDistanceModel(distanceModel) {
+  const normalized = distanceModel.trim().toLowerCase();
+  if (normalized === "linear" || normalized === "exponential") {
+    return normalized;
+  }
+  return "inverse";
+}
+__name(normalizeDistanceModel, "normalizeDistanceModel");
+function createConfiguredAudio(listener, options) {
+  const sound = options.positional ? new THREE20.PositionalAudio(listener) : new THREE20.Audio(listener);
+  sound.setLoop(options.loop);
+  sound.setVolume(options.volume);
+  sound.setPlaybackRate(options.pitch);
+  if (sound instanceof THREE20.PositionalAudio) {
+    sound.setRefDistance(options.refDistance);
+    sound.setDistanceModel(normalizeDistanceModel(options.distanceModel));
+    sound.setRolloffFactor(options.rolloffFactor);
+  }
+  return sound;
+}
+__name(createConfiguredAudio, "createConfiguredAudio");
+function createAudioEditorHelper() {
+  if (typeof document === "undefined") {
+    const geometry = new THREE20.EdgesGeometry(
+      new THREE20.OctahedronGeometry(0.22, 0)
+    );
+    const material2 = new THREE20.LineBasicMaterial({
+      color: "#8bc8ff",
+      transparent: true,
+      opacity: 0.95,
+      depthTest: false
+    });
+    const fallback = new THREE20.LineSegments(geometry, material2);
+    fallback.renderOrder = 10;
+    fallback.userData.ecsHelper = true;
+    fallback.visible = false;
+    return fallback;
+  }
+  const size = 96;
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return new THREE20.Object3D();
+  }
+  ctx.clearRect(0, 0, size, size);
+  ctx.fillStyle = "rgba(27, 35, 52, 0.9)";
+  ctx.beginPath();
+  ctx.arc(size / 2, size / 2, 36, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.strokeStyle = "rgba(137, 202, 255, 0.9)";
+  ctx.lineWidth = 4;
+  ctx.beginPath();
+  ctx.arc(size / 2, size / 2, 36, 0, Math.PI * 2);
+  ctx.stroke();
+  ctx.fillStyle = "#d9ecff";
+  ctx.beginPath();
+  ctx.moveTo(33, 56);
+  ctx.lineTo(43, 56);
+  ctx.lineTo(54, 66);
+  ctx.lineTo(54, 30);
+  ctx.lineTo(43, 40);
+  ctx.lineTo(33, 40);
+  ctx.closePath();
+  ctx.fill();
+  ctx.strokeStyle = "#7fd2ff";
+  ctx.lineWidth = 4;
+  ctx.lineCap = "round";
+  ctx.beginPath();
+  ctx.arc(56, 48, 10, -0.8, 0.8);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.arc(56, 48, 16, -0.8, 0.8);
+  ctx.stroke();
+  const texture = new THREE20.CanvasTexture(canvas);
+  texture.needsUpdate = true;
+  const material = new THREE20.SpriteMaterial({
+    map: texture,
+    transparent: true,
+    depthTest: false
+  });
+  const helper = new THREE20.Sprite(material);
+  helper.scale.set(0.68, 0.68, 0.68);
+  helper.renderOrder = 10;
+  helper.userData.ecsHelper = true;
+  helper.visible = false;
+  return helper;
+}
+__name(createAudioEditorHelper, "createAudioEditorHelper");
+function createAudioComponent(world, entityId, path = "", options = {}, context) {
+  const component = new AudioComponent(path, options);
+  const anchor = context?.object ?? null;
+  const listener = context?.listener ?? null;
+  if (anchor && listener) {
+    component.object = anchor;
+    const sound = createConfiguredAudio(listener, component.options);
+    if (context?.isEditor) {
+      anchor.add(createAudioEditorHelper());
+    }
+    anchor.add(sound);
+    component.audio = sound;
+  }
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createAudioComponent, "createAudioComponent");
+function createCameraComponent(world, entityId, payload = {}) {
+  const object = world.getComponent(entityId, Object3DRef)?.object;
+  const objectCamera = object instanceof THREE20.Camera ? object : void 0;
+  const component = new CameraComponent({
+    ...payload,
+    camera: payload.camera ?? objectCamera
+  });
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createCameraComponent, "createCameraComponent");
+
+// core/factories/components/PhysicsFactory.ts
+function createPhysicsComponent(world, entityId, values) {
+  const component = new PhysicsComponent(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createPhysicsComponent, "createPhysicsComponent");
+
+// core/factories/components/EnvironmentFactory.ts
+function createEnvironmentComponent(world, entityId, values) {
+  const component = new Environment(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createEnvironmentComponent, "createEnvironmentComponent");
+
+// core/factories/components/EntityTypeFactory.ts
+function createEntityTypeComponent(world, entityId, ...args) {
+  const component = new EntityType(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createEntityTypeComponent, "createEntityTypeComponent");
+
+// core/factories/components/ImageComponentFactory.ts
+function createImageComponent(world, entityId, ...args) {
+  const component = new ImageComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageComponent, "createImageComponent");
+
+// core/factories/components/ImageTargetAnchorFactory.ts
+function createImageTargetAnchorComponent(world, entityId, ...args) {
+  const component = new ImageTargetAnchor(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageTargetAnchorComponent, "createImageTargetAnchorComponent");
+
+// core/factories/components/ImageTargetFactory.ts
+function createImageTargetComponent(world, entityId, ...args) {
+  const component = new ImageTarget(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createImageTargetComponent, "createImageTargetComponent");
+
+// core/factories/components/LightFactory.ts
+function createLightComponent(world, entityId, ...args) {
+  const component = new LightComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createLightComponent, "createLightComponent");
+
+// core/factories/components/MaterialFactory.ts
+function createMaterialComponent(world, entityId, ...args) {
+  const component = new MaterialComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMaterialComponent, "createMaterialComponent");
+
+// core/factories/components/MeshFactory.ts
+function createMeshComponent(world, entityId, ...args) {
+  const component = new MeshComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshComponent, "createMeshComponent");
+
+// core/factories/components/MeshGeometryFactory.ts
+function createMeshGeometryComponent(world, entityId, ...args) {
+  const component = new MeshGeometryComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createMeshGeometryComponent, "createMeshGeometryComponent");
+
+// core/factories/components/ModelFactory.ts
+function createModelComponent(world, entityId, ...args) {
+  const component = new ModelComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createModelComponent, "createModelComponent");
+
+// core/factories/components/NameFactory.ts
+function createNameComponent(world, entityId, ...args) {
+  const component = new Name(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createNameComponent, "createNameComponent");
+
+// core/factories/components/Object3DRefFactory.ts
+function createObject3DRefComponent(world, entityId, ...args) {
+  const component = new Object3DRef(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createObject3DRefComponent, "createObject3DRefComponent");
+
+// core/factories/components/ParentIdFactory.ts
+function createParentIdComponent(world, entityId, ...args) {
+  const component = new ParentId(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createParentIdComponent, "createParentIdComponent");
+
+// core/factories/components/PostprocessingFactory.ts
+function createPostprocessingComponent(world, entityId, values) {
+  const component = new Postprocessing(values);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createPostprocessingComponent, "createPostprocessingComponent");
+
+// core/factories/components/ScriptComponentFactory.ts
+function createScriptComponent(world, entityId, payload = {}) {
+  const entries = Array.isArray(payload.entries) ? payload.entries.map((entry) => ({
+    entityId,
+    className: typeof entry.className === "string" ? entry.className : "",
+    scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
+    enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
+    data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : {},
+    runtimeState: entry.runtimeState,
+    runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
+  })) : [];
+  const component = new ScriptComponent(entries);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createScriptComponent, "createScriptComponent");
+
+// core/factories/components/SelectableFactory.ts
+function createSelectableComponent(world, entityId, ...args) {
+  const component = new Selectable(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSelectableComponent, "createSelectableComponent");
+
+// core/factories/components/SelectionTransformStateFactory.ts
+function createSelectionTransformStateComponent(world, entityId, ...args) {
+  const component = new SelectionTransformState(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSelectionTransformStateComponent, "createSelectionTransformStateComponent");
+
+// core/factories/components/SpriteFactory.ts
+function createSpriteComponent(world, entityId, ...args) {
+  const component = new SpriteComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createSpriteComponent, "createSpriteComponent");
+
+// core/factories/components/TransformFactory.ts
+function createTransformComponent(world, entityId, ...args) {
+  const component = new TransformComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createTransformComponent, "createTransformComponent");
+
+// core/factories/components/VideoFactory.ts
+function createVideoComponent(world, entityId, ...args) {
+  const component = new VideoComponent(...args);
+  world.addComponent(entityId, component);
+  return component;
+}
+__name(createVideoComponent, "createVideoComponent");
+
+// core/factories/registerDefaultComponentFactories.ts
+function registerDefaultComponentFactories(objectManagementSystem) {
+  objectManagementSystem.registerComponentFactory("animation", createAnimationComponent);
+  objectManagementSystem.registerComponentFactory("audio", createAudioComponent);
+  objectManagementSystem.registerComponentFactory("camera", createCameraComponent);
+  objectManagementSystem.registerComponentFactory("physics", createPhysicsComponent);
+  objectManagementSystem.registerComponentFactory("environment", createEnvironmentComponent);
+  objectManagementSystem.registerComponentFactory("entityType", createEntityTypeComponent);
+  objectManagementSystem.registerComponentFactory("image", createImageComponent);
+  objectManagementSystem.registerComponentFactory(
+    "imageTargetAnchor",
+    createImageTargetAnchorComponent
+  );
+  objectManagementSystem.registerComponentFactory("imageTarget", createImageTargetComponent);
+  objectManagementSystem.registerComponentFactory("light", createLightComponent);
+  objectManagementSystem.registerComponentFactory("material", createMaterialComponent);
+  objectManagementSystem.registerComponentFactory("mesh", createMeshComponent);
+  objectManagementSystem.registerComponentFactory(
+    "meshGeometry",
+    createMeshGeometryComponent
+  );
+  objectManagementSystem.registerComponentFactory("model", createModelComponent);
+  objectManagementSystem.registerComponentFactory("name", createNameComponent);
+  objectManagementSystem.registerComponentFactory(
+    "object3DRef",
+    createObject3DRefComponent
+  );
+  objectManagementSystem.registerComponentFactory("parentId", createParentIdComponent);
+  objectManagementSystem.registerComponentFactory(
+    "postprocessing",
+    createPostprocessingComponent
+  );
+  objectManagementSystem.registerComponentFactory("script", createScriptComponent);
+  objectManagementSystem.registerComponentFactory("selectable", createSelectableComponent);
+  objectManagementSystem.registerComponentFactory(
+    "selectionTransformState",
+    createSelectionTransformStateComponent
+  );
+  objectManagementSystem.registerComponentFactory("sprite", createSpriteComponent);
+  objectManagementSystem.registerComponentFactory("transform", createTransformComponent);
+  objectManagementSystem.registerComponentFactory("video", createVideoComponent);
+}
+__name(registerDefaultComponentFactories, "registerDefaultComponentFactories");
+
+// core/factories/objects/shared.ts
+function createBaseEntity(world, object, options) {
+  const entityId = world.createEntity();
+  object.userData.entityId = entityId;
+  const transform = createTransform(options.transformInput);
+  applyTransform(object, transform);
+  world.addComponent(entityId, transform);
+  createObject3DRefComponent(world, entityId, object);
+  createNameComponent(world, entityId, options.label);
+  createEntityTypeComponent(world, entityId, options.entityType);
+  createParentIdComponent(world, entityId, options.parentId ?? null);
+  createSelectableComponent(world, entityId, true);
+  return entityId;
+}
+__name(createBaseEntity, "createBaseEntity");
+
+// core/factories/objects/AudioFactory.ts
+function getOrCreateListener(camera) {
+  const existing = camera.userData.ecsAudioListener;
+  if (existing instanceof THREE20.AudioListener) {
+    return existing;
+  }
+  const listener = new THREE20.AudioListener();
+  camera.add(listener);
+  camera.userData.ecsAudioListener = listener;
+  return listener;
+}
+__name(getOrCreateListener, "getOrCreateListener");
+function createAudio({
+  world,
+  scene,
+  camera,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE20.Object3D();
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Audio",
+    entityType: "audio",
+    transformInput: payload.transform
+  });
+  const audio = createAudioComponent(
+    world,
+    entityId,
+    payload.path ?? "",
+    payload.options ?? {},
+    {
+      object: anchor,
+      listener: getOrCreateListener(camera),
+      isEditor
+    }
+  );
+  scene.add(anchor);
+  if (!audio.path) {
+    return entityId;
+  }
+  if (!isEditor) {
+    const loader = new THREE20.AudioLoader();
+    loader.load(
+      audio.path,
+      (buffer) => {
+        if (!world.hasEntity(entityId)) {
+          return;
+        }
+        const sound = audio.audio;
+        if (!sound) {
+          return;
+        }
+        sound.setBuffer(buffer);
+        if (audio.options.autoplay) {
+          audio.play();
+        }
+      },
+      void 0,
+      (error) => {
+        console.error(`Failed to load audio: ${audio.path}`, error);
+      }
+    );
+  }
+  return entityId;
+}
+__name(createAudio, "createAudio");
+var DEFAULT_NEAR = 0.1;
+var DEFAULT_FAR = 2e3;
+var DEFAULT_FOV = 50;
+var DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT = 5;
+function readViewportAspect() {
+  if (typeof window === "undefined") {
+    return 1;
+  }
+  const width = window.innerWidth;
+  const height = window.innerHeight;
+  if (Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0) {
+    return width / height;
+  }
+  return 1;
+}
+__name(readViewportAspect, "readViewportAspect");
+function toCameraCreateOptions(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const value = input;
+  const type = value.type === "3d" || value.type === "ar" ? value.type : void 0;
+  const projection = value.projection === "orthographic" || value.projection === "perspective" ? value.projection : void 0;
+  return {
+    type,
+    isDefault: typeof value.isDefault === "boolean" ? value.isDefault : void 0,
+    projection,
+    fov: typeof value.fov === "number" && Number.isFinite(value.fov) ? value.fov : void 0,
+    near: typeof value.near === "number" && Number.isFinite(value.near) ? value.near : void 0,
+    far: typeof value.far === "number" && Number.isFinite(value.far) ? value.far : void 0,
+    left: typeof value.left === "number" && Number.isFinite(value.left) ? value.left : void 0,
+    right: typeof value.right === "number" && Number.isFinite(value.right) ? value.right : void 0,
+    top: typeof value.top === "number" && Number.isFinite(value.top) ? value.top : void 0,
+    bottom: typeof value.bottom === "number" && Number.isFinite(value.bottom) ? value.bottom : void 0,
+    zoom: typeof value.zoom === "number" && Number.isFinite(value.zoom) ? value.zoom : void 0
+  };
+}
+__name(toCameraCreateOptions, "toCameraCreateOptions");
+function resolveCameraCreateOptions(payload) {
+  const next = toCameraCreateOptions(payload.options);
+  if (payload.options && typeof payload.options === "object") {
+    return next;
+  }
+  return toCameraCreateOptions(payload.camera);
+}
+__name(resolveCameraCreateOptions, "resolveCameraCreateOptions");
+function applyCameraSettings(camera, options) {
+  const near = typeof options.near === "number" ? options.near : DEFAULT_NEAR;
+  const far = typeof options.far === "number" ? options.far : DEFAULT_FAR;
+  const projection = options.projection;
+  if (camera instanceof THREE20.PerspectiveCamera) {
+    if (!projection || projection === "perspective") {
+      camera.fov = typeof options.fov === "number" ? options.fov : DEFAULT_FOV;
+    }
+    camera.aspect = readViewportAspect();
+    camera.near = near;
+    camera.far = far;
+    camera.updateProjectionMatrix();
+    return;
+  }
+  if (camera instanceof THREE20.OrthographicCamera) {
+    camera.left = typeof options.left === "number" ? options.left : -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.right = typeof options.right === "number" ? options.right : DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.top = typeof options.top === "number" ? options.top : DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.bottom = typeof options.bottom === "number" ? options.bottom : -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    camera.zoom = typeof options.zoom === "number" ? options.zoom : 1;
+    camera.near = near;
+    camera.far = far;
+    camera.updateProjectionMatrix();
+  }
+}
+__name(applyCameraSettings, "applyCameraSettings");
+function createCameraObject(options) {
+  const projection = options.projection ?? "perspective";
+  const near = options.near ?? DEFAULT_NEAR;
+  const far = options.far ?? DEFAULT_FAR;
+  if (projection === "orthographic") {
+    const top = options.top ?? DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const bottom = options.bottom ?? -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const left = options.left ?? -DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const right = options.right ?? DEFAULT_ORTHOGRAPHIC_HALF_HEIGHT;
+    const camera = new THREE20.OrthographicCamera(
+      left,
+      right,
+      top,
+      bottom,
+      near,
+      far
+    );
+    camera.zoom = options.zoom ?? 1;
+    camera.updateProjectionMatrix();
+    return camera;
+  }
+  return new THREE20.PerspectiveCamera(
+    options.fov ?? DEFAULT_FOV,
+    readViewportAspect(),
+    near,
+    far
+  );
+}
+__name(createCameraObject, "createCameraObject");
+function createCamera({ world, scene, camera, payload, isEditor }) {
+  const options = resolveCameraCreateOptions(payload);
+  const useWorldCamera = !isEditor && (payload.useWorldCamera === true || Boolean(options.isDefault));
+  const object = useWorldCamera ? camera : createCameraObject(options);
+  const entityId = createBaseEntity(world, object, {
+    label: payload.name ?? "Camera",
+    entityType: "camera",
+    transformInput: payload.transform
+  });
+  const objectRef = world.getComponent(entityId, Object3DRef);
+  if (objectRef?.object instanceof THREE20.Camera) {
+    objectRef.object.userData.entityId = entityId;
+  }
+  const componentOptions = {
+    camera: object,
+    type: options.type,
+    isDefault: options.isDefault,
+    projection: options.projection,
+    fov: options.fov,
+    near: options.near,
+    far: options.far,
+    left: options.left,
+    right: options.right,
+    top: options.top,
+    bottom: options.bottom,
+    zoom: options.zoom
+  };
+  const component = createCameraComponent(world, entityId, componentOptions);
+  if (useWorldCamera) {
+    applyCameraSettings(object, options);
+  } else {
+    applyCameraSettings(object, options);
+    if (isEditor && component.isDefault) {
+      const helper = new THREE20.CameraHelper(object);
+      helper.onBeforeRender = () => {
+        helper.update();
+      };
+      helper.userData.ecsHelper = true;
+      helper.visible = false;
+      object.add(helper);
+    }
+    scene.add(object);
+  }
+  return entityId;
+}
+__name(createCamera, "createCamera");
+function createCapsule({
+  world,
+  scene,
+  payload
+}) {
+  const geometry = new THREE20.CapsuleGeometry(0.5, 1, 4, 8);
+  const material = new THREE20.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE20.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Capsule",
+    entityType: "capsule",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "capsule", mesh, {
+    radius: 0.5,
+    height: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCapsule, "createCapsule");
+function createCube({ world, scene, payload }) {
+  const geometry = new THREE20.BoxGeometry(1, 1, 1);
+  const material = new THREE20.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE20.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Cube",
+    entityType: "cube",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "cube", mesh, {
+    width: 1,
+    height: 1,
+    depth: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCube, "createCube");
+function createCylinder({
+  world,
+  scene,
+  payload
+}) {
+  const geometry = new THREE20.CylinderGeometry(0.5, 0.5, 1, 20);
+  const material = new THREE20.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE20.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Cylinder",
+    entityType: "cylinder",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "cylinder", mesh, {
+    radius: 0.5,
+    height: 1
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createCylinder, "createCylinder");
+function createEmpty({ world, scene, payload, isEditor }) {
+  const object = new THREE20.Group();
+  const entityId = createBaseEntity(world, object, {
+    label: payload.name ?? "Empty",
+    entityType: "empty",
+    transformInput: payload.transform
+  });
+  scene.add(object);
+  return entityId;
+}
+__name(createEmpty, "createEmpty");
+function createImage({ world, scene, payload }) {
+  const anchor = new THREE20.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Image",
+    entityType: "image",
+    transformInput: payload.transform
+  });
+  const image = createImageComponent(world, entityId, imagePath);
+  image.object = anchor;
+  scene.add(anchor);
+  if (!imagePath) {
+    return entityId;
+  }
+  const loader = new THREE20.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE20.MeshBasicMaterial({
+        map: texture,
+        transparent: true,
+        side: THREE20.DoubleSide
+      });
+      const geometry = new THREE20.PlaneGeometry(1, 1);
+      const plane = new THREE20.Mesh(geometry, material);
+      plane.userData.entityId = entityId;
+      const textureImage = texture.image;
+      const width = textureImage?.width ?? 1;
+      const height = textureImage?.height ?? 1;
+      const aspect = height > 0 ? width / height : 1;
+      image.width = width;
+      image.height = height;
+      plane.scale.set(aspect, 1, 1);
+      anchor.add(plane);
+      image.texture = texture;
+      image.object = plane;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load image: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createImage, "createImage");
+function toImageTargetOptions(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const value = input;
+  const targets = Array.isArray(value.targets) ? value.targets.filter((target) => {
+    if (!target || typeof target !== "object") {
+      return false;
+    }
+    const candidate = target;
+    return typeof candidate.id === "number" && Number.isFinite(candidate.id) && typeof candidate.url === "string" && candidate.url.length > 0 && typeof candidate.width === "number" && Number.isFinite(candidate.width) && typeof candidate.height === "number" && Number.isFinite(candidate.height);
+  }) : void 0;
+  return {
+    targets,
+    compiledTargetUrl: typeof value.compiledTargetUrl === "string" ? value.compiledTargetUrl : void 0,
+    compiledTargetDir: typeof value.compiledTargetDir === "string" ? value.compiledTargetDir : void 0
+  };
+}
+__name(toImageTargetOptions, "toImageTargetOptions");
+function createImageTarget({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE20.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Image Target",
+    entityType: "imageTarget",
+    transformInput: payload.transform
+  });
+  const targetOptions = toImageTargetOptions(payload.options);
+  const imageTarget = createImageTargetComponent(
+    world,
+    entityId,
+    targetOptions
+  );
+  scene.add(anchor);
+  if (!isEditor || !imagePath) {
+    return entityId;
+  }
+  const loader = new THREE20.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE20.MeshBasicMaterial({
+        map: texture,
+        transparent: true,
+        side: THREE20.DoubleSide
+      });
+      const geometry = new THREE20.PlaneGeometry(1, 1);
+      const plane = new THREE20.Mesh(geometry, material);
+      plane.userData.entityId = entityId;
+      const textureImage = texture.image;
+      const width = textureImage?.width ?? 1;
+      const height = textureImage?.height ?? 1;
+      const aspect = height > 0 ? width / height : 1;
+      plane.scale.set(aspect, 1, 1);
+      anchor.add(plane);
+      imageTarget.texture = texture;
+      imageTarget.object = plane;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load image target: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createImageTarget, "createImageTarget");
+function createAmbientLight({
+  world,
+  scene,
+  payload
+}) {
+  const light = new THREE20.AmbientLight("#ffffff", 0.6);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Ambient Light",
+    entityType: "ambientLight",
+    transformInput: payload.transform
+  });
+  createLightComponent(world, entityId, light);
+  scene.add(light);
+  return entityId;
+}
+__name(createAmbientLight, "createAmbientLight");
+function createAreaLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE20.RectAreaLight("#ffffff", 5, 4, 4);
+  light.lookAt(0, 0, 0);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Area Light",
+    entityType: "areaLight",
+    transformInput: payload.transform ?? {
+      position: { x: 0, y: 4, z: 0 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new RectAreaLightHelper(light, "#fb7185");
+    helper.onBeforeRender = () => {
+      helper.updateMatrixWorld(true);
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createAreaLight, "createAreaLight");
+function createDirectionalLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE20.DirectionalLight("#ffffff", 1.5);
+  light.castShadow = true;
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Directional Light",
+    entityType: "directionalLight",
+    transformInput: payload.transform ?? {
+      position: { x: 3, y: 6, z: 4 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE20.DirectionalLightHelper(light, 1.8, "#38bdf8");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createDirectionalLight, "createDirectionalLight");
+function createPointLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE20.PointLight("#ffffff", 1, 10);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Point Light",
+    entityType: "pointLight",
+    transformInput: payload.transform ?? {
+      position: { x: 2, y: 3, z: 2 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE20.PointLightHelper(light, 0.35, "#fbbf24");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createPointLight, "createPointLight");
+function createSpotLight({
+  world,
+  scene,
+  payload,
+  isEditor
+}) {
+  const light = new THREE20.SpotLight("#ffffff", 1, 20, Math.PI / 6, 0.1, 1);
+  const entityId = createBaseEntity(world, light, {
+    label: payload.name ?? "Spot Light",
+    entityType: "spotLight",
+    transformInput: payload.transform ?? {
+      position: { x: 2, y: 5, z: 2 }
+    }
+  });
+  createLightComponent(world, entityId, light);
+  if (isEditor) {
+    const helper = new THREE20.SpotLightHelper(light, "#f59e0b");
+    helper.onBeforeRender = () => {
+      helper.update();
+    };
+    helper.userData.ecsHelper = true;
+    helper.visible = false;
+    light.add(helper);
+  }
+  scene.add(light);
+  return entityId;
+}
+__name(createSpotLight, "createSpotLight");
+var DEFAULT_DRACO_DECODER_PATH = resolveDracoDecoderPath();
+function getModelFileName(path) {
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] ?? "";
+}
+__name(getModelFileName, "getModelFileName");
+function createModelLoader() {
+  const loader = new GLTFLoader();
+  try {
+    const dracoLoader = new DRACOLoader();
+    dracoLoader.setDecoderPath(DEFAULT_DRACO_DECODER_PATH);
+    loader.setDRACOLoader(dracoLoader);
+  } catch (error) {
+    console.warn("DRACOLoader could not be configured. Loading non-Draco models only.", error);
+  }
+  return loader;
+}
+__name(createModelLoader, "createModelLoader");
+function createModel({ world, scene, payload }) {
+  const anchor = new THREE20.Object3D();
+  const modelPath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Model",
+    entityType: "model",
+    transformInput: payload.transform
+  });
+  const model = createModelComponent(world, entityId, modelPath);
+  const meshGeometry = createMeshGeometryComponent(world, entityId, "model", anchor, {}, {
+    modelName: getModelFileName(modelPath),
+    castShadow: false,
+    receiveShadow: false
+  });
+  model.object = anchor;
+  scene.add(anchor);
+  if (!modelPath) {
+    return entityId;
+  }
+  const loader = createModelLoader();
+  loader.load(
+    modelPath,
+    (gltf) => {
+      if (!world.hasEntity(entityId)) {
+        return;
+      }
+      const object = gltf.scene;
+      object.userData.entityId = entityId;
+      object.traverse((child) => {
+        child.userData.entityId = entityId;
+      });
+      anchor.add(object);
+      model.object = object;
+      meshGeometry.object = object;
+      if (gltf.animations.length > 0) {
+        let animation = world.getComponent(entityId, AnimationComponent);
+        if (!animation) {
+          animation = createAnimationComponent(world, entityId, {
+            clips: gltf.animations,
+            externalClipSources: [],
+            paused: false,
+            reverse: false,
+            timeScale: 1,
+            crossFadeDuration: 0
+          });
+        }
+        animation.setModelClips(gltf.animations);
+      }
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load model: ${modelPath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createModel, "createModel");
+function createPlane({ world, scene, payload }) {
+  const geometry = new THREE20.PlaneGeometry(100, 100);
+  const material = new THREE20.MeshStandardMaterial({
+    color: "#ffffff",
+    side: THREE20.DoubleSide
+  });
+  const mesh = new THREE20.Mesh(geometry, material);
+  const entityId = createBaseEntity(
+    world,
+    mesh,
+    {
+      label: payload.name ?? "Plane",
+      entityType: "plane",
+      transformInput: {
+        position: payload.transform?.position,
+        rotation: payload.transform?.rotation ?? {
+          x: -Math.PI / 2,
+          y: 0,
+          z: 0
+        },
+        scale: payload.transform?.scale
+      }
+    }
+  );
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "plane", mesh, {
+    width: 10,
+    height: 10
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createPlane, "createPlane");
+function createSprite({ world, scene, payload }) {
+  const anchor = new THREE20.Object3D();
+  const imagePath = payload.path ?? "";
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Sprite",
+    entityType: "sprite",
+    transformInput: payload.transform
+  });
+  const spriteComponent = createSpriteComponent(world, entityId, imagePath);
+  scene.add(anchor);
+  if (!imagePath) {
+    return entityId;
+  }
+  const loader = new THREE20.TextureLoader();
+  loader.load(
+    imagePath,
+    (texture) => {
+      if (!world.hasEntity(entityId)) {
+        texture.dispose();
+        return;
+      }
+      const material = new THREE20.SpriteMaterial({
+        map: texture,
+        transparent: true
+      });
+      const sprite = new THREE20.Sprite(material);
+      sprite.userData.entityId = entityId;
+      const textureImage = texture.image;
+      spriteComponent.width = textureImage?.width ?? 1;
+      spriteComponent.height = textureImage?.height ?? 1;
+      anchor.add(sprite);
+      spriteComponent.texture = texture;
+      spriteComponent.object = sprite;
+    },
+    void 0,
+    (error) => {
+      console.error(`Failed to load sprite: ${imagePath}`, error);
+    }
+  );
+  return entityId;
+}
+__name(createSprite, "createSprite");
+function createSphere({ world, scene, payload }) {
+  const geometry = new THREE20.SphereGeometry(0.5, 24, 24);
+  const material = new THREE20.MeshStandardMaterial({ color: "#ffffff" });
+  const mesh = new THREE20.Mesh(geometry, material);
+  const entityId = createBaseEntity(world, mesh, {
+    label: payload.name ?? "Sphere",
+    entityType: "sphere",
+    transformInput: payload.transform
+  });
+  createMeshComponent(world, entityId, mesh);
+  createMaterialComponent(world, entityId, material);
+  createMeshGeometryComponent(world, entityId, "sphere", mesh, {
+    radius: 0.5
+  }, {
+    castShadow: false,
+    receiveShadow: false
+  });
+  scene.add(mesh);
+  return entityId;
+}
+__name(createSphere, "createSphere");
+function getOrCreateListener2(camera) {
+  const existing = camera.userData.ecsAudioListener;
+  if (existing instanceof THREE20.AudioListener) {
+    return existing;
+  }
+  const listener = new THREE20.AudioListener();
+  camera.add(listener);
+  camera.userData.ecsAudioListener = listener;
+  return listener;
+}
+__name(getOrCreateListener2, "getOrCreateListener");
+function normalizeDistanceModel2(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "linear" || v === "exponential") return v;
+  return "inverse";
+}
+__name(normalizeDistanceModel2, "normalizeDistanceModel");
+function toBool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+__name(toBool, "toBool");
+function toNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return value;
+}
+__name(toNumber, "toNumber");
+function toColor(value, fallback) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return fallback;
+  }
+  return value;
+}
+__name(toColor, "toColor");
+function normalizeOptions(input) {
+  return {
+    autoplay: toBool(input?.autoplay, false),
+    loop: toBool(input?.loop, true),
+    volume: Math.max(0, Math.min(1, toNumber(input?.volume, 1))),
+    width: Math.max(0.01, toNumber(input?.width, 1)),
+    height: Math.max(0.01, toNumber(input?.height, 1)),
+    isGreenScreen: toBool(input?.isGreenScreen, false),
+    backgroundColor: toColor(input?.backgroundColor, "#00ff00"),
+    similarity: Math.max(0.01, Math.min(1, toNumber(input?.similarity, 0.4))),
+    smoothness: Math.max(1e-3, Math.min(1, toNumber(input?.smoothness, 0.08))),
+    spill: Math.max(0, Math.min(1, toNumber(input?.spill, 0.12))),
+    positional: toBool(input?.positional, false),
+    refDistance: Math.max(0, toNumber(input?.refDistance, 1)),
+    distanceModel: toColor(input?.distanceModel, "inverse"),
+    rolloffFactor: Math.max(0, toNumber(input?.rolloffFactor, 1))
+  };
+}
+__name(normalizeOptions, "normalizeOptions");
+function createChromaMaterial(texture, options) {
+  return new THREE20.ShaderMaterial({
+    uniforms: {
+      tex: { value: texture },
+      keyColor: { value: new THREE20.Color(options.backgroundColor) },
+      similarity: { value: options.similarity },
+      smoothness: { value: options.smoothness },
+      spill: { value: options.spill }
+    },
+    vertexShader: `
+      varying vec2 vUv;
+      void main() {
+        vUv = uv;
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }
+    `,
+    fragmentShader: `
+      uniform sampler2D tex;
+      uniform vec3 keyColor;
+      uniform float similarity;
+      uniform float smoothness;
+      uniform float spill;
+      varying vec2 vUv;
+
+      void main() {
+        vec4 texel = texture2D(tex, vUv);
+        float chromaDist = distance(texel.rgb, keyColor);
+        float alpha = smoothstep(similarity, similarity + smoothness, chromaDist);
+
+        float spillFactor = smoothstep(similarity, similarity + spill + smoothness, chromaDist);
+        vec3 despilled = mix(vec3(dot(texel.rgb, vec3(0.299, 0.587, 0.114))), texel.rgb, spillFactor);
+
+        gl_FragColor = vec4(despilled, texel.a * alpha);
+      }
+    `,
+    transparent: true,
+    side: THREE20.DoubleSide
+  });
+}
+__name(createChromaMaterial, "createChromaMaterial");
+function createStandardMaterial(texture) {
+  return new THREE20.MeshBasicMaterial({
+    map: texture,
+    transparent: true,
+    side: THREE20.DoubleSide
+  });
+}
+__name(createStandardMaterial, "createStandardMaterial");
+function createVideoMesh(entityId, texture, options) {
+  const geometry = new THREE20.PlaneGeometry(1, 1);
+  const material = options.isGreenScreen ? createChromaMaterial(texture, options) : createStandardMaterial(texture);
+  const mesh = new THREE20.Mesh(geometry, material);
+  mesh.userData.entityId = entityId;
+  mesh.scale.set(options.width, options.height, 1);
+  return { mesh, material };
+}
+__name(createVideoMesh, "createVideoMesh");
+function applyMetadataSizing(video, mesh, options) {
+  const width = video.videoWidth;
+  const height = video.videoHeight;
+  if (width <= 0 || height <= 0) {
+    return;
+  }
+  const nextWidth = options.width > 0 ? options.width : width / height;
+  const nextHeight = options.height > 0 ? options.height : 1;
+  mesh.scale.set(nextWidth, nextHeight, 1);
+}
+__name(applyMetadataSizing, "applyMetadataSizing");
+function createVideoElement(path, options) {
+  const video = document.createElement("video");
+  video.src = path;
+  video.crossOrigin = "anonymous";
+  video.loop = options.loop;
+  video.playsInline = true;
+  video.preload = "auto";
+  video.volume = options.volume;
+  return video;
+}
+__name(createVideoElement, "createVideoElement");
+function createVideo({
+  world,
+  scene,
+  camera,
+  payload,
+  isEditor
+}) {
+  const anchor = new THREE20.Object3D();
+  const path = payload.path ?? "";
+  const options = normalizeOptions(payload.options);
+  const entityId = createBaseEntity(world, anchor, {
+    label: payload.name ?? "Video",
+    entityType: "video",
+    transformInput: payload.transform
+  });
+  const videoComponent = createVideoComponent(world, entityId, path, options);
+  videoComponent.object = anchor;
+  scene.add(anchor);
+  if (!path || typeof document === "undefined") {
+    return entityId;
+  }
+  const video = createVideoElement(path, options);
+  const texture = new THREE20.VideoTexture(video);
+  texture.colorSpace = THREE20.SRGBColorSpace;
+  texture.needsUpdate = true;
+  const { mesh, material } = createVideoMesh(entityId, texture, options);
+  anchor.add(mesh);
+  videoComponent.videoElement = video;
+  videoComponent.texture = texture;
+  videoComponent.material = material;
+  videoComponent.object = mesh;
+  video.addEventListener("loadedmetadata", () => {
+    if (!world.hasEntity(entityId)) {
+      return;
+    }
+    applyMetadataSizing(video, mesh, options);
+  });
+  if (!isEditor && options.positional) {
+    const listener = getOrCreateListener2(camera);
+    const audioNode = new THREE20.PositionalAudio(listener);
+    audioNode.setVolume(options.volume);
+    audioNode.setRefDistance(options.refDistance);
+    audioNode.setDistanceModel(normalizeDistanceModel2(options.distanceModel));
+    audioNode.setRolloffFactor(options.rolloffFactor);
+    audioNode.setMediaElementSource(video);
+    video.volume = 1;
+    anchor.add(audioNode);
+    videoComponent.audioNode = audioNode;
+  }
+  if (options.autoplay) {
+    videoComponent.play();
+  }
+  return entityId;
+}
+__name(createVideo, "createVideo");
+
+// core/factories/registerDefaultFactories.ts
+function registerDefaultFactories(objectManagementSystem) {
+  objectManagementSystem.register("cube", createCube);
+  objectManagementSystem.register("sphere", createSphere);
+  objectManagementSystem.register("plane", createPlane);
+  objectManagementSystem.register("capsule", createCapsule);
+  objectManagementSystem.register("cylinder", createCylinder);
+  objectManagementSystem.register("empty", createEmpty);
+  objectManagementSystem.register("model", createModel);
+  objectManagementSystem.register("image", createImage);
+  objectManagementSystem.register("imageTarget", createImageTarget);
+  objectManagementSystem.register("sprite", createSprite);
+  objectManagementSystem.register("audio", createAudio);
+  objectManagementSystem.register("camera", createCamera);
+  objectManagementSystem.register("video", createVideo);
+  objectManagementSystem.register("ambientLight", createAmbientLight);
+  objectManagementSystem.register("directionalLight", createDirectionalLight);
+  objectManagementSystem.register("pointLight", createPointLight);
+  objectManagementSystem.register("spotLight", createSpotLight);
+  objectManagementSystem.register("areaLight", createAreaLight);
+  registerDefaultComponentFactories(objectManagementSystem);
+}
+__name(registerDefaultFactories, "registerDefaultFactories");
+
+export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories };
+//# sourceMappingURL=chunk-XWIEEJ7Z.js.map
+//# sourceMappingURL=chunk-XWIEEJ7Z.js.map